@leofcoin/messages 1.1.2 → 1.1.3

package/dist/messages.esm

@@ -1,599 +1,1377 @@
 /******/ var __webpack_modules__ = ({
 
-/***/ 7187:
-/***/ ((module) => {
-
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-
-var R = typeof Reflect === 'object' ? Reflect : null
-var ReflectApply = R && typeof R.apply === 'function'
-  ? R.apply
-  : function ReflectApply(target, receiver, args) {
-    return Function.prototype.apply.call(target, receiver, args);
-  }
-
-var ReflectOwnKeys
-if (R && typeof R.ownKeys === 'function') {
-  ReflectOwnKeys = R.ownKeys
-} else if (Object.getOwnPropertySymbols) {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target)
-      .concat(Object.getOwnPropertySymbols(target));
-  };
-} else {
-  ReflectOwnKeys = function ReflectOwnKeys(target) {
-    return Object.getOwnPropertyNames(target);
-  };
-}
+/***/ 427:
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
-function ProcessEmitWarning(warning) {
-  if (console && console.warn) console.warn(warning);
-}
+var __webpack_unused_export__;
 
-var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
-  return value !== value;
-}
 
-function EventEmitter() {
-  EventEmitter.init.call(this);
-}
-module.exports = EventEmitter;
-module.exports.once = once;
+__webpack_unused_export__ = ({ value: true });
 
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+var bs32 = __webpack_require__(894);
+var bs58 = __webpack_require__(158);
+var isHex = __webpack_require__(187);
+var varint = __webpack_require__(676);
+var createKeccakHash = __webpack_require__(811);
 
-EventEmitter.prototype._events = undefined;
-EventEmitter.prototype._eventsCount = 0;
-EventEmitter.prototype._maxListeners = undefined;
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-// By default EventEmitters will print a warning if more than 10 listeners are
-// added to it. This is a useful default which helps finding memory leaks.
-var defaultMaxListeners = 10;
+var bs32__default = /*#__PURE__*/_interopDefaultLegacy(bs32);
+var bs58__default = /*#__PURE__*/_interopDefaultLegacy(bs58);
+var isHex__default = /*#__PURE__*/_interopDefaultLegacy(isHex);
+var varint__default = /*#__PURE__*/_interopDefaultLegacy(varint);
+var createKeccakHash__default = /*#__PURE__*/_interopDefaultLegacy(createKeccakHash);
 
-function checkListener(listener) {
-  if (typeof listener !== 'function') {
-    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
-  }
+class BasicInterface$1 {
+  handleDecode() {
+    if (!this.decode) throw new Error('bad implementation: needs decode func')
+    return this.decode()
+  }
+
+  handleEncode() {
+    if (!this.encode) throw new Error('bad implementation: needs encode func')
+    return this.encode()
+  }
+  isHex(string) {
+    return isHex__default["default"](string)
+  }
+  isBase32(string) {
+    return bs32__default["default"].isBase32(string)
+  }
+  isBase58(string) {
+    return bs58__default["default"].isBase58(string)
+  }
+  /**
+   * @param {String} encoded
+   */
+  fromBs32(encoded) {
+    this.encoded = bs32__default["default"].decode(encoded);
+    return this.handleDecode()
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromBs58(encoded) {
+    this.encoded = bs58__default["default"].decode(encoded);
+    return this.handleDecode()
+  }
+
+  async toArray() {
+    const array = [];
+    for await (const value of this.encoded.values()) {
+      array.push(value);
+    }
+    return array
+  }
+
+  fromString(string) {
+    this.encoded = new Uint8Array(string.split(','));
+    return this.handleDecode()
+  }
+
+  fromArray(array) {
+    this.encoded = new Uint8Array([...array]);
+    return this.handleDecode()
+  }
+
+  /**
+   * @param {Buffer} encoded
+   */
+  fromEncoded(encoded) {
+    this.encoded = encoded;
+    return this.handleDecode()
+  }
+
+  /**
+   * @param {String} encoded
+   */
+  fromHex(encoded) {
+    this.encoded = Buffer.from(encoded, 'hex');
+    return this.handleDecode()
+  }
+
+  async toString(encoding = 'utf8') {
+    if (!this.encoded) await this.handleEncode();
+    return this.encoded.toString(encoding)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  toHex() {
+    return this.toString('hex')
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  async toBs32() {
+    if (!this.encoded) await this.handleEncode();
+    return bs32__default["default"].encode(this.encoded)
+  }
+
+  /**
+   * @return {String} encoded
+   */
+  async toBs58() {
+    if (!this.encoded) await this.handleEncode();
+    return bs58__default["default"].encode(this.encoded)
+  }
+
+  /**
+   * @param {Object} data
+   */
+  create(data) {
+    const decoded = {};
+    if (this.keys?.length > 0) {
+      for (const key of this.keys) {
+        Object.defineProperties(decoded, {
+          [key]: {
+            enumerable: true,
+            configurable: true,
+            set: (val) => value = data[key],
+            get: () => data[key]
+          }
+        });
+      }
+
+      this.decoded = decoded;
+      return this.encode()
+    }
+  }
 }
 
-Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
-  enumerable: true,
-  get: function() {
-    return defaultMaxListeners;
-  },
-  set: function(arg) {
-    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
-      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
-    }
-    defaultMaxListeners = arg;
-  }
-});
-
-EventEmitter.init = function() {
+var codecs = {
+  // just a hash
+  'disco-hash': {
+    codec: parseInt('30', 16),
+    hashAlg: 'dbl-keccak-256', // ,
+    // testnet: 'olivia'
+  },
+  'peernet-peer-response': {
+    codec: parseInt('707072', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-peer': {
+    codec: parseInt('7070', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-dht': {
+    codec: parseInt('706468', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-dht-response': {
+    codec: parseInt('706472', 16),
+    hashAlg: 'keccak-256',
+  },
+  // data
+  'peernet-data': {
+    codec: parseInt('706461', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-data-response': {
+    codec: parseInt('70646172', 16),
+    hashAlg: 'keccak-256',
+  },
+  // message
+  'peernet-message': {
+    codec: parseInt('706d65', 16),
+    hashAlg: 'keccak-256',
+  },
+  // pubsub
+  'peernet-ps': {
+    codec: parseInt('707073', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-response': {
+    codec: parseInt('7072', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-request': {
+    codec: parseInt('707271', 16),
+    hashAlg: 'keccak-256',
+  },
+  // normal block
+  'leofcoin-block': {
+    codec: parseInt('6c62', 16),
+    hashAlg: 'dbl-keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  'leofcoin-tx': {
+    codec: parseInt('6c74', 16),
+    hashAlg: 'dbl-keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  // itx
+  'leofcoin-itx': {
+    codec: parseInt('6c69', 16),
+    hashAlg: 'keccak-512', // ,
+    // testnet: 'olivia'
+  },
+  // peer reputation
+  'leofcoin-pr': {
+    codec: parseInt('6c70', 16),
+    hashAlg: 'keccak-256', // ,
+    // testnet: 'olivia'
+  },
+  // chat message
+  'chat-message': {
+    codec: parseInt('636d', 16),
+    hashAlg: 'dbl-keccak-256',
+  },
+  'peernet-file' : {
+    codec: parseInt('7066', 16),
+    hashAlg: 'keccak-256',
+  },
+  'peernet-file-response' : {
+    codec: parseInt('706672', 16),
+    hashAlg: 'keccak-256',
+  }
+};
 
-  if (this._events === undefined ||
-      this._events === Object.getPrototypeOf(this)._events) {
-    this._events = Object.create(null);
-    this._eventsCount = 0;
-  }
-
-  this._maxListeners = this._maxListeners || undefined;
-};
-
-// Obviously not all Emitters should be limited to 10. This function allows
-// that to be increased. Set to zero for unlimited.
-EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
-  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
-    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
-  }
-  this._maxListeners = n;
-  return this;
-};
+class PeernetCodec extends BasicInterface$1 {
+  get codecs() {
+    return {...globalThis.peernet.codecs, ...codecs}
+  }
+  constructor(buffer) {
+    super();
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        const codec = varint__default["default"].decode(buffer);
+        const name = this.getCodecName(codec);
+        if (name) {
+          this.name = name;
+          this.encoded = buffer;
+          this.decode(buffer);
+        } else {
+          this.encode(buffer);
+        }
+      } else if (buffer instanceof ArrayBuffer) {
+        const encoded = new Uint8Array(buffer.byteLength);
+
+        for (let i = 0; i < buffer.byteLength; i++) {
+          encoded[i] = buffer[i];
+        }
+        this.encoded = encoded;
+        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
+        this.decode(buffer);
+        return
+      }
+      if (typeof buffer === 'string') {
+        if (this.codecs[buffer]) this.fromName(buffer);
+        else if (this.isHex(buffer)) this.fromHex(buffer);
+        else if (this.isBase32(buffer)) this.fromBs32(buffer);
+        else if (this.isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
+      }
+      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer);
+    }
+  }
+
+  fromEncoded(encoded) {
+    const codec = varint__default["default"].decode(encoded);
+    const name = this.getCodecName(codec);
+    this.name = name;
+    this.encoded = encoded;
+    this.decode(encoded);
+  }
+
+  getCodec(name) {
+    return this.codecs[name].codec
+  }
+
+  getCodecName(codec) {
+    return Object.keys(this.codecs).reduce((p, c) => {
+      const item = this.codecs[c];
+      if (item.codec === codec) return c;
+      else return p;
+    }, undefined)
+  }
+
+  getHashAlg(name) {
+    return this.codecs[name].hashAlg
+  }
+
+  fromCodec(codec) {
+    this.name = this.getCodecName(codec);
+    this.hashAlg = this.getHashAlg(this.name);
+
+    this.codec = this.getCodec(this.name);
+    this.codecBuffer = varint__default["default"].encode(codec);
+  }
+
+  fromName(name) {
+    const codec = this.getCodec(name);
+    this.name = name;
+    this.codec = codec;
+    this.hashAlg = this.getHashAlg(name);
+    this.codecBuffer = varint__default["default"].encode(codec);
+  }
+
+  decode() {
+    const codec = varint__default["default"].decode(this.encoded);
+    this.fromCodec(codec);
+  }
+
+  encode() {
+    const codec = varint__default["default"].encode(this.decoded);
+    this.encoded = codec;
+    return this.encoded
+  }
+}
 
-function _getMaxListeners(that) {
-  if (that._maxListeners === undefined)
-    return EventEmitter.defaultMaxListeners;
-  return that._maxListeners;
+class CodecHash$1 extends BasicInterface$1 {
+  constructor(buffer, options = {}) {
+    super();
+    if (options.name) this.name = options.name;
+    else this.name = 'disco-hash';
+    if (options.codecs) this.codecs = options.codecs;
+    if (buffer) {
+      if (buffer instanceof Uint8Array) {
+        this.discoCodec = new PeernetCodec(buffer, this.codecs);
+        const name = this.discoCodec.name;
+
+        if (name) {
+          this.name = name;
+          this.decode(buffer);
+        } else {
+          this.encode(buffer);
+        }
+      }
+
+      if (typeof buffer === 'string') {
+        if (this.isHex(buffer)) this.fromHex(buffer);
+        if (this.isBase32(buffer)) this.fromBs32(buffer);
+        else if (this.isBase58(buffer)) this.fromBs58(buffer);
+        else throw new Error(`unsupported string ${buffer}`)
+      } else if (typeof buffer === 'object') this.fromJSON(buffer);
+    }
+  }
+
+  get prefix() {
+    const length = this.length;
+    const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length);
+    uint8Array.set(length);
+    uint8Array.set(this.discoCodec.codecBuffer, length.length);
+
+    return uint8Array
+  }
+
+  get length() {
+    return varint__default["default"].encode(this.size)
+  }
+
+  get buffer() {
+    return this.encoded
+  }
+
+  get hash() {
+    return this.encoded
+  }
+
+  fromJSON(json) {
+    return this.encode(Buffer.from(JSON.stringify(json)))
+  }
+
+  encode(buffer, name) {
+    if (!this.name && name) this.name = name;
+    if (!buffer) buffer = this.buffer;
+    this.discoCodec = new PeernetCodec(this.name, this.codecs);
+    this.discoCodec.fromName(this.name);
+    let hashAlg = this.discoCodec.hashAlg;
+    if (hashAlg.includes('dbl')) {
+      hashAlg = hashAlg.replace('dbl-', '');
+      buffer = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
+    }
+    this.digest = createKeccakHash__default["default"](hashAlg.replace('-', '')).update(buffer).digest();
+    this.size = this.digest.length;
+
+    this.codec = this.discoCodec.encode();
+    this.codec = this.discoCodec.codecBuffer;
+    const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
+    uint8Array.set(this.prefix);
+    uint8Array.set(this.digest, this.prefix.length);
+
+    this.encoded = uint8Array;
+
+    return this.encoded
+  }
+
+  validate(buffer) {
+    if (Buffer.isBuffer(buffer)) {
+      const codec = varint__default["default"].decode(buffer);
+      if (this.codecs[codec]) {
+        this.decode(buffer);
+      } else {
+        this.encode(buffer);
+      }
+    }
+    if (typeof buffer === 'string') {
+      if (this.isHex(buffer)) this.fromHex(buffer);
+      if (this.isBase32(buffer)) this.fromBs32(buffer);
+    }
+    if (typeof buffer === 'object') this.fromJSON(buffer);
+  }
+
+  decode(buffer) {
+    this.encoded = buffer;
+    const codec = varint__default["default"].decode(buffer);
+
+    this.discoCodec = new PeernetCodec(codec, this.codecs);
+    // TODO: validate codec
+    buffer = buffer.slice(varint__default["default"].decode.bytes);
+    this.size = varint__default["default"].decode(buffer);
+    this.digest = buffer.slice(varint__default["default"].decode.bytes);
+    if (this.digest.length !== this.size) {
+      throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`)
+    }
+
+    // const discoCodec = new Codec(codec, this.codecs)
+
+    this.name = this.discoCodec.name;
+
+
+    this.size = this.digest.length;
+
+    return {
+      codec: this.codec,
+      name: this.name,
+      size: this.size,
+      length: this.length,
+      digest: this.digest,
+    }
+  }
 }
 
-EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
-  return _getMaxListeners(this);
-};
+class FormatInterface$1 extends BasicInterface$1 {
+
+  async protoEncode(data) {
+    // check schema
+    return new TextEncoder().encode(data)
+  }
+
+  async protoDecode(data) {
+    // check schema
+    return new TextDecoder().decode(data)
+  }
+
+  async init(buffer) {
+    if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer);
+    else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer);
+    else if (buffer?.name === this.name) return buffer
+    else if (buffer instanceof String) {
+      if (this.isHex(buffer)) await this.fromHex(buffer);
+      else if (this.isBase32(buffer)) await this.fromBs32(buffer);
+      else if (this.isBase58(buffer)) await this.fromBs58(buffer);
+      else throw new Error(`unsupported string ${buffer}`)
+    } else {
+      await this.create(buffer);
+    }
+    return this
+  }
+
+  /**
+   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
+   * @param {Object} proto - {encode, decode}
+   * @param {Object} options - {hashFormat, name}
+   */
+  constructor(buffer, proto, options = {}) {
+    super();
+    this.proto = proto;
+    this.hashFormat = options.hashFormat || 'bs32';
+    if (options.name) this.name = options.name;
+    return this.init(buffer)
+  }
+
+  /**
+   * @return {PeernetHash}
+   */
+  get peernetHash() {
+    return new CodecHash$1(this.decoded, {name: this.name})
+  }
+
+  /**
+   * @return {peernetHash}
+   */
+  get hash() {
+    const upper = this.hashFormat.charAt(0).toUpperCase();
+    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
+    return this.peernetHash[`to${format}`]()
+  }
+
+  /**
+   * @return {Object}
+   */
+  async decode() {
+    let encoded = this.encoded;
+    const discoCodec = new PeernetCodec(this.encoded);
+    encoded = encoded.slice(discoCodec.codecBuffer.length);
+    this.name = discoCodec.name;
+    this.decoded = await this.protoDecode(encoded);
+    try {
+      this.decoded = JSON.parse(this.decoded);
+    } catch {
+      
+    }
+    return this.decoded
+  }
+
+  /**
+   * @return {Buffer}
+   */
+  async encode(decoded) {
+    if (!decoded) decoded = this.decoded;
+    const codec = new PeernetCodec(this.name);
+    const encoded = await this.protoEncode(typeof decoded === 'object' ? JSON.stringify(decoded) : decoded);
+    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
+    uint8Array.set(codec.codecBuffer);
+    uint8Array.set(encoded, codec.codecBuffer.length);
+    this.encoded = uint8Array;
+    return this.encoded
+  }
+
+  hasCodec() {
+    if (!this.encoded) return false
+    const codec = new PeernetCodec(this.encoded);
+    if (codec.name) return true
+  }
+
+  fromUint8Array(buffer) {
+    this.encoded = buffer;
+    return this.hasCodec() ? this.decode() : this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    )
+  }
+
+  fromArrayBuffer(buffer) {
+    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
+    return this.hasCodec() ? this.decode() : this.create(
+      JSON.parse(new TextDecoder().decode(this.encoded))
+    )
+  }
+}
 
-EventEmitter.prototype.emit = function emit(type) {
-  var args = [];
-  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
-  var doError = (type === 'error');
+const BasicInterface = BasicInterface$1;
+const FormatInterface = FormatInterface$1;
+const CodecHash = CodecHash$1;
+const Codec = PeernetCodec;
+const Codecs = codecs;
 
-  var events = this._events;
-  if (events !== undefined)
-    doError = (doError && events.error === undefined);
-  else if (!doError)
-    return false;
+__webpack_unused_export__ = BasicInterface;
+__webpack_unused_export__ = Codec;
+__webpack_unused_export__ = CodecHash;
+__webpack_unused_export__ = Codecs;
+exports.L1 = FormatInterface;
 
-  // If there is no 'error' event listener then throw.
-  if (doError) {
-    var er;
-    if (args.length > 0)
-      er = args[0];
-    if (er instanceof Error) {
-      // Note: The comments on the `throw` lines are intentional, they show
-      // up in Node's output if this results in an unhandled exception.
-      throw er; // Unhandled 'error' event
-    }
-    // At least give some kind of context to the user
-    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
-    err.context = er;
-    throw err; // Unhandled 'error' event
-  }
 
-  var handler = events[type];
+/***/ }),
 
-  if (handler === undefined)
-    return false;
+/***/ 353:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-  if (typeof handler === 'function') {
-    ReflectApply(handler, this, args);
-  } else {
-    var len = handler.length;
-    var listeners = arrayClone(handler, len);
-    for (var i = 0; i < len; ++i)
-      ReflectApply(listeners[i], this, args);
-  }
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "Z": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+const base = ALPHABET => {
+  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
+  const BASE_MAP = new Uint8Array(256)
+  for (let j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255
+  }
+  for (let i = 0; i < ALPHABET.length; i++) {
+    const x = ALPHABET.charAt(i)
+    const xc = x.charCodeAt(0)
+    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
+    BASE_MAP[xc] = i
+  }
+  const BASE = ALPHABET.length
+  const LEADER = ALPHABET.charAt(0)
+  const FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up
+  const iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up
+
+  const encode = source => {
+    if (source instanceof Uint8Array) {
+    } else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source)
+    }
+    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
+    if (source.length === 0) { return '' }
+    // Skip & count leading zeroes.
+    let zeroes = 0
+    let length = 0
+    let pbegin = 0
+    const pend = source.length
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++
+      zeroes++
+    }
+    // Allocate enough space in big-endian base58 representation.
+    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0
+    const b58 = new Uint8Array(size)
+        // Process the bytes.
+    while (pbegin !== pend) {
+      let carry = source[pbegin]
+            // Apply "b58 = b58 * 256 + ch".
+      let i = 0
+      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+        carry += (256 * b58[it1]) >>> 0
+        b58[it1] = (carry % BASE) >>> 0
+        carry = (carry / BASE) >>> 0
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i
+      pbegin++
+    }
+        // Skip leading zeroes in base58 result.
+    let it2 = size - length
+    while (it2 !== size && b58[it2] === 0) {
+      it2++
+    }
+        // Translate the result into a string.
+    let str = LEADER.repeat(zeroes)
+    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }
+    return str
+  }
+  const decodeUnsafe = source => {
+    if (typeof source !== 'string') { throw new TypeError('Expected String') }
+    if (source.length === 0) { return new Uint8Array() }
+    let psz = 0
+        // Skip and count leading '1's.
+    let zeroes = 0
+    let length = 0
+    while (source[psz] === LEADER) {
+      zeroes++
+      psz++
+    }
+    // Allocate enough space in big-endian base256 representation.
+    const size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.
+    let b256 = new Uint8Array(size)
+    // Process the characters.
+    while (source[psz]) {
+      // Decode character
+      let carry = BASE_MAP[source.charCodeAt(psz)]
+      // Invalid character
+      if (carry === 255) { return }
+      let i = 0
+      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+        carry += (BASE * b256[it3]) >>> 0
+        b256[it3] = (carry % 256) >>> 0
+        carry = (carry / 256) >>> 0
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i
+      psz++
+    }
+    // Skip leading zeroes in b256.
+    let it4 = size - length
+    while (it4 !== size && b256[it4] === 0) {
+      it4++
+    }
+    let vch = new Uint8Array(zeroes + (size - it4))
+    let j = zeroes
+    while (it4 !== size) {
+      vch[j++] = b256[it4++]
+    }
+    return vch
+  }
+  const decode = string => {
+    const buffer = decodeUnsafe(string)
+    if (buffer) { return buffer }
+    throw new Error('Non-base' + BASE + ' character')
+  }
+  return {
+    encode: encode,
+    decodeUnsafe: decodeUnsafe,
+    decode: decode
+  }
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (base);
 
-  return true;
-};
 
-function _addListener(target, type, listener, prepend) {
-  var m;
-  var events;
-  var existing;
+/***/ }),
 
-  checkListener(listener);
+/***/ 894:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-  events = target._events;
-  if (events === undefined) {
-    events = target._events = Object.create(null);
-    target._eventsCount = 0;
-  } else {
-    // To avoid recursion in the case that type === "newListener"! Before
-    // adding it to the listeners, first emit "newListener".
-    if (events.newListener !== undefined) {
-      target.emit('newListener', type,
-                  listener.listener ? listener.listener : listener);
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(353);
 
-      // Re-assign `events` because a newListener handler could have caused the
-      // this._events to be assigned to a new object
-      events = target._events;
-    }
-    existing = events[type];
-  }
 
-  if (existing === undefined) {
-    // Optimize the case of one listener. Don't need the extra array object.
-    existing = events[type] = listener;
-    ++target._eventsCount;
-  } else {
-    if (typeof existing === 'function') {
-      // Adding the second element, need to change to array.
-      existing = events[type] =
-        prepend ? [listener, existing] : [existing, listener];
-      // If we've already got an array, just append.
-    } else if (prepend) {
-      existing.unshift(listener);
-    } else {
-      existing.push(listener);
-    }
+const base32 = 'abcdefghijklmnopqrstuvwxyz234567'
+const base32Hex = '0123456789abcdefghijklmnopqrstuv'
 
-    // Check for listener leak
-    m = _getMaxListeners(target);
-    if (m > 0 && existing.length > m && !existing.warned) {
-      existing.warned = true;
-      // No error code for this since it is a Warning
-      // eslint-disable-next-line no-restricted-syntax
-      var w = new Error('Possible EventEmitter memory leak detected. ' +
-                          existing.length + ' ' + String(type) + ' listeners ' +
-                          'added. Use emitter.setMaxListeners() to ' +
-                          'increase limit');
-      w.name = 'MaxListenersExceededWarning';
-      w.emitter = target;
-      w.type = type;
-      w.count = existing.length;
-      ProcessEmitWarning(w);
+const decode = (uint8Array, hex = false) => {
+  const decoder = hex ? (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base32Hex) : (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base32)
+  return decoder.decode(uint8Array)
+}
+
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
+  encode: (uint8Array, hex = false) => {
+    const encoder = hex ? (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base32Hex) : (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base32)
+    return encoder.encode(uint8Array)
+  },
+  decode,
+  isBase32: (uint8Array, hex = false) => {
+    try {
+      decode(uint8Array, hex)
+      return true;
+    } catch (e) {
+      return false;
     }
   }
+});
 
-  return target;
-}
 
-EventEmitter.prototype.addListener = function addListener(type, listener) {
-  return _addListener(this, type, listener, false);
-};
+/***/ }),
 
-EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+/***/ 158:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-EventEmitter.prototype.prependListener =
-    function prependListener(type, listener) {
-      return _addListener(this, type, listener, true);
-    };
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony import */ var _vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(353);
 
-function onceWrapper() {
-  if (!this.fired) {
-    this.target.removeListener(this.type, this.wrapFn);
-    this.fired = true;
-    if (arguments.length === 0)
-      return this.listener.call(this.target);
-    return this.listener.apply(this.target, arguments);
-  }
-}
 
-function _onceWrap(target, type, listener) {
-  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
-  var wrapped = onceWrapper.bind(state);
-  wrapped.listener = listener;
-  state.wrapFn = wrapped;
-  return wrapped;
-}
+const base58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
 
-EventEmitter.prototype.once = function once(type, listener) {
-  checkListener(listener);
-  this.on(type, _onceWrap(this, type, listener));
-  return this;
-};
+const decode = uint8Array => (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base58).decode(uint8Array)
 
-EventEmitter.prototype.prependOnceListener =
-    function prependOnceListener(type, listener) {
-      checkListener(listener);
-      this.prependListener(type, _onceWrap(this, type, listener));
-      return this;
-    };
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
+  encode: uint8Array => (0,_vandeurenglenn_base_x__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z)(base58).encode(uint8Array),
+  decode,
+  isBase58: uint8Array => {
+    try {
+      decode(uint8Array)
+      return true
+    } catch (e) {
+      return false
+    }
+  }
+});
 
-// Emits a 'removeListener' event if and only if the listener was removed.
-EventEmitter.prototype.removeListener =
-    function removeListener(type, listener) {
-      var list, events, position, i, originalListener;
 
-      checkListener(listener);
+/***/ }),
 
-      events = this._events;
-      if (events === undefined)
-        return this;
+/***/ 187:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
-      list = events[type];
-      if (list === undefined)
-        return this;
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
+/* harmony export */ });
+/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (string => /^[A-F0-9]+$/i.test(string));
 
-      if (list === listener || list.listener === listener) {
-        if (--this._eventsCount === 0)
-          this._events = Object.create(null);
-        else {
-          delete events[type];
-          if (events.removeListener)
-            this.emit('removeListener', type, list.listener || listener);
-        }
-      } else if (typeof list !== 'function') {
-        position = -1;
-
-        for (i = list.length - 1; i >= 0; i--) {
-          if (list[i] === listener || list[i].listener === listener) {
-            originalListener = list[i].listener;
-            position = i;
-            break;
-          }
-        }
 
-        if (position < 0)
-          return this;
-
-        if (position === 0)
-          list.shift();
-        else {
-          spliceOne(list, position);
-        }
+/***/ }),
 
-        if (list.length === 1)
-          events[type] = list[0];
+/***/ 370:
+/***/ ((module) => {
 
-        if (events.removeListener !== undefined)
-          this.emit('removeListener', type, originalListener || listener);
-      }
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-      return this;
-    };
 
-EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 
-EventEmitter.prototype.removeAllListeners =
-    function removeAllListeners(type) {
-      var listeners, events, i;
+var R = typeof Reflect === 'object' ? Reflect : null
+var ReflectApply = R && typeof R.apply === 'function'
+  ? R.apply
+  : function ReflectApply(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
+  }
 
-      events = this._events;
-      if (events === undefined)
-        return this;
+var ReflectOwnKeys
+if (R && typeof R.ownKeys === 'function') {
+  ReflectOwnKeys = R.ownKeys
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target)
+      .concat(Object.getOwnPropertySymbols(target));
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target);
+  };
+}
 
-      // not listening for removeListener, no need to emit
-      if (events.removeListener === undefined) {
-        if (arguments.length === 0) {
-          this._events = Object.create(null);
-          this._eventsCount = 0;
-        } else if (events[type] !== undefined) {
-          if (--this._eventsCount === 0)
-            this._events = Object.create(null);
-          else
-            delete events[type];
-        }
-        return this;
-      }
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) console.warn(warning);
+}
 
-      // emit removeListener for all listeners on all events
-      if (arguments.length === 0) {
-        var keys = Object.keys(events);
-        var key;
-        for (i = 0; i < keys.length; ++i) {
-          key = keys[i];
-          if (key === 'removeListener') continue;
-          this.removeAllListeners(key);
-        }
-        this.removeAllListeners('removeListener');
-        this._events = Object.create(null);
-        this._eventsCount = 0;
-        return this;
-      }
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+  return value !== value;
+}
 
-      listeners = events[type];
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+module.exports = EventEmitter;
+module.exports.once = once;
 
-      if (typeof listeners === 'function') {
-        this.removeListener(type, listeners);
-      } else if (listeners !== undefined) {
-        // LIFO order
-        for (i = listeners.length - 1; i >= 0; i--) {
-          this.removeListener(type, listeners[i]);
-        }
-      }
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
 
-      return this;
-    };
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
 
-function _listeners(target, type, unwrap) {
-  var events = target._events;
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
 
-  if (events === undefined)
-    return [];
+function checkListener(listener) {
+  if (typeof listener !== 'function') {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
 
-  var evlistener = events[type];
-  if (evlistener === undefined)
-    return [];
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+  enumerable: true,
+  get: function() {
+    return defaultMaxListeners;
+  },
+  set: function(arg) {
+    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+    }
+    defaultMaxListeners = arg;
+  }
+});
 
-  if (typeof evlistener === 'function')
-    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+EventEmitter.init = function() {
 
-  return unwrap ?
-    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
-}
+  if (this._events === undefined ||
+      this._events === Object.getPrototypeOf(this)._events) {
+    this._events = Object.create(null);
+    this._eventsCount = 0;
+  }
 
-EventEmitter.prototype.listeners = function listeners(type) {
-  return _listeners(this, type, true);
+  this._maxListeners = this._maxListeners || undefined;
 };
 
-EventEmitter.prototype.rawListeners = function rawListeners(type) {
-  return _listeners(this, type, false);
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+  }
+  this._maxListeners = n;
+  return this;
 };
 
-EventEmitter.listenerCount = function(emitter, type) {
-  if (typeof emitter.listenerCount === 'function') {
-    return emitter.listenerCount(type);
-  } else {
-    return listenerCount.call(emitter, type);
-  }
+function _getMaxListeners(that) {
+  if (that._maxListeners === undefined)
+    return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
 };
 
-EventEmitter.prototype.listenerCount = listenerCount;
-function listenerCount(type) {
-  var events = this._events;
+EventEmitter.prototype.emit = function emit(type) {
+  var args = [];
+  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+  var doError = (type === 'error');
 
-  if (events !== undefined) {
-    var evlistener = events[type];
+  var events = this._events;
+  if (events !== undefined)
+    doError = (doError && events.error === undefined);
+  else if (!doError)
+    return false;
 
-    if (typeof evlistener === 'function') {
-      return 1;
-    } else if (evlistener !== undefined) {
-      return evlistener.length;
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+    var er;
+    if (args.length > 0)
+      er = args[0];
+    if (er instanceof Error) {
+      // Note: The comments on the `throw` lines are intentional, they show
+      // up in Node's output if this results in an unhandled exception.
+      throw er; // Unhandled 'error' event
     }
+    // At least give some kind of context to the user
+    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+    err.context = er;
+    throw err; // Unhandled 'error' event
   }
 
-  return 0;
-}
+  var handler = events[type];
 
-EventEmitter.prototype.eventNames = function eventNames() {
-  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
-};
+  if (handler === undefined)
+    return false;
 
-function arrayClone(arr, n) {
-  var copy = new Array(n);
-  for (var i = 0; i < n; ++i)
-    copy[i] = arr[i];
-  return copy;
-}
+  if (typeof handler === 'function') {
+    ReflectApply(handler, this, args);
+  } else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      ReflectApply(listeners[i], this, args);
+  }
 
-function spliceOne(list, index) {
-  for (; index + 1 < list.length; index++)
-    list[index] = list[index + 1];
-  list.pop();
-}
+  return true;
+};
 
-function unwrapListeners(arr) {
-  var ret = new Array(arr.length);
-  for (var i = 0; i < ret.length; ++i) {
-    ret[i] = arr[i].listener || arr[i];
-  }
-  return ret;
-}
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events;
+  var existing;
 
-function once(emitter, name) {
-  return new Promise(function (resolve, reject) {
-    function errorListener(err) {
-      emitter.removeListener(name, resolver);
-      reject(err);
-    }
+  checkListener(listener);
 
-    function resolver() {
-      if (typeof emitter.removeListener === 'function') {
-        emitter.removeListener('error', errorListener);
-      }
-      resolve([].slice.call(arguments));
-    };
+  events = target._events;
+  if (events === undefined) {
+    events = target._events = Object.create(null);
+    target._eventsCount = 0;
+  } else {
+    // To avoid recursion in the case that type === "newListener"! Before
+    // adding it to the listeners, first emit "newListener".
+    if (events.newListener !== undefined) {
+      target.emit('newListener', type,
+                  listener.listener ? listener.listener : listener);
 
-    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
-    if (name !== 'error') {
-      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+      // Re-assign `events` because a newListener handler could have caused the
+      // this._events to be assigned to a new object
+      events = target._events;
     }
-  });
-}
-
-function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
-  if (typeof emitter.on === 'function') {
-    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+    existing = events[type];
   }
-}
 
-function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
-  if (typeof emitter.on === 'function') {
-    if (flags.once) {
-      emitter.once(name, listener);
+  if (existing === undefined) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === 'function') {
+      // Adding the second element, need to change to array.
+      existing = events[type] =
+        prepend ? [listener, existing] : [existing, listener];
+      // If we've already got an array, just append.
+    } else if (prepend) {
+      existing.unshift(listener);
     } else {
-      emitter.on(name, listener);
+      existing.push(listener);
+    }
+
+    // Check for listener leak
+    m = _getMaxListeners(target);
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      // No error code for this since it is a Warning
+      // eslint-disable-next-line no-restricted-syntax
+      var w = new Error('Possible EventEmitter memory leak detected. ' +
+                          existing.length + ' ' + String(type) + ' listeners ' +
+                          'added. Use emitter.setMaxListeners() to ' +
+                          'increase limit');
+      w.name = 'MaxListenersExceededWarning';
+      w.emitter = target;
+      w.type = type;
+      w.count = existing.length;
+      ProcessEmitWarning(w);
     }
-  } else if (typeof emitter.addEventListener === 'function') {
-    // EventTarget does not have `error` event semantics like Node
-    // EventEmitters, we do not listen for `error` events here.
-    emitter.addEventListener(name, function wrapListener(arg) {
-      // IE does not have builtin `{ once: true }` support so we
-      // have to do it manually.
-      if (flags.once) {
-        emitter.removeEventListener(name, wrapListener);
-      }
-      listener(arg);
-    });
-  } else {
-    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
   }
+
+  return target;
 }
 
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
 
-/***/ }),
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
 
-/***/ 5717:
-/***/ ((module) => {
+EventEmitter.prototype.prependListener =
+    function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
 
-if (typeof Object.create === 'function') {
-  // implementation from standard node.js 'util' module
-  module.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor
-      ctor.prototype = Object.create(superCtor.prototype, {
-        constructor: {
-          value: ctor,
-          enumerable: false,
-          writable: true,
-          configurable: true
-        }
-      })
-    }
-  };
-} else {
-  // old school shim for old browsers
-  module.exports = function inherits(ctor, superCtor) {
-    if (superCtor) {
-      ctor.super_ = superCtor
-      var TempCtor = function () {}
-      TempCtor.prototype = superCtor.prototype
-      ctor.prototype = new TempCtor()
-      ctor.prototype.constructor = ctor
-    }
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    if (arguments.length === 0)
+      return this.listener.call(this.target);
+    return this.listener.apply(this.target, arguments);
   }
 }
 
+function _onceWrap(target, type, listener) {
+  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+  var wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
 
-/***/ }),
+EventEmitter.prototype.once = function once(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
 
-/***/ 5811:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+EventEmitter.prototype.prependOnceListener =
+    function prependOnceListener(type, listener) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
 
-module.exports = __webpack_require__(6066)(__webpack_require__(9653))
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+    function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
 
+      checkListener(listener);
 
-/***/ }),
+      events = this._events;
+      if (events === undefined)
+        return this;
 
-/***/ 6066:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+      list = events[type];
+      if (list === undefined)
+        return this;
 
-const createKeccak = __webpack_require__(7016)
-const createShake = __webpack_require__(5675)
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit('removeListener', type, list.listener || listener);
+        }
+      } else if (typeof list !== 'function') {
+        position = -1;
 
-module.exports = function (KeccakState) {
-  const Keccak = createKeccak(KeccakState)
-  const Shake = createShake(KeccakState)
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
 
-  return function (algorithm, options) {
-    const hash = typeof algorithm === 'string' ? algorithm.toLowerCase() : algorithm
-    switch (hash) {
-      case 'keccak224': return new Keccak(1152, 448, null, 224, options)
-      case 'keccak256': return new Keccak(1088, 512, null, 256, options)
-      case 'keccak384': return new Keccak(832, 768, null, 384, options)
-      case 'keccak512': return new Keccak(576, 1024, null, 512, options)
+        if (position < 0)
+          return this;
 
-      case 'sha3-224': return new Keccak(1152, 448, 0x06, 224, options)
-      case 'sha3-256': return new Keccak(1088, 512, 0x06, 256, options)
-      case 'sha3-384': return new Keccak(832, 768, 0x06, 384, options)
-      case 'sha3-512': return new Keccak(576, 1024, 0x06, 512, options)
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
 
-      case 'shake128': return new Shake(1344, 256, 0x1f, options)
-      case 'shake256': return new Shake(1088, 512, 0x1f, options)
+        if (list.length === 1)
+          events[type] = list[0];
 
-      default: throw new Error('Invald algorithm: ' + algorithm)
-    }
-  }
-}
+        if (events.removeListener !== undefined)
+          this.emit('removeListener', type, originalListener || listener);
+      }
 
+      return this;
+    };
 
-/***/ }),
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
 
-/***/ 7016:
-/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+EventEmitter.prototype.removeAllListeners =
+    function removeAllListeners(type) {
+      var listeners, events, i;
 
-const { Transform } = __webpack_require__(8473)
+      events = this._events;
+      if (events === undefined)
+        return this;
 
-module.exports = (KeccakState) => class Keccak extends Transform {
-  constructor (rate, capacity, delimitedSuffix, hashBitLength, options) {
-    super(options)
+      // not listening for removeListener, no need to emit
+      if (events.removeListener === undefined) {
+        if (arguments.length === 0) {
+          this._events = Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== undefined) {
+          if (--this._eventsCount === 0)
+            this._events = Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
 
-    this._rate = rate
-    this._capacity = capacity
-    this._delimitedSuffix = delimitedSuffix
-    this._hashBitLength = hashBitLength
-    this._options = options
+      // emit removeListener for all listeners on all events
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === 'removeListener') continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners('removeListener');
+        this._events = Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+
+      listeners = events[type];
+
+      if (typeof listeners === 'function') {
+        this.removeListener(type, listeners);
+      } else if (listeners !== undefined) {
+        // LIFO order
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+
+      return this;
+    };
+
+function _listeners(target, type, unwrap) {
+  var events = target._events;
+
+  if (events === undefined)
+    return [];
+
+  var evlistener = events[type];
+  if (evlistener === undefined)
+    return [];
+
+  if (typeof evlistener === 'function')
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+  return unwrap ?
+    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === 'function') {
+    return emitter.listenerCount(type);
+  } else {
+    return listenerCount.call(emitter, type);
+  }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events = this._events;
+
+  if (events !== undefined) {
+    var evlistener = events[type];
+
+    if (typeof evlistener === 'function') {
+      return 1;
+    } else if (evlistener !== undefined) {
+      return evlistener.length;
+    }
+  }
+
+  return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr, n) {
+  var copy = new Array(n);
+  for (var i = 0; i < n; ++i)
+    copy[i] = arr[i];
+  return copy;
+}
+
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++)
+    list[index] = list[index + 1];
+  list.pop();
+}
+
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
+
+function once(emitter, name) {
+  return new Promise(function (resolve, reject) {
+    function errorListener(err) {
+      emitter.removeListener(name, resolver);
+      reject(err);
+    }
+
+    function resolver() {
+      if (typeof emitter.removeListener === 'function') {
+        emitter.removeListener('error', errorListener);
+      }
+      resolve([].slice.call(arguments));
+    };
+
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== 'error') {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
+}
+
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === 'function') {
+    // EventTarget does not have `error` event semantics like Node
+    // EventEmitters, we do not listen for `error` events here.
+    emitter.addEventListener(name, function wrapListener(arg) {
+      // IE does not have builtin `{ once: true }` support so we
+      // have to do it manually.
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}
+
+
+/***/ }),
+
+/***/ 717:
+/***/ ((module) => {
+
+if (typeof Object.create === 'function') {
+  // implementation from standard node.js 'util' module
+  module.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor
+      ctor.prototype = Object.create(superCtor.prototype, {
+        constructor: {
+          value: ctor,
+          enumerable: false,
+          writable: true,
+          configurable: true
+        }
+      })
+    }
+  };
+} else {
+  // old school shim for old browsers
+  module.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+      ctor.super_ = superCtor
+      var TempCtor = function () {}
+      TempCtor.prototype = superCtor.prototype
+      ctor.prototype = new TempCtor()
+      ctor.prototype.constructor = ctor
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 811:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = __webpack_require__(66)(__webpack_require__(653))
+
+
+/***/ }),
+
+/***/ 66:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const createKeccak = __webpack_require__(16)
+const createShake = __webpack_require__(675)
+
+module.exports = function (KeccakState) {
+  const Keccak = createKeccak(KeccakState)
+  const Shake = createShake(KeccakState)
+
+  return function (algorithm, options) {
+    const hash = typeof algorithm === 'string' ? algorithm.toLowerCase() : algorithm
+    switch (hash) {
+      case 'keccak224': return new Keccak(1152, 448, null, 224, options)
+      case 'keccak256': return new Keccak(1088, 512, null, 256, options)
+      case 'keccak384': return new Keccak(832, 768, null, 384, options)
+      case 'keccak512': return new Keccak(576, 1024, null, 512, options)
+
+      case 'sha3-224': return new Keccak(1152, 448, 0x06, 224, options)
+      case 'sha3-256': return new Keccak(1088, 512, 0x06, 256, options)
+      case 'sha3-384': return new Keccak(832, 768, 0x06, 384, options)
+      case 'sha3-512': return new Keccak(576, 1024, 0x06, 512, options)
+
+      case 'shake128': return new Shake(1344, 256, 0x1f, options)
+      case 'shake256': return new Shake(1088, 512, 0x1f, options)
+
+      default: throw new Error('Invald algorithm: ' + algorithm)
+    }
+  }
+}
+
+
+/***/ }),
+
+/***/ 16:
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const { Transform } = __webpack_require__(473)
+
+module.exports = (KeccakState) => class Keccak extends Transform {
+  constructor (rate, capacity, delimitedSuffix, hashBitLength, options) {
+    super(options)
+
+    this._rate = rate
+    this._capacity = capacity
+    this._delimitedSuffix = delimitedSuffix
+    this._hashBitLength = hashBitLength
+    this._options = options
 
     this._state = new KeccakState()
     this._state.initialize(rate, capacity)
@@ -664,10 +1442,10 @@ module.exports = (KeccakState) => class Keccak extends Transform {
 
 /***/ }),
 
-/***/ 5675:
+/***/ 675:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const { Transform } = __webpack_require__(8473)
+const { Transform } = __webpack_require__(473)
 
 module.exports = (KeccakState) => class Shake extends Transform {
   constructor (rate, capacity, delimitedSuffix, options) {
@@ -739,7 +1517,7 @@ module.exports = (KeccakState) => class Shake extends Transform {
 
 /***/ }),
 
-/***/ 4040:
+/***/ 40:
 /***/ ((__unused_webpack_module, exports) => {
 
 const P1600_ROUND_CONSTANTS = [1, 0, 32898, 0, 32906, 2147483648, 2147516416, 2147483648, 32907, 0, 2147483649, 0, 2147516545, 2147483648, 32777, 2147483648, 138, 0, 136, 0, 2147516425, 0, 2147483658, 0, 2147516555, 0, 139, 2147483648, 32905, 2147483648, 32771, 2147483648, 32770, 2147483648, 128, 2147483648, 32778, 0, 2147483658, 2147483648, 2147516545, 2147483648, 32896, 2147483648, 2147483649, 0, 2147516424, 2147483648]
@@ -932,10 +1710,10 @@ exports.p1600 = function (s) {
 
 /***/ }),
 
-/***/ 9653:
+/***/ 653:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-const keccakState = __webpack_require__(4040)
+const keccakState = __webpack_require__(40)
 
 function Keccak () {
   // much faster than `new Array(50)`
@@ -1007,7 +1785,7 @@ module.exports = Keccak
 
 /***/ }),
 
-/***/ 4281:
+/***/ 281:
 /***/ ((module) => {
 
 
@@ -1141,7 +1919,7 @@ module.exports.q = codes;
 
 /***/ }),
 
-/***/ 6753:
+/***/ 753:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // Copyright Joyent, Inc. and other Node contributors.
@@ -1185,11 +1963,11 @@ var objectKeys = Object.keys || function (obj) {
 
 module.exports = Duplex;
 
-var Readable = __webpack_require__(9481);
+var Readable = __webpack_require__(481);
 
-var Writable = __webpack_require__(4229);
+var Writable = __webpack_require__(229);
 
-__webpack_require__(5717)(Duplex, Readable);
+__webpack_require__(717)(Duplex, Readable);
 
 {
   // Allow the keys array to be GC'ed.
@@ -1286,7 +2064,7 @@ Object.defineProperty(Duplex.prototype, 'destroyed', {
 
 /***/ }),
 
-/***/ 2725:
+/***/ 725:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // Copyright Joyent, Inc. and other Node contributors.
@@ -1316,9 +2094,9 @@ Object.defineProperty(Duplex.prototype, 'destroyed', {
 
 module.exports = PassThrough;
 
-var Transform = __webpack_require__(4605);
+var Transform = __webpack_require__(605);
 
-__webpack_require__(5717)(PassThrough, Transform);
+__webpack_require__(717)(PassThrough, Transform);
 
 function PassThrough(options) {
   if (!(this instanceof PassThrough)) return new PassThrough(options);
@@ -1331,7 +2109,7 @@ PassThrough.prototype._transform = function (chunk, encoding, cb) {
 
 /***/ }),
 
-/***/ 9481:
+/***/ 481:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // Copyright Joyent, Inc. and other Node contributors.
@@ -1365,7 +2143,7 @@ var Duplex;
 Readable.ReadableState = ReadableState;
 /*<replacement>*/
 
-var EE = (__webpack_require__(7187).EventEmitter);
+var EE = (__webpack_require__(370).EventEmitter);
 
 var EElistenerCount = function EElistenerCount(emitter, type) {
   return emitter.listeners(type).length;
@@ -1375,11 +2153,11 @@ var EElistenerCount = function EElistenerCount(emitter, type) {
 /*<replacement>*/
 
 
-var Stream = __webpack_require__(2503);
+var Stream = __webpack_require__(503);
 /*</replacement>*/
 
 
-var Buffer = (__webpack_require__(5291).Buffer);
+var Buffer = (__webpack_require__(291).Buffer);
 
 var OurUint8Array = __webpack_require__.g.Uint8Array || function () {};
 
@@ -1393,7 +2171,7 @@ function _isUint8Array(obj) {
 /*<replacement>*/
 
 
-var debugUtil = __webpack_require__(4616);
+var debugUtil = __webpack_require__(616);
 
 var debug;
 
@@ -1405,14 +2183,14 @@ if (debugUtil && debugUtil.debuglog) {
 /*</replacement>*/
 
 
-var BufferList = __webpack_require__(7327);
+var BufferList = __webpack_require__(327);
 
-var destroyImpl = __webpack_require__(1195);
+var destroyImpl = __webpack_require__(195);
 
-var _require = __webpack_require__(2457),
+var _require = __webpack_require__(457),
     getHighWaterMark = _require.getHighWaterMark;
 
-var _require$codes = (__webpack_require__(4281)/* .codes */ .q),
+var _require$codes = (__webpack_require__(281)/* .codes */ .q),
     ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
     ERR_STREAM_PUSH_AFTER_EOF = _require$codes.ERR_STREAM_PUSH_AFTER_EOF,
     ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
@@ -1423,7 +2201,7 @@ var StringDecoder;
 var createReadableStreamAsyncIterator;
 var from;
 
-__webpack_require__(5717)(Readable, Stream);
+__webpack_require__(717)(Readable, Stream);
 
 var errorOrDestroy = destroyImpl.errorOrDestroy;
 var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
@@ -1440,7 +2218,7 @@ function prependListener(emitter, event, fn) {
 }
 
 function ReadableState(options, stream, isDuplex) {
-  Duplex = Duplex || __webpack_require__(6753);
+  Duplex = Duplex || __webpack_require__(753);
   options = options || {}; // Duplex streams are both readable and writable, but share
   // the same options object.
   // However, some cases require setting options to different
@@ -1496,14 +2274,14 @@ function ReadableState(options, stream, isDuplex) {
   this.encoding = null;
 
   if (options.encoding) {
-    if (!StringDecoder) StringDecoder = (__webpack_require__(2553)/* .StringDecoder */ .s);
+    if (!StringDecoder) StringDecoder = (__webpack_require__(553)/* .StringDecoder */ .s);
     this.decoder = new StringDecoder(options.encoding);
     this.encoding = options.encoding;
   }
 }
 
 function Readable(options) {
-  Duplex = Duplex || __webpack_require__(6753);
+  Duplex = Duplex || __webpack_require__(753);
   if (!(this instanceof Readable)) return new Readable(options); // Checking for a Stream.Duplex instance is faster here instead of inside
   // the ReadableState constructor, at least with V8 6.5
 
@@ -1658,7 +2436,7 @@ Readable.prototype.isPaused = function () {
 
 
 Readable.prototype.setEncoding = function (enc) {
-  if (!StringDecoder) StringDecoder = (__webpack_require__(2553)/* .StringDecoder */ .s);
+  if (!StringDecoder) StringDecoder = (__webpack_require__(553)/* .StringDecoder */ .s);
   var decoder = new StringDecoder(enc);
   this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8
 
@@ -2342,7 +3120,7 @@ Readable.prototype.wrap = function (stream) {
 if (typeof Symbol === 'function') {
   Readable.prototype[Symbol.asyncIterator] = function () {
     if (createReadableStreamAsyncIterator === undefined) {
-      createReadableStreamAsyncIterator = __webpack_require__(5850);
+      createReadableStreamAsyncIterator = __webpack_require__(850);
     }
 
     return createReadableStreamAsyncIterator(this);
@@ -2444,7 +3222,7 @@ function endReadableNT(state, stream) {
 if (typeof Symbol === 'function') {
   Readable.from = function (iterable, opts) {
     if (from === undefined) {
-      from = __webpack_require__(5167);
+      from = __webpack_require__(167);
     }
 
     return from(Readable, iterable, opts);
@@ -2461,7 +3239,7 @@ function indexOf(xs, x) {
 
 /***/ }),
 
-/***/ 4605:
+/***/ 605:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // Copyright Joyent, Inc. and other Node contributors.
@@ -2529,15 +3307,15 @@ function indexOf(xs, x) {
 
 module.exports = Transform;
 
-var _require$codes = (__webpack_require__(4281)/* .codes */ .q),
+var _require$codes = (__webpack_require__(281)/* .codes */ .q),
     ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
     ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
     ERR_TRANSFORM_ALREADY_TRANSFORMING = _require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING,
     ERR_TRANSFORM_WITH_LENGTH_0 = _require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
 
-var Duplex = __webpack_require__(6753);
+var Duplex = __webpack_require__(753);
 
-__webpack_require__(5717)(Transform, Duplex);
+__webpack_require__(717)(Transform, Duplex);
 
 function afterTransform(er, data) {
   var ts = this._transformState;
@@ -2668,7 +3446,7 @@ function done(stream, er, data) {
 
 /***/ }),
 
-/***/ 4229:
+/***/ 229:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // Copyright Joyent, Inc. and other Node contributors.
@@ -2730,17 +3508,17 @@ Writable.WritableState = WritableState;
 /*<replacement>*/
 
 var internalUtil = {
-  deprecate: __webpack_require__(4927)
+  deprecate: __webpack_require__(927)
 };
 /*</replacement>*/
 
 /*<replacement>*/
 
-var Stream = __webpack_require__(2503);
+var Stream = __webpack_require__(503);
 /*</replacement>*/
 
 
-var Buffer = (__webpack_require__(5291).Buffer);
+var Buffer = (__webpack_require__(291).Buffer);
 
 var OurUint8Array = __webpack_require__.g.Uint8Array || function () {};
 
@@ -2752,12 +3530,12 @@ function _isUint8Array(obj) {
   return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
 }
 
-var destroyImpl = __webpack_require__(1195);
+var destroyImpl = __webpack_require__(195);
 
-var _require = __webpack_require__(2457),
+var _require = __webpack_require__(457),
     getHighWaterMark = _require.getHighWaterMark;
 
-var _require$codes = (__webpack_require__(4281)/* .codes */ .q),
+var _require$codes = (__webpack_require__(281)/* .codes */ .q),
     ERR_INVALID_ARG_TYPE = _require$codes.ERR_INVALID_ARG_TYPE,
     ERR_METHOD_NOT_IMPLEMENTED = _require$codes.ERR_METHOD_NOT_IMPLEMENTED,
     ERR_MULTIPLE_CALLBACK = _require$codes.ERR_MULTIPLE_CALLBACK,
@@ -2769,12 +3547,12 @@ var _require$codes = (__webpack_require__(4281)/* .codes */ .q),
 
 var errorOrDestroy = destroyImpl.errorOrDestroy;
 
-__webpack_require__(5717)(Writable, Stream);
+__webpack_require__(717)(Writable, Stream);
 
 function nop() {}
 
 function WritableState(options, stream, isDuplex) {
-  Duplex = Duplex || __webpack_require__(6753);
+  Duplex = Duplex || __webpack_require__(753);
   options = options || {}; // Duplex streams are both readable and writable, but share
   // the same options object.
   // However, some cases require setting options to different
@@ -2900,7 +3678,7 @@ if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.protot
 }
 
 function Writable(options) {
-  Duplex = Duplex || __webpack_require__(6753); // Writable ctor is applied to Duplexes, too.
+  Duplex = Duplex || __webpack_require__(753); // Writable ctor is applied to Duplexes, too.
   // `realHasInstance` is necessary because using plain `instanceof`
   // would return false, as no `_writableState` property is attached.
   // Trying to use the custom `instanceof` for Writable here will also break the
@@ -3371,7 +4149,7 @@ Writable.prototype._destroy = function (err, cb) {
 
 /***/ }),
 
-/***/ 5850:
+/***/ 850:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 
@@ -3380,7 +4158,7 @@ var _Object$setPrototypeO;
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-var finished = __webpack_require__(8610);
+var finished = __webpack_require__(610);
 
 var kLastResolve = Symbol('lastResolve');
 var kLastReject = Symbol('lastReject');
@@ -3584,7 +4362,7 @@ module.exports = createReadableStreamAsyncIterator;
 
 /***/ }),
 
-/***/ 7327:
+/***/ 327:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 
@@ -3601,10 +4379,10 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
-var _require = __webpack_require__(5291),
+var _require = __webpack_require__(291),
     Buffer = _require.Buffer;
 
-var _require2 = __webpack_require__(2361),
+var _require2 = __webpack_require__(361),
     inspect = _require2.inspect;
 
 var custom = inspect && inspect.custom || 'inspect';
@@ -3800,7 +4578,7 @@ function () {
 
 /***/ }),
 
-/***/ 1195:
+/***/ 195:
 /***/ ((module) => {
 
  // undocumented cb() API, needed for core, not for public API
@@ -3911,14 +4689,14 @@ module.exports = {
 
 /***/ }),
 
-/***/ 8610:
+/***/ 610:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // Ported from https://github.com/mafintosh/end-of-stream with
 // permission from the author, Mathias Buus (@mafintosh).
 
 
-var ERR_STREAM_PREMATURE_CLOSE = (__webpack_require__(4281)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE);
+var ERR_STREAM_PREMATURE_CLOSE = (__webpack_require__(281)/* .codes.ERR_STREAM_PREMATURE_CLOSE */ .q.ERR_STREAM_PREMATURE_CLOSE);
 
 function once(callback) {
   var called = false;
@@ -4021,7 +4799,7 @@ module.exports = eos;
 
 /***/ }),
 
-/***/ 5167:
+/***/ 167:
 /***/ ((module) => {
 
 module.exports = function () {
@@ -4031,7 +4809,7 @@ module.exports = function () {
 
 /***/ }),
 
-/***/ 9946:
+/***/ 946:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 // Ported from https://github.com/mafintosh/pump with
@@ -4049,7 +4827,7 @@ function once(callback) {
   };
 }
 
-var _require$codes = (__webpack_require__(4281)/* .codes */ .q),
+var _require$codes = (__webpack_require__(281)/* .codes */ .q),
     ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
     ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
 
@@ -4068,7 +4846,7 @@ function destroyer(stream, reading, writing, callback) {
   stream.on('close', function () {
     closed = true;
   });
-  if (eos === undefined) eos = __webpack_require__(8610);
+  if (eos === undefined) eos = __webpack_require__(610);
   eos(stream, {
     readable: reading,
     writable: writing
@@ -4134,12 +4912,12 @@ module.exports = pipeline;
 
 /***/ }),
 
-/***/ 2457:
+/***/ 457:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 
 
-var ERR_INVALID_OPT_VALUE = (__webpack_require__(4281)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE);
+var ERR_INVALID_OPT_VALUE = (__webpack_require__(281)/* .codes.ERR_INVALID_OPT_VALUE */ .q.ERR_INVALID_OPT_VALUE);
 
 function highWaterMarkFrom(options, isDuplex, duplexKey) {
   return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
@@ -4167,36 +4945,36 @@ module.exports = {
 
 /***/ }),
 
-/***/ 2503:
+/***/ 503:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
-module.exports = __webpack_require__(7187).EventEmitter;
+module.exports = __webpack_require__(370).EventEmitter;
 
 
 /***/ }),
 
-/***/ 8473:
+/***/ 473:
 /***/ ((module, exports, __webpack_require__) => {
 
-exports = module.exports = __webpack_require__(9481);
+exports = module.exports = __webpack_require__(481);
 exports.Stream = exports;
 exports.Readable = exports;
-exports.Writable = __webpack_require__(4229);
-exports.Duplex = __webpack_require__(6753);
-exports.Transform = __webpack_require__(4605);
-exports.PassThrough = __webpack_require__(2725);
-exports.finished = __webpack_require__(8610);
-exports.pipeline = __webpack_require__(9946);
+exports.Writable = __webpack_require__(229);
+exports.Duplex = __webpack_require__(753);
+exports.Transform = __webpack_require__(605);
+exports.PassThrough = __webpack_require__(725);
+exports.finished = __webpack_require__(610);
+exports.pipeline = __webpack_require__(946);
 
 
 /***/ }),
 
-/***/ 9509:
+/***/ 509:
 /***/ ((module, exports, __webpack_require__) => {
 
 /*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 /* eslint-disable node/no-deprecated-api */
-var buffer = __webpack_require__(5291)
+var buffer = __webpack_require__(291)
 var Buffer = buffer.Buffer
 
 // alternative to using Object.keys for old browsers
@@ -4263,7 +5041,7 @@ SafeBuffer.allocUnsafeSlow = function (size) {
 
 /***/ }),
 
-/***/ 2553:
+/***/ 553:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 // Copyright Joyent, Inc. and other Node contributors.
@@ -4291,7 +5069,7 @@ SafeBuffer.allocUnsafeSlow = function (size) {
 
 /*<replacement>*/
 
-var Buffer = (__webpack_require__(9509).Buffer);
+var Buffer = (__webpack_require__(509).Buffer);
 /*</replacement>*/
 
 var isEncoding = Buffer.isEncoding || function (encoding) {
@@ -4565,7 +5343,7 @@ function simpleEnd(buf) {
 
 /***/ }),
 
-/***/ 4927:
+/***/ 927:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 
@@ -4639,7 +5417,7 @@ function config (name) {
 
 /***/ }),
 
-/***/ 6988:
+/***/ 988:
 /***/ ((module) => {
 
 module.exports = read
@@ -4675,7 +5453,7 @@ function read(buf, offset) {
 
 /***/ }),
 
-/***/ 1312:
+/***/ 312:
 /***/ ((module) => {
 
 module.exports = encode
@@ -4712,12 +5490,12 @@ function encode(num, out, offset) {
 
 /***/ }),
 
-/***/ 4676:
+/***/ 676:
 /***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
 module.exports = {
-    encode: __webpack_require__(1312)
-  , decode: __webpack_require__(6988)
+    encode: __webpack_require__(312)
+  , decode: __webpack_require__(988)
   , encodingLength: __webpack_require__(82)
 }
 
@@ -4756,7 +5534,7 @@ module.exports = function (value) {
 
 /***/ }),
 
-/***/ 5277:
+/***/ 277:
 /***/ ((__unused_webpack_module, exports) => {
 
 
@@ -4886,9 +5664,7 @@ function fromByteArray (uint8) {
 
   // go through the array every three bytes, we'll deal with trailing stuff later
   for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
-    parts.push(encodeChunk(
-      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
-    ))
+    parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
   }
 
   // pad the end with zeros, but make sure to not forget the extra bytes
@@ -4915,7 +5691,7 @@ function fromByteArray (uint8) {
 
 /***/ }),
 
-/***/ 5291:
+/***/ 291:
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 /*!
@@ -4928,11 +5704,11 @@ function fromByteArray (uint8) {
 
 
 
-var base64 = __webpack_require__(5277)
-var ieee754 = __webpack_require__(2608)
+var base64 = __webpack_require__(277)
+var ieee754 = __webpack_require__(608)
 var customInspectSymbol =
-  (typeof Symbol === 'function' && typeof Symbol.for === 'function')
-    ? Symbol.for('nodejs.util.inspect.custom')
+  (typeof Symbol === 'function' && typeof Symbol['for'] === 'function') // eslint-disable-line dot-notation
+    ? Symbol['for']('nodejs.util.inspect.custom') // eslint-disable-line dot-notation
     : null
 
 exports.Buffer = Buffer
@@ -5036,7 +5812,7 @@ function from (value, encodingOrOffset, length) {
   }
 
   if (ArrayBuffer.isView(value)) {
-    return fromArrayLike(value)
+    return fromArrayView(value)
   }
 
   if (value == null) {
@@ -5117,7 +5893,7 @@ function alloc (size, fill, encoding) {
   if (fill !== undefined) {
     // Only pay attention to encoding if it's a string. This
     // prevents accidentally sending in a number that would
-    // be interpretted as a start offset.
+    // be interpreted as a start offset.
     return typeof encoding === 'string'
       ? createBuffer(size).fill(fill, encoding)
       : createBuffer(size).fill(fill)
@@ -5184,6 +5960,14 @@ function fromArrayLike (array) {
   return buf
 }
 
+function fromArrayView (arrayView) {
+  if (isInstance(arrayView, Uint8Array)) {
+    var copy = new Uint8Array(arrayView)
+    return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength)
+  }
+  return fromArrayLike(arrayView)
+}
+
 function fromArrayBuffer (array, byteOffset, length) {
   if (byteOffset < 0 || array.byteLength < byteOffset) {
     throw new RangeError('"offset" is outside of buffer bounds')
@@ -5323,12 +6107,20 @@ Buffer.concat = function concat (list, length) {
   for (i = 0; i < list.length; ++i) {
     var buf = list[i]
     if (isInstance(buf, Uint8Array)) {
-      buf = Buffer.from(buf)
-    }
-    if (!Buffer.isBuffer(buf)) {
+      if (pos + buf.length > buffer.length) {
+        Buffer.from(buf).copy(buffer, pos)
+      } else {
+        Uint8Array.prototype.set.call(
+          buffer,
+          buf,
+          pos
+        )
+      }
+    } else if (!Buffer.isBuffer(buf)) {
       throw new TypeError('"list" argument must be an Array of Buffers')
+    } else {
+      buf.copy(buffer, pos)
     }
-    buf.copy(buffer, pos)
     pos += buf.length
   }
   return buffer
@@ -5410,7 +6202,7 @@ function slowToString (encoding, start, end) {
     return ''
   }
 
-  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
+  // Force coercion to uint32. This will also coerce falsey/NaN values to 0.
   end >>>= 0
   start >>>= 0
 
@@ -5761,10 +6553,6 @@ function asciiWrite (buf, string, offset, length) {
   return blitBuffer(asciiToBytes(string), buf, offset, length)
 }
 
-function latin1Write (buf, string, offset, length) {
-  return asciiWrite(buf, string, offset, length)
-}
-
 function base64Write (buf, string, offset, length) {
   return blitBuffer(base64ToBytes(string), buf, offset, length)
 }
@@ -5820,11 +6608,9 @@ Buffer.prototype.write = function write (string, offset, length, encoding) {
         return utf8Write(this, string, offset, length)
 
       case 'ascii':
-        return asciiWrite(this, string, offset, length)
-
       case 'latin1':
       case 'binary':
-        return latin1Write(this, string, offset, length)
+        return asciiWrite(this, string, offset, length)
 
       case 'base64':
         // Warning: maxLength not taken into account in base64Write
@@ -5867,10 +6653,13 @@ function utf8Slice (buf, start, end) {
   while (i < end) {
     var firstByte = buf[i]
     var codePoint = null
-    var bytesPerSequence = (firstByte > 0xEF) ? 4
-      : (firstByte > 0xDF) ? 3
-        : (firstByte > 0xBF) ? 2
-          : 1
+    var bytesPerSequence = (firstByte > 0xEF)
+      ? 4
+      : (firstByte > 0xDF)
+          ? 3
+          : (firstByte > 0xBF)
+              ? 2
+              : 1
 
     if (i + bytesPerSequence <= end) {
       var secondByte, thirdByte, fourthByte, tempCodePoint
@@ -5991,7 +6780,8 @@ function hexSlice (buf, start, end) {
 function utf16leSlice (buf, start, end) {
   var bytes = buf.slice(start, end)
   var res = ''
-  for (var i = 0; i < bytes.length; i += 2) {
+  // If bytes.length is odd, the last 8 bits must be ignored (same as node.js)
+  for (var i = 0; i < bytes.length - 1; i += 2) {
     res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
   }
   return res
@@ -6033,6 +6823,7 @@ function checkOffset (offset, ext, length) {
   if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
 }
 
+Buffer.prototype.readUintLE =
 Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
   offset = offset >>> 0
   byteLength = byteLength >>> 0
@@ -6048,6 +6839,7 @@ Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert)
   return val
 }
 
+Buffer.prototype.readUintBE =
 Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
   offset = offset >>> 0
   byteLength = byteLength >>> 0
@@ -6064,24 +6856,28 @@ Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert)
   return val
 }
 
+Buffer.prototype.readUint8 =
 Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
   offset = offset >>> 0
   if (!noAssert) checkOffset(offset, 1, this.length)
   return this[offset]
 }
 
+Buffer.prototype.readUint16LE =
 Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
   offset = offset >>> 0
   if (!noAssert) checkOffset(offset, 2, this.length)
   return this[offset] | (this[offset + 1] << 8)
 }
 
+Buffer.prototype.readUint16BE =
 Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
   offset = offset >>> 0
   if (!noAssert) checkOffset(offset, 2, this.length)
   return (this[offset] << 8) | this[offset + 1]
 }
 
+Buffer.prototype.readUint32LE =
 Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
   offset = offset >>> 0
   if (!noAssert) checkOffset(offset, 4, this.length)
@@ -6092,6 +6888,7 @@ Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
       (this[offset + 3] * 0x1000000)
 }
 
+Buffer.prototype.readUint32BE =
 Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
   offset = offset >>> 0
   if (!noAssert) checkOffset(offset, 4, this.length)
@@ -6209,6 +7006,7 @@ function checkInt (buf, value, offset, ext, max, min) {
   if (offset + ext > buf.length) throw new RangeError('Index out of range')
 }
 
+Buffer.prototype.writeUintLE =
 Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
   value = +value
   offset = offset >>> 0
@@ -6228,6 +7026,7 @@ Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength,
   return offset + byteLength
 }
 
+Buffer.prototype.writeUintBE =
 Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
   value = +value
   offset = offset >>> 0
@@ -6247,6 +7046,7 @@ Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength,
   return offset + byteLength
 }
 
+Buffer.prototype.writeUint8 =
 Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
   value = +value
   offset = offset >>> 0
@@ -6255,6 +7055,7 @@ Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
   return offset + 1
 }
 
+Buffer.prototype.writeUint16LE =
 Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
   value = +value
   offset = offset >>> 0
@@ -6264,6 +7065,7 @@ Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert
   return offset + 2
 }
 
+Buffer.prototype.writeUint16BE =
 Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
   value = +value
   offset = offset >>> 0
@@ -6273,6 +7075,7 @@ Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert
   return offset + 2
 }
 
+Buffer.prototype.writeUint32LE =
 Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
   value = +value
   offset = offset >>> 0
@@ -6284,6 +7087,7 @@ Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert
   return offset + 4
 }
 
+Buffer.prototype.writeUint32BE =
 Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
   value = +value
   offset = offset >>> 0
@@ -6463,11 +7267,6 @@ Buffer.prototype.copy = function copy (target, targetStart, start, end) {
   if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
     // Use built-in when available, missing from IE11
     this.copyWithin(targetStart, start, end)
-  } else if (this === target && start < targetStart && targetStart < end) {
-    // descending copy from end
-    for (var i = len - 1; i >= 0; --i) {
-      target[i + targetStart] = this[i + start]
-    }
   } else {
     Uint8Array.prototype.set.call(
       target,
@@ -6716,9 +7515,10 @@ var hexSliceLookupTable = (function () {
 
 /***/ }),
 
-/***/ 2608:
+/***/ 608:
 /***/ ((__unused_webpack_module, exports) => {
 
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
 exports.read = function (buffer, offset, isLE, mLen, nBytes) {
   var e, m
   var eLen = (nBytes * 8) - mLen - 1
@@ -6807,14 +7607,14 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
 
 /***/ }),
 
-/***/ 2361:
+/***/ 361:
 /***/ (() => {
 
 /* (ignored) */
 
 /***/ }),
 
-/***/ 4616:
+/***/ 616:
 /***/ (() => {
 
 /* (ignored) */
@@ -6847,53 +7647,8 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
 /******/ 	return module.exports;
 /******/ }
 /******/ 
-/******/ // expose the modules object (__webpack_modules__)
-/******/ __webpack_require__.m = __webpack_modules__;
-/******/ 
 /************************************************************************/
-/******/ /* webpack/runtime/compat get default export */
-/******/ (() => {
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__webpack_require__.n = (module) => {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			() => (module['default']) :
-/******/ 			() => (module);
-/******/ 		__webpack_require__.d(getter, { a: getter });
-/******/ 		return getter;
-/******/ 	};
-/******/ })();
-/******/ 
-/******/ /* webpack/runtime/create fake namespace object */
-/******/ (() => {
-/******/ 	var getProto = Object.getPrototypeOf ? (obj) => (Object.getPrototypeOf(obj)) : (obj) => (obj.__proto__);
-/******/ 	var leafPrototypes;
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 16: return value when it's Promise-like
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__webpack_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = this(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if(typeof value === 'object' && value) {
-/******/ 			if((mode & 4) && value.__esModule) return value;
-/******/ 			if((mode & 16) && typeof value.then === 'function') return value;
-/******/ 		}
-/******/ 		var ns = Object.create(null);
-/******/ 		__webpack_require__.r(ns);
-/******/ 		var def = {};
-/******/ 		leafPrototypes = leafPrototypes || [null, getProto({}), getProto([]), getProto(getProto)];
-/******/ 		for(var current = mode & 2 && value; typeof current == 'object' && !~leafPrototypes.indexOf(current); current = getProto(current)) {
-/******/ 			Object.getOwnPropertyNames(current).forEach((key) => (def[key] = () => (value[key])));
-/******/ 		}
-/******/ 		def['default'] = () => (value);
-/******/ 		__webpack_require__.d(ns, def);
-/******/ 		return ns;
-/******/ 	};
-/******/ })();
-/******/ 
-/******/ /* webpack/runtime/define property getters */
+/******/ /* webpack/runtime/define property getters */
 /******/ (() => {
 /******/ 	// define getter functions for harmony exports
 /******/ 	__webpack_require__.d = (exports, definition) => {
@@ -6905,28 +7660,6 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
 /******/ 	};
 /******/ })();
 /******/ 
-/******/ /* webpack/runtime/ensure chunk */
-/******/ (() => {
-/******/ 	__webpack_require__.f = {};
-/******/ 	// This file contains only the entry chunk.
-/******/ 	// The chunk loading function for additional chunks
-/******/ 	__webpack_require__.e = (chunkId) => {
-/******/ 		return Promise.all(Object.keys(__webpack_require__.f).reduce((promises, key) => {
-/******/ 			__webpack_require__.f[key](chunkId, promises);
-/******/ 			return promises;
-/******/ 		}, []));
-/******/ 	};
-/******/ })();
-/******/ 
-/******/ /* webpack/runtime/get javascript chunk filename */
-/******/ (() => {
-/******/ 	// This function allow to reference async chunks
-/******/ 	__webpack_require__.u = (chunkId) => {
-/******/ 		// return url for filenames based on template
-/******/ 		return "" + "protons" + ".esm";
-/******/ 	};
-/******/ })();
-/******/ 
 /******/ /* webpack/runtime/global */
 /******/ (() => {
 /******/ 	__webpack_require__.g = (function() {
@@ -6944,52 +7677,6 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
 /******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
 /******/ })();
 /******/ 
-/******/ /* webpack/runtime/load script */
-/******/ (() => {
-/******/ 	var inProgress = {};
-/******/ 	var dataWebpackPrefix = "@leofcoin/messages:";
-/******/ 	// loadScript function to load a script via script tag
-/******/ 	__webpack_require__.l = (url, done, key, chunkId) => {
-/******/ 		if(inProgress[url]) { inProgress[url].push(done); return; }
-/******/ 		var script, needAttach;
-/******/ 		if(key !== undefined) {
-/******/ 			var scripts = document.getElementsByTagName("script");
-/******/ 			for(var i = 0; i < scripts.length; i++) {
-/******/ 				var s = scripts[i];
-/******/ 				if(s.getAttribute("src") == url || s.getAttribute("data-webpack") == dataWebpackPrefix + key) { script = s; break; }
-/******/ 			}
-/******/ 		}
-/******/ 		if(!script) {
-/******/ 			needAttach = true;
-/******/ 			script = document.createElement('script');
-/******/ 			script.type = "module";
-/******/ 			script.charset = 'utf-8';
-/******/ 			script.timeout = 120;
-/******/ 			if (__webpack_require__.nc) {
-/******/ 				script.setAttribute("nonce", __webpack_require__.nc);
-/******/ 			}
-/******/ 			script.setAttribute("data-webpack", dataWebpackPrefix + key);
-/******/ 			script.src = url;
-/******/ 		}
-/******/ 		inProgress[url] = [done];
-/******/ 		var onScriptComplete = (prev, event) => {
-/******/ 			// avoid mem leaks in IE.
-/******/ 			script.onerror = script.onload = null;
-/******/ 			clearTimeout(timeout);
-/******/ 			var doneFns = inProgress[url];
-/******/ 			delete inProgress[url];
-/******/ 			script.parentNode && script.parentNode.removeChild(script);
-/******/ 			doneFns && doneFns.forEach((fn) => (fn(event)));
-/******/ 			if(prev) return prev(event);
-/******/ 		}
-/******/ 		;
-/******/ 		var timeout = setTimeout(onScriptComplete.bind(null, undefined, { type: 'timeout', target: script }), 120000);
-/******/ 		script.onerror = onScriptComplete.bind(null, script.onerror);
-/******/ 		script.onload = onScriptComplete.bind(null, script.onload);
-/******/ 		needAttach && document.head.appendChild(script);
-/******/ 	};
-/******/ })();
-/******/ 
 /******/ /* webpack/runtime/make namespace object */
 /******/ (() => {
 /******/ 	// define __esModule on exports
@@ -7001,107 +7688,6 @@ exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
 /******/ 	};
 /******/ })();
 /******/ 
-/******/ /* webpack/runtime/publicPath */
-/******/ (() => {
-/******/ 	var scriptUrl;
-/******/ 	if (typeof import.meta.url === "string") scriptUrl = import.meta.url
-/******/ 	// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
-/******/ 	// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
-/******/ 	if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
-/******/ 	scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
-/******/ 	__webpack_require__.p = scriptUrl;
-/******/ })();
-/******/ 
-/******/ /* webpack/runtime/jsonp chunk loading */
-/******/ (() => {
-/******/ 	// no baseURI
-/******/ 	
-/******/ 	// object to store loaded and loading chunks
-/******/ 	// undefined = chunk not loaded, null = chunk preloaded/prefetched
-/******/ 	// [resolve, reject, Promise] = chunk loading, 0 = chunk loaded
-/******/ 	var installedChunks = {
-/******/ 		158: 0
-/******/ 	};
-/******/ 	
-/******/ 	__webpack_require__.f.j = (chunkId, promises) => {
-/******/ 			// JSONP chunk loading for javascript
-/******/ 			var installedChunkData = __webpack_require__.o(installedChunks, chunkId) ? installedChunks[chunkId] : undefined;
-/******/ 			if(installedChunkData !== 0) { // 0 means "already installed".
-/******/ 	
-/******/ 				// a Promise means "currently loading".
-/******/ 				if(installedChunkData) {
-/******/ 					promises.push(installedChunkData[2]);
-/******/ 				} else {
-/******/ 					if(true) { // all chunks have JS
-/******/ 						// setup Promise in chunk cache
-/******/ 						var promise = new Promise((resolve, reject) => (installedChunkData = installedChunks[chunkId] = [resolve, reject]));
-/******/ 						promises.push(installedChunkData[2] = promise);
-/******/ 	
-/******/ 						// start chunk loading
-/******/ 						var url = __webpack_require__.p + __webpack_require__.u(chunkId);
-/******/ 						// create error before stack unwound to get useful stacktrace later
-/******/ 						var error = new Error();
-/******/ 						var loadingEnded = (event) => {
-/******/ 							if(__webpack_require__.o(installedChunks, chunkId)) {
-/******/ 								installedChunkData = installedChunks[chunkId];
-/******/ 								if(installedChunkData !== 0) installedChunks[chunkId] = undefined;
-/******/ 								if(installedChunkData) {
-/******/ 									var errorType = event && (event.type === 'load' ? 'missing' : event.type);
-/******/ 									var realSrc = event && event.target && event.target.src;
-/******/ 									error.message = 'Loading chunk ' + chunkId + ' failed.\n(' + errorType + ': ' + realSrc + ')';
-/******/ 									error.name = 'ChunkLoadError';
-/******/ 									error.type = errorType;
-/******/ 									error.request = realSrc;
-/******/ 									installedChunkData[1](error);
-/******/ 								}
-/******/ 							}
-/******/ 						};
-/******/ 						__webpack_require__.l(url, loadingEnded, "chunk-" + chunkId, chunkId);
-/******/ 					} else installedChunks[chunkId] = 0;
-/******/ 				}
-/******/ 			}
-/******/ 	};
-/******/ 	
-/******/ 	// no prefetching
-/******/ 	
-/******/ 	// no preloaded
-/******/ 	
-/******/ 	// no HMR
-/******/ 	
-/******/ 	// no HMR manifest
-/******/ 	
-/******/ 	// no on chunks loaded
-/******/ 	
-/******/ 	// install a JSONP callback for chunk loading
-/******/ 	var webpackJsonpCallback = (parentChunkLoadingFunction, data) => {
-/******/ 		var [chunkIds, moreModules, runtime] = data;
-/******/ 		// add "moreModules" to the modules object,
-/******/ 		// then flag all "chunkIds" as loaded and fire callback
-/******/ 		var moduleId, chunkId, i = 0;
-/******/ 		if(chunkIds.some((id) => (installedChunks[id] !== 0))) {
-/******/ 			for(moduleId in moreModules) {
-/******/ 				if(__webpack_require__.o(moreModules, moduleId)) {
-/******/ 					__webpack_require__.m[moduleId] = moreModules[moduleId];
-/******/ 				}
-/******/ 			}
-/******/ 			if(runtime) var result = runtime(__webpack_require__);
-/******/ 		}
-/******/ 		if(parentChunkLoadingFunction) parentChunkLoadingFunction(data);
-/******/ 		for(;i < chunkIds.length; i++) {
-/******/ 			chunkId = chunkIds[i];
-/******/ 			if(__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) {
-/******/ 				installedChunks[chunkId][0]();
-/******/ 			}
-/******/ 			installedChunks[chunkId] = 0;
-/******/ 		}
-/******/ 	
-/******/ 	}
-/******/ 	
-/******/ 	var chunkLoadingGlobal = self["webpackChunk_leofcoin_messages"] = self["webpackChunk_leofcoin_messages"] || [];
-/******/ 	chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0));
-/******/ 	chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal));
-/******/ })();
-/******/ 
 /************************************************************************/
 var __webpack_exports__ = {};
 // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
@@ -7125,742 +7711,13 @@ message ContractMessage {
 }
 `);
 
-;// CONCATENATED MODULE: ./node_modules/@vandeurenglenn/base-x/src/base-x.js
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-const base = ALPHABET => {
-  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
-  const BASE_MAP = new Uint8Array(256)
-  for (let j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255
-  }
-  for (let i = 0; i < ALPHABET.length; i++) {
-    const x = ALPHABET.charAt(i)
-    const xc = x.charCodeAt(0)
-    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
-    BASE_MAP[xc] = i
-  }
-  const BASE = ALPHABET.length
-  const LEADER = ALPHABET.charAt(0)
-  const FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up
-  const iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up
-
-  const encode = source => {
-    if (source instanceof Uint8Array) {
-    } else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source)
-    }
-    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
-    if (source.length === 0) { return '' }
-    // Skip & count leading zeroes.
-    let zeroes = 0
-    let length = 0
-    let pbegin = 0
-    const pend = source.length
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++
-      zeroes++
-    }
-    // Allocate enough space in big-endian base58 representation.
-    const size = ((pend - pbegin) * iFACTOR + 1) >>> 0
-    const b58 = new Uint8Array(size)
-        // Process the bytes.
-    while (pbegin !== pend) {
-      let carry = source[pbegin]
-            // Apply "b58 = b58 * 256 + ch".
-      let i = 0
-      for (let it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-        carry += (256 * b58[it1]) >>> 0
-        b58[it1] = (carry % BASE) >>> 0
-        carry = (carry / BASE) >>> 0
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i
-      pbegin++
-    }
-        // Skip leading zeroes in base58 result.
-    let it2 = size - length
-    while (it2 !== size && b58[it2] === 0) {
-      it2++
-    }
-        // Translate the result into a string.
-    let str = LEADER.repeat(zeroes)
-    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }
-    return str
-  }
-  const decodeUnsafe = source => {
-    if (typeof source !== 'string') { throw new TypeError('Expected String') }
-    if (source.length === 0) { return new Uint8Array() }
-    let psz = 0
-        // Skip and count leading '1's.
-    let zeroes = 0
-    let length = 0
-    while (source[psz] === LEADER) {
-      zeroes++
-      psz++
-    }
-    // Allocate enough space in big-endian base256 representation.
-    const size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.
-    let b256 = new Uint8Array(size)
-    // Process the characters.
-    while (source[psz]) {
-      // Decode character
-      let carry = BASE_MAP[source.charCodeAt(psz)]
-      // Invalid character
-      if (carry === 255) { return }
-      let i = 0
-      for (let it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-        carry += (BASE * b256[it3]) >>> 0
-        b256[it3] = (carry % 256) >>> 0
-        carry = (carry / 256) >>> 0
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i
-      psz++
-    }
-    // Skip leading zeroes in b256.
-    let it4 = size - length
-    while (it4 !== size && b256[it4] === 0) {
-      it4++
-    }
-    let vch = new Uint8Array(zeroes + (size - it4))
-    let j = zeroes
-    while (it4 !== size) {
-      vch[j++] = b256[it4++]
-    }
-    return vch
-  }
-  const decode = string => {
-    const buffer = decodeUnsafe(string)
-    if (buffer) { return buffer }
-    throw new Error('Non-base' + BASE + ' character')
-  }
-  return {
-    encode: encode,
-    decodeUnsafe: decodeUnsafe,
-    decode: decode
-  }
-}
-
-/* harmony default export */ const base_x = (base);
-
-;// CONCATENATED MODULE: ./node_modules/@vandeurenglenn/base32/src/base32.js
-
-
-const base32_base32 = 'abcdefghijklmnopqrstuvwxyz234567'
-const base32Hex = '0123456789abcdefghijklmnopqrstuv'
-
-const decode = (uint8Array, hex = false) => {
-  const decoder = hex ? base_x(base32Hex) : base_x(base32_base32)
-  return decoder.decode(uint8Array)
-}
-
-/* harmony default export */ const src_base32 = ({
-  encode: (uint8Array, hex = false) => {
-    const encoder = hex ? base_x(base32Hex) : base_x(base32_base32)
-    return encoder.encode(uint8Array)
-  },
-  decode,
-  isBase32: (uint8Array, hex = false) => {
-    try {
-      decode(uint8Array, hex)
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-});
-
-;// CONCATENATED MODULE: ./node_modules/@vandeurenglenn/base58/src/base58.js
-
-
-const base58_base58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-
-const base58_decode = uint8Array => base_x(base58_base58).decode(uint8Array)
-
-/* harmony default export */ const src_base58 = ({
-  encode: uint8Array => base_x(base58_base58).encode(uint8Array),
-  decode: base58_decode,
-  isBase58: uint8Array => {
-    try {
-      base58_decode(uint8Array)
-      return true
-    } catch (e) {
-      return false
-    }
-  }
-});
-
-;// CONCATENATED MODULE: ./node_modules/@vandeurenglenn/is-hex/is-hex.js
-/* harmony default export */ const is_hex = (string => /^[A-F0-9]+$/i.test(string));
-
-;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/basic-interface.js
-
-
-
-
-class BasicInterface {
-  #handleDecode() {
-    if (!this.decode) throw new Error('bad implementation: needs decode func')
-    return this.decode()
-  }
-
-  #handleEncode() {
-    if (!this.encode) throw new Error('bad implementation: needs encode func')
-    return this.encode()
-  }
-  isHex(string) {
-    return is_hex(string)
-  }
-  isBase32(string) {
-    return base32.isBase32(string)
-  }
-  isBase58(string) {
-    return base58.isBase32(string)
-  }
-  /**
-   * @param {String} encoded
-   */
-  fromBs32(encoded) {
-    this.encoded = src_base32.decode(encoded)
-    return this.#handleDecode()
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromBs58(encoded) {
-    this.encoded = src_base58.decode(encoded)
-    return this.#handleDecode()
-  }
-
-  async toArray() {
-    const array = []
-    for await (const value of this.encoded.values()) {
-      array.push(value)
-    }
-    return array
-  }
-
-  fromString(string) {
-    this.encoded = new Uint8Array(string.split(','))
-    return this.#handleDecode()
-  }
-
-  fromArray(array) {
-    this.encoded = new Uint8Array([...array])
-    return this.#handleDecode()
-  }
-
-  /**
-   * @param {Buffer} encoded
-   */
-  fromEncoded(encoded) {
-    this.encoded = encoded
-    return this.#handleDecode()
-  }
-
-  /**
-   * @param {String} encoded
-   */
-  fromHex(encoded) {
-    this.encoded = Buffer.from(encoded, 'hex')
-    return this.#handleDecode()
-  }
-
-  async toString(encoding = 'utf8') {
-    if (!this.encoded) await this.#handleEncode()
-    return this.encoded.toString(encoding)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  toHex() {
-    return this.toString('hex')
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  async toBs32() {
-    if (!this.encoded) await this.#handleEncode()
-    return src_base32.encode(this.encoded)
-  }
-
-  /**
-   * @return {String} encoded
-   */
-  async toBs58() {
-    if (!this.encoded) await this.#handleEncode()
-    return src_base58.encode(this.encoded)
-  }
-
-  /**
-   * @param {Object} data
-   */
-  create(data) {
-    const decoded = {}
-    if (this.keys?.length > 0) {
-      for (const key of this.keys) {
-        Object.defineProperties(decoded, {
-          [key]: {
-            enumerable: true,
-            configurable: true,
-            set: (val) => value = data[key],
-            get: () => data[key]
-          }
-        })
-      }
-
-      this.decoded = decoded
-      return this.encode()
-    }
-  }
-}
-
-// EXTERNAL MODULE: ./node_modules/varint/index.js
-var varint = __webpack_require__(4676);
-var varint_default = /*#__PURE__*/__webpack_require__.n(varint);
-;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/codecs.js
-/* harmony default export */ const codecs = ({
-  // just a hash
-  'disco-hash': {
-    codec: parseInt('30', 16),
-    hashAlg: 'dbl-keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  'peernet-peer-response': {
-    codec: parseInt('707072', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-peer': {
-    codec: parseInt('7070', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht': {
-    codec: parseInt('706468', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-dht-response': {
-    codec: parseInt('706472', 16),
-    hashAlg: 'keccak-256',
-  },
-  // data
-  'peernet-data': {
-    codec: parseInt('706461', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-data-response': {
-    codec: parseInt('70646172', 16),
-    hashAlg: 'keccak-256',
-  },
-  // message
-  'peernet-message': {
-    codec: parseInt('706d65', 16),
-    hashAlg: 'keccak-256',
-  },
-  // pubsub
-  'peernet-ps': {
-    codec: parseInt('707073', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-response': {
-    codec: parseInt('7072', 16),
-    hashAlg: 'keccak-256',
-  },
-  'peernet-request': {
-    codec: parseInt('707271', 16),
-    hashAlg: 'keccak-256',
-  },
-  // normal block
-  'leofcoin-block': {
-    codec: parseInt('6c62', 16),
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  'leofcoin-tx': {
-    codec: parseInt('6c74', 16),
-    hashAlg: 'dbl-keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // itx
-  'leofcoin-itx': {
-    codec: parseInt('6c69', 16),
-    hashAlg: 'keccak-512', // ,
-    // testnet: 'olivia'
-  },
-  // peer reputation
-  'leofcoin-pr': {
-    codec: parseInt('6c70', 16),
-    hashAlg: 'keccak-256', // ,
-    // testnet: 'olivia'
-  },
-  // chat message
-  'chat-message': {
-    codec: parseInt('636d', 16),
-    hashAlg: 'dbl-keccak-256',
-  },
-});
-
-;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/codec.js
-
-
-
-
-class PeernetCodec extends BasicInterface {
-  get codecs() {
-    return {...globalThis.peernet.codecs, ...codecs}
-  }
-  constructor(buffer) {
-    super()
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        const codec = varint_default().decode(buffer);
-        const name = this.getCodecName(codec)
-        if (name) {
-          this.name = name
-          this.encoded = buffer
-          this.decode(buffer)
-        } else {
-          this.encode(buffer)
-        }
-      } else if (buffer instanceof ArrayBuffer) {
-        const encoded = new Uint8Array(buffer.byteLength)
-
-        for (let i = 0; i < buffer.byteLength; i++) {
-          encoded[i] = buffer[i]
-        }
-        this.encoded = encoded
-        // this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-        this.decode(buffer)
-        return
-      }
-      if (typeof buffer === 'string') {
-        if (this.codecs[buffer]) this.fromName(buffer)
-        else if (this.isHex(buffer)) this.fromHex(buffer)
-        else if (this.isBase32(buffer)) this.fromBs32(buffer)
-        else if (this.isBase58(buffer)) this.fromBs58(buffer)
-        else throw new Error(`unsupported string ${buffer}`)
-      }
-      if (!isNaN(buffer)) if (this.codecs[this.getCodecName(buffer)]) this.fromCodec(buffer)
-    }
-  }
-
-  fromEncoded(encoded) {
-    const codec = varint_default().decode(encoded);
-    const name = this.getCodecName(codec)
-    this.name = name
-    this.encoded = encoded
-    this.decode(encoded)
-  }
-
-  getCodec(name) {
-    return this.codecs[name].codec
-  }
-
-  getCodecName(codec) {
-    return Object.keys(this.codecs).reduce((p, c) => {
-      const item = this.codecs[c]
-      if (item.codec === codec) return c;
-      else return p;
-    }, undefined)
-  }
-
-  getHashAlg(name) {
-    return this.codecs[name].hashAlg
-  }
-
-  fromCodec(codec) {
-    this.name = this.getCodecName(codec)
-    this.hashAlg = this.getHashAlg(this.name)
-
-    this.codec = this.getCodec(this.name)
-    this.codecBuffer = varint_default().encode(codec)
-  }
-
-  fromName(name) {
-    const codec = this.getCodec(name)
-    this.name = name
-    this.codec = codec
-    this.hashAlg = this.getHashAlg(name)
-    this.codecBuffer = varint_default().encode(codec)
-  }
-
-  decode() {
-    const codec = varint_default().decode(this.encoded);
-    this.fromCodec(codec)
-  }
-
-  encode() {
-    const codec = varint_default().encode(this.decoded)
-    this.encoded = codec
-    return this.encoded
-  }
-}
-
-// EXTERNAL MODULE: ./node_modules/keccak/js.js
-var js = __webpack_require__(5811);
-var js_default = /*#__PURE__*/__webpack_require__.n(js);
-;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/codec-hash.js
-
-
-
-
-
-class CodecHash extends BasicInterface {
-  constructor(buffer, options = {}) {
-    super()
-    if (options.name) this.name = options.name
-    else this.name = 'disco-hash'
-    if (options.codecs) this.codecs = options.codecs
-    if (buffer) {
-      if (buffer instanceof Uint8Array) {
-        this.discoCodec = new PeernetCodec(buffer, this.codecs)
-        const name = this.discoCodec.name
-
-        if (name) {
-          this.name = name
-          this.decode(buffer)
-        } else {
-          this.encode(buffer)
-        }
-      }
-
-      if (typeof buffer === 'string') {
-        if (this.isHex(buffer)) this.fromHex(buffer)
-        if (this.isBase32(buffer)) this.fromBs32(buffer)
-        else if (this.isBase58(buffer)) this.fromBs58(buffer)
-        else throw new Error(`unsupported string ${buffer}`)
-      } else if (typeof buffer === 'object') this.fromJSON(buffer)
-    }
-  }
-
-  get prefix() {
-    const length = this.length
-    const uint8Array = new Uint8Array(length.length + this.discoCodec.codecBuffer.length)
-    uint8Array.set(length)
-    uint8Array.set(this.discoCodec.codecBuffer, length.length)
-
-    return uint8Array
-  }
-
-  get length() {
-    return varint_default().encode(this.size)
-  }
-
-  get buffer() {
-    return this.encoded
-  }
-
-  get hash() {
-    return this.encoded
-  }
-
-  fromJSON(json) {
-    return this.encode(Buffer.from(JSON.stringify(json)))
-  }
-
-  encode(buffer, name) {
-    if (!this.name && name) this.name = name;
-    if (!buffer) buffer = this.buffer;
-    this.discoCodec = new PeernetCodec(this.name, this.codecs)
-    this.discoCodec.fromName(this.name)
-    let hashAlg = this.discoCodec.hashAlg
-    if (hashAlg.includes('dbl')) {
-      hashAlg = hashAlg.replace('dbl-', '')
-      buffer = js_default()(hashAlg.replace('-', '')).update(buffer).digest()
-    }
-    this.digest = js_default()(hashAlg.replace('-', '')).update(buffer).digest()
-    this.size = this.digest.length
-
-    this.codec = this.discoCodec.encode();
-    this.codec = this.discoCodec.codecBuffer
-    const uint8Array = new Uint8Array(this.digest.length + this.prefix.length)
-    uint8Array.set(this.prefix)
-    uint8Array.set(this.digest, this.prefix.length)
-
-    this.encoded = uint8Array
-
-    return this.encoded
-  }
-
-  validate(buffer) {
-    if (Buffer.isBuffer(buffer)) {
-      const codec = varint_default().decode(buffer);
-      if (this.codecs[codec]) {
-        this.decode(buffer)
-      } else {
-        this.encode(buffer)
-      }
-    }
-    if (typeof buffer === 'string') {
-      if (this.isHex(buffer)) this.fromHex(buffer)
-      if (this.isBase32(buffer)) this.fromBs32(buffer)
-    }
-    if (typeof buffer === 'object') this.fromJSON(buffer)
-  }
-
-  decode(buffer) {
-    this.encoded = buffer
-    const codec = varint_default().decode(buffer);
-
-    this.discoCodec = new PeernetCodec(codec, this.codecs)
-    // TODO: validate codec
-    buffer = buffer.slice((varint_default()).decode.bytes);
-    this.size = varint_default().decode(buffer);
-    this.digest = buffer.slice((varint_default()).decode.bytes);
-    if (this.digest.length !== this.size) {
-      throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`)
-    }
-
-    // const discoCodec = new Codec(codec, this.codecs)
-
-    this.name = this.discoCodec.name
-
-
-    this.size = this.digest.length
-
-    return {
-      codec: this.codec,
-      name: this.name,
-      size: this.size,
-      length: this.length,
-      digest: this.digest,
-    }
-  }
-}
-
-;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/codec-format-interface.js
-
-
-
-let protons
-
-class FormatInterface extends BasicInterface {
-  async #importProtons() {
-    let importee = await __webpack_require__.e(/* import() | protons */ 397).then(__webpack_require__.t.bind(__webpack_require__, 7160, 23))
-    return importee.default
-  }
-
-  async protoEncode(data) {
-    if (!protons) protons = await this.#importProtons()
-    return protons(this.proto)[this.messageName].encode(data)
-  }
-
-  async protoDecode(data) {
-    if (!protons) protons = await this.#importProtons()
-    return protons(this.proto)[this.messageName].decode(data)
-  }
-
-  async #init(buffer) {
-    if (buffer instanceof Uint8Array) await this.fromUint8Array(buffer)
-    else if (buffer instanceof ArrayBuffer) await this.fromArrayBuffer(buffer)
-    else if (buffer?.name === this.name) return buffer
-    else if (buffer instanceof String) {
-      if (this.isHex(buffer)) await this.fromHex(buffer)
-      else if (this.isBase32(buffer)) await this.fromBs32(buffer)
-      else if (this.isBase58(buffer)) await this.fromBs58(buffer)
-      else throw new Error(`unsupported string ${buffer}`)
-    } else {
-      await this.create(buffer)
-    }
-    return this
-  }
-
-  /**
-   * @param {Buffer|String|Object} buffer - data - The data needed to create the desired message
-   * @param {Object} proto - {encode, decode}
-   * @param {Object} options - {hashFormat, name}
-   */
-  constructor(buffer, proto, options = {}) {
-    super()
-    this.proto = proto
-    this.hashFormat = options.hashFormat || 'bs32'
-    if (options.name) this.name = options.name
-    return this.#init(buffer)
-  }
-
-  /**
-   * @return {PeernetHash}
-   */
-  get peernetHash() {
-    return new CodecHash(this.decoded, {name: this.name})
-  }
-
-  /**
-   * @return {peernetHash}
-   */
-  get hash() {
-    const upper = this.hashFormat.charAt(0).toUpperCase()
-    const format = `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`
-    return this.peernetHash[`to${format}`]()
-  }
-
-  /**
-   * @return {Object}
-   */
-  async decode() {
-    let encoded = this.encoded;
-    const discoCodec = new PeernetCodec(this.encoded)
-    encoded = encoded.slice(discoCodec.codecBuffer.length)
-    this.name = discoCodec.name
-    this.decoded = await this.protoDecode(encoded)
-    return this.decoded
-  }
-
-  /**
-   * @return {Buffer}
-   */
-  async encode(decoded) {
-    if (!decoded) decoded = this.decoded;
-    const codec = new PeernetCodec(this.name)
-    const encoded = await this.protoEncode(decoded)
-    const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length)
-    uint8Array.set(codec.codecBuffer)
-    uint8Array.set(encoded, codec.codecBuffer.length)
-    this.encoded = uint8Array
-    return this.encoded
-  }
-
-  hasCodec() {
-    if (!this.encoded) return false
-    const codec = new PeernetCodec(this.encoded)
-    if (codec.name) return true
-  }
-
-  fromUint8Array(buffer) {
-    this.encoded = buffer
-    return this.hasCodec() ? this.decode() : this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    )
-  }
-
-  fromArrayBuffer(buffer) {
-    this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength)
-    return this.hasCodec() ? this.decode() : this.create(
-      JSON.parse(new TextDecoder().decode(this.encoded))
-    )
-  }
-}
-
-;// CONCATENATED MODULE: ./node_modules/@leofcoin/codec-format-interface/src/index.js
-
-
-
-
-
-
+// EXTERNAL MODULE: ./node_modules/@leofcoin/codec-format-interface/dist/index.js
+var dist = __webpack_require__(427);
 ;// CONCATENATED MODULE: ./src/messages/contract.js
 
 
 
-class ContractMessage extends FormatInterface {
+class ContractMessage extends dist/* FormatInterface */.L1 {
   get keys() {
     return ['creator', 'contract', 'constructorParameters']
   }
@@ -7884,6 +7741,7 @@ message TransactionMessage {
   required uint64 nonce = 4;
   required string method = 5;
   repeated string params = 6;
+  required string signature = 7;
 }
 `);
 
@@ -7891,9 +7749,9 @@ message TransactionMessage {
 
 
 
-class TransactionMessage extends FormatInterface {
+class TransactionMessage extends dist/* FormatInterface */.L1 {
   get keys() {
-    return ['timestamp', 'from', 'to', 'nonce', 'method', 'params']
+    return ['timestamp', 'from', 'to', 'nonce', 'method', 'params', 'signature']
   }
 
   get messageName() {
@@ -7938,7 +7796,7 @@ message BlockMessage {
 
 
 
-class BlockMessage extends FormatInterface {
+class BlockMessage extends dist/* FormatInterface */.L1 {
   get keys() {
     return ['index', 'previousHash', 'timestamp', 'reward', 'fees', 'transactions', 'validators']
   }
@@ -7966,7 +7824,7 @@ message BWMessage {
 
 
 
-class BWMessage extends FormatInterface {
+class BWMessage extends dist/* FormatInterface */.L1 {
   get keys() {
     return ['up', 'down']
   }
@@ -7992,7 +7850,7 @@ message BWRequestMessage {
 
 
 
-class BWRequestMessage extends FormatInterface {
+class BWRequestMessage extends dist/* FormatInterface */.L1 {
   get keys() {
     return []
   }