@leofcoin/workers 1.3.8 → 1.3.10

package/dist/bundle/module/worker-def77c26.js

@@ -1,4858 +0,0 @@
-import require$$0$1 from 'stream';
-import require$$0$2 from 'events';
-import require$$2$1 from 'buffer';
-import require$$1$1 from 'util';
-import require$$10 from 'string_decoder/';
-import require$$0$3 from 'fs';
-import require$$1$2 from 'path';
-import require$$2$2 from 'os';
-
-var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
-
-function getAugmentedNamespace(n) {
-  var f = n.default;
-	if (typeof f == "function") {
-		var a = function () {
-			return f.apply(this, arguments);
-		};
-		a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, '__esModule', {value: true});
-	Object.keys(n).forEach(function (k) {
-		var d = Object.getOwnPropertyDescriptor(n, k);
-		Object.defineProperty(a, k, d.get ? d : {
-			enumerable: true,
-			get: function () {
-				return n[k];
-			}
-		});
-	});
-	return a;
-}
-
-var dist = {};
-
-// 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
-  }
-};
-
-const base32 = 'abcdefghijklmnopqrstuvwxyz234567';
-const base32Hex = '0123456789abcdefghijklmnopqrstuv';
-
-const decode$2 = (uint8Array, hex = false) => {
-  const decoder = hex ? base(base32Hex) : base(base32);
-  return decoder.decode(uint8Array)
-};
-
-var base32$1 = {
-  encode: (uint8Array, hex = false) => {
-    const encoder = hex ? base(base32Hex) : base(base32);
-    return encoder.encode(uint8Array)
-  },
-  decode: decode$2,
-  isBase32: (uint8Array, hex = false) => {
-    try {
-      decode$2(uint8Array, hex);
-      return true;
-    } catch (e) {
-      return false;
-    }
-  }
-};
-
-var base32$2 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	'default': base32$1
-});
-
-var require$$0 = /*@__PURE__*/getAugmentedNamespace(base32$2);
-
-const base58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
-
-const decode$1 = uint8Array => base(base58).decode(uint8Array);
-
-var base58$1 = {
-  encode: uint8Array => base(base58).encode(uint8Array),
-  decode: decode$1,
-  isBase58: uint8Array => {
-    try {
-      decode$1(uint8Array);
-      return true
-    } catch (e) {
-      return false
-    }
-  }
-};
-
-var base58$2 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	'default': base58$1
-});
-
-var require$$1 = /*@__PURE__*/getAugmentedNamespace(base58$2);
-
-var isHex$1 = string => /^[A-F0-9]+$/i.test(string);
-
-var isHex$2 = /*#__PURE__*/Object.freeze({
-	__proto__: null,
-	'default': isHex$1
-});
-
-var require$$2 = /*@__PURE__*/getAugmentedNamespace(isHex$2);
-
-var encode_1 = encode;
-
-var MSB$1 = 0x80
-  , REST$1 = 0x7F
-  , MSBALL = ~REST$1
-  , INT = Math.pow(2, 31);
-
-function encode(num, out, offset) {
-  if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-    encode.bytes = 0;
-    throw new RangeError('Could not encode varint')
-  }
-  out = out || [];
-  offset = offset || 0;
-  var oldOffset = offset;
-
-  while(num >= INT) {
-    out[offset++] = (num & 0xFF) | MSB$1;
-    num /= 128;
-  }
-  while(num & MSBALL) {
-    out[offset++] = (num & 0xFF) | MSB$1;
-    num >>>= 7;
-  }
-  out[offset] = num | 0;
-  
-  encode.bytes = offset - oldOffset + 1;
-  
-  return out
-}
-
-var decode = read;
-
-var MSB = 0x80
-  , REST = 0x7F;
-
-function read(buf, offset) {
-  var res    = 0
-    , offset = offset || 0
-    , shift  = 0
-    , counter = offset
-    , b
-    , l = buf.length;
-
-  do {
-    if (counter >= l || shift > 49) {
-      read.bytes = 0;
-      throw new RangeError('Could not decode varint')
-    }
-    b = buf[counter++];
-    res += shift < 28
-      ? (b & REST) << shift
-      : (b & REST) * Math.pow(2, shift);
-    shift += 7;
-  } while (b >= MSB)
-
-  read.bytes = counter - offset;
-
-  return res
-}
-
-var N1 = Math.pow(2,  7);
-var N2 = Math.pow(2, 14);
-var N3 = Math.pow(2, 21);
-var N4 = Math.pow(2, 28);
-var N5 = Math.pow(2, 35);
-var N6 = Math.pow(2, 42);
-var N7 = Math.pow(2, 49);
-var N8 = Math.pow(2, 56);
-var N9 = Math.pow(2, 63);
-
-var length = function (value) {
-  return (
-    value < N1 ? 1
-  : value < N2 ? 2
-  : value < N3 ? 3
-  : value < N4 ? 4
-  : value < N5 ? 5
-  : value < N6 ? 6
-  : value < N7 ? 7
-  : value < N8 ? 8
-  : value < N9 ? 9
-  :              10
-  )
-};
-
-var varint$1 = {
-    encode: encode_1
-  , decode: decode
-  , encodingLength: length
-};
-
-var keccak$2 = {exports: {}};
-
-var readable = {exports: {}};
-
-var stream = {exports: {}};
-
-var hasRequiredStream;
-
-function requireStream () {
-	if (hasRequiredStream) return stream.exports;
-	hasRequiredStream = 1;
-	(function (module) {
-		module.exports = require$$0$1;
-} (stream));
-	return stream.exports;
-}
-
-var buffer_list;
-var hasRequiredBuffer_list;
-
-function requireBuffer_list () {
-	if (hasRequiredBuffer_list) return buffer_list;
-	hasRequiredBuffer_list = 1;
-
-	function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-	function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-	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; }
-
-	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-	function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-	function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-	var _require = require$$2$1,
-	    Buffer = _require.Buffer;
-
-	var _require2 = require$$1$1,
-	    inspect = _require2.inspect;
-
-	var custom = inspect && inspect.custom || 'inspect';
-
-	function copyBuffer(src, target, offset) {
-	  Buffer.prototype.copy.call(src, target, offset);
-	}
-
-	buffer_list =
-	/*#__PURE__*/
-	function () {
-	  function BufferList() {
-	    _classCallCheck(this, BufferList);
-
-	    this.head = null;
-	    this.tail = null;
-	    this.length = 0;
-	  }
-
-	  _createClass(BufferList, [{
-	    key: "push",
-	    value: function push(v) {
-	      var entry = {
-	        data: v,
-	        next: null
-	      };
-	      if (this.length > 0) this.tail.next = entry;else this.head = entry;
-	      this.tail = entry;
-	      ++this.length;
-	    }
-	  }, {
-	    key: "unshift",
-	    value: function unshift(v) {
-	      var entry = {
-	        data: v,
-	        next: this.head
-	      };
-	      if (this.length === 0) this.tail = entry;
-	      this.head = entry;
-	      ++this.length;
-	    }
-	  }, {
-	    key: "shift",
-	    value: function shift() {
-	      if (this.length === 0) return;
-	      var ret = this.head.data;
-	      if (this.length === 1) this.head = this.tail = null;else this.head = this.head.next;
-	      --this.length;
-	      return ret;
-	    }
-	  }, {
-	    key: "clear",
-	    value: function clear() {
-	      this.head = this.tail = null;
-	      this.length = 0;
-	    }
-	  }, {
-	    key: "join",
-	    value: function join(s) {
-	      if (this.length === 0) return '';
-	      var p = this.head;
-	      var ret = '' + p.data;
-
-	      while (p = p.next) {
-	        ret += s + p.data;
-	      }
-
-	      return ret;
-	    }
-	  }, {
-	    key: "concat",
-	    value: function concat(n) {
-	      if (this.length === 0) return Buffer.alloc(0);
-	      var ret = Buffer.allocUnsafe(n >>> 0);
-	      var p = this.head;
-	      var i = 0;
-
-	      while (p) {
-	        copyBuffer(p.data, ret, i);
-	        i += p.data.length;
-	        p = p.next;
-	      }
-
-	      return ret;
-	    } // Consumes a specified amount of bytes or characters from the buffered data.
-
-	  }, {
-	    key: "consume",
-	    value: function consume(n, hasStrings) {
-	      var ret;
-
-	      if (n < this.head.data.length) {
-	        // `slice` is the same for buffers and strings.
-	        ret = this.head.data.slice(0, n);
-	        this.head.data = this.head.data.slice(n);
-	      } else if (n === this.head.data.length) {
-	        // First chunk is a perfect match.
-	        ret = this.shift();
-	      } else {
-	        // Result spans more than one buffer.
-	        ret = hasStrings ? this._getString(n) : this._getBuffer(n);
-	      }
-
-	      return ret;
-	    }
-	  }, {
-	    key: "first",
-	    value: function first() {
-	      return this.head.data;
-	    } // Consumes a specified amount of characters from the buffered data.
-
-	  }, {
-	    key: "_getString",
-	    value: function _getString(n) {
-	      var p = this.head;
-	      var c = 1;
-	      var ret = p.data;
-	      n -= ret.length;
-
-	      while (p = p.next) {
-	        var str = p.data;
-	        var nb = n > str.length ? str.length : n;
-	        if (nb === str.length) ret += str;else ret += str.slice(0, n);
-	        n -= nb;
-
-	        if (n === 0) {
-	          if (nb === str.length) {
-	            ++c;
-	            if (p.next) this.head = p.next;else this.head = this.tail = null;
-	          } else {
-	            this.head = p;
-	            p.data = str.slice(nb);
-	          }
-
-	          break;
-	        }
-
-	        ++c;
-	      }
-
-	      this.length -= c;
-	      return ret;
-	    } // Consumes a specified amount of bytes from the buffered data.
-
-	  }, {
-	    key: "_getBuffer",
-	    value: function _getBuffer(n) {
-	      var ret = Buffer.allocUnsafe(n);
-	      var p = this.head;
-	      var c = 1;
-	      p.data.copy(ret);
-	      n -= p.data.length;
-
-	      while (p = p.next) {
-	        var buf = p.data;
-	        var nb = n > buf.length ? buf.length : n;
-	        buf.copy(ret, ret.length - n, 0, nb);
-	        n -= nb;
-
-	        if (n === 0) {
-	          if (nb === buf.length) {
-	            ++c;
-	            if (p.next) this.head = p.next;else this.head = this.tail = null;
-	          } else {
-	            this.head = p;
-	            p.data = buf.slice(nb);
-	          }
-
-	          break;
-	        }
-
-	        ++c;
-	      }
-
-	      this.length -= c;
-	      return ret;
-	    } // Make sure the linked list only shows the minimal necessary information.
-
-	  }, {
-	    key: custom,
-	    value: function value(_, options) {
-	      return inspect(this, _objectSpread({}, options, {
-	        // Only inspect one level.
-	        depth: 0,
-	        // It should not recurse.
-	        customInspect: false
-	      }));
-	    }
-	  }]);
-
-	  return BufferList;
-	}();
-	return buffer_list;
-}
-
-var destroy_1;
-var hasRequiredDestroy;
-
-function requireDestroy () {
-	if (hasRequiredDestroy) return destroy_1;
-	hasRequiredDestroy = 1;
-
-	function destroy(err, cb) {
-	  var _this = this;
-
-	  var readableDestroyed = this._readableState && this._readableState.destroyed;
-	  var writableDestroyed = this._writableState && this._writableState.destroyed;
-
-	  if (readableDestroyed || writableDestroyed) {
-	    if (cb) {
-	      cb(err);
-	    } else if (err) {
-	      if (!this._writableState) {
-	        process.nextTick(emitErrorNT, this, err);
-	      } else if (!this._writableState.errorEmitted) {
-	        this._writableState.errorEmitted = true;
-	        process.nextTick(emitErrorNT, this, err);
-	      }
-	    }
-
-	    return this;
-	  } // we set destroyed to true before firing error callbacks in order
-	  // to make it re-entrance safe in case destroy() is called within callbacks
-
-
-	  if (this._readableState) {
-	    this._readableState.destroyed = true;
-	  } // if this is a duplex stream mark the writable part as destroyed as well
-
-
-	  if (this._writableState) {
-	    this._writableState.destroyed = true;
-	  }
-
-	  this._destroy(err || null, function (err) {
-	    if (!cb && err) {
-	      if (!_this._writableState) {
-	        process.nextTick(emitErrorAndCloseNT, _this, err);
-	      } else if (!_this._writableState.errorEmitted) {
-	        _this._writableState.errorEmitted = true;
-	        process.nextTick(emitErrorAndCloseNT, _this, err);
-	      } else {
-	        process.nextTick(emitCloseNT, _this);
-	      }
-	    } else if (cb) {
-	      process.nextTick(emitCloseNT, _this);
-	      cb(err);
-	    } else {
-	      process.nextTick(emitCloseNT, _this);
-	    }
-	  });
-
-	  return this;
-	}
-
-	function emitErrorAndCloseNT(self, err) {
-	  emitErrorNT(self, err);
-	  emitCloseNT(self);
-	}
-
-	function emitCloseNT(self) {
-	  if (self._writableState && !self._writableState.emitClose) return;
-	  if (self._readableState && !self._readableState.emitClose) return;
-	  self.emit('close');
-	}
-
-	function undestroy() {
-	  if (this._readableState) {
-	    this._readableState.destroyed = false;
-	    this._readableState.reading = false;
-	    this._readableState.ended = false;
-	    this._readableState.endEmitted = false;
-	  }
-
-	  if (this._writableState) {
-	    this._writableState.destroyed = false;
-	    this._writableState.ended = false;
-	    this._writableState.ending = false;
-	    this._writableState.finalCalled = false;
-	    this._writableState.prefinished = false;
-	    this._writableState.finished = false;
-	    this._writableState.errorEmitted = false;
-	  }
-	}
-
-	function emitErrorNT(self, err) {
-	  self.emit('error', err);
-	}
-
-	function errorOrDestroy(stream, err) {
-	  // We have tests that rely on errors being emitted
-	  // in the same tick, so changing this is semver major.
-	  // For now when you opt-in to autoDestroy we allow
-	  // the error to be emitted nextTick. In a future
-	  // semver major update we should change the default to this.
-	  var rState = stream._readableState;
-	  var wState = stream._writableState;
-	  if (rState && rState.autoDestroy || wState && wState.autoDestroy) stream.destroy(err);else stream.emit('error', err);
-	}
-
-	destroy_1 = {
-	  destroy: destroy,
-	  undestroy: undestroy,
-	  errorOrDestroy: errorOrDestroy
-	};
-	return destroy_1;
-}
-
-var errors = {};
-
-var hasRequiredErrors;
-
-function requireErrors () {
-	if (hasRequiredErrors) return errors;
-	hasRequiredErrors = 1;
-
-	const codes = {};
-
-	function createErrorType(code, message, Base) {
-	  if (!Base) {
-	    Base = Error;
-	  }
-
-	  function getMessage (arg1, arg2, arg3) {
-	    if (typeof message === 'string') {
-	      return message
-	    } else {
-	      return message(arg1, arg2, arg3)
-	    }
-	  }
-
-	  class NodeError extends Base {
-	    constructor (arg1, arg2, arg3) {
-	      super(getMessage(arg1, arg2, arg3));
-	    }
-	  }
-
-	  NodeError.prototype.name = Base.name;
-	  NodeError.prototype.code = code;
-
-	  codes[code] = NodeError;
-	}
-
-	// https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
-	function oneOf(expected, thing) {
-	  if (Array.isArray(expected)) {
-	    const len = expected.length;
-	    expected = expected.map((i) => String(i));
-	    if (len > 2) {
-	      return `one of ${thing} ${expected.slice(0, len - 1).join(', ')}, or ` +
-	             expected[len - 1];
-	    } else if (len === 2) {
-	      return `one of ${thing} ${expected[0]} or ${expected[1]}`;
-	    } else {
-	      return `of ${thing} ${expected[0]}`;
-	    }
-	  } else {
-	    return `of ${thing} ${String(expected)}`;
-	  }
-	}
-
-	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
-	function startsWith(str, search, pos) {
-		return str.substr(!pos || pos < 0 ? 0 : +pos, search.length) === search;
-	}
-
-	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith
-	function endsWith(str, search, this_len) {
-		if (this_len === undefined || this_len > str.length) {
-			this_len = str.length;
-		}
-		return str.substring(this_len - search.length, this_len) === search;
-	}
-
-	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
-	function includes(str, search, start) {
-	  if (typeof start !== 'number') {
-	    start = 0;
-	  }
-
-	  if (start + search.length > str.length) {
-	    return false;
-	  } else {
-	    return str.indexOf(search, start) !== -1;
-	  }
-	}
-
-	createErrorType('ERR_INVALID_OPT_VALUE', function (name, value) {
-	  return 'The value "' + value + '" is invalid for option "' + name + '"'
-	}, TypeError);
-	createErrorType('ERR_INVALID_ARG_TYPE', function (name, expected, actual) {
-	  // determiner: 'must be' or 'must not be'
-	  let determiner;
-	  if (typeof expected === 'string' && startsWith(expected, 'not ')) {
-	    determiner = 'must not be';
-	    expected = expected.replace(/^not /, '');
-	  } else {
-	    determiner = 'must be';
-	  }
-
-	  let msg;
-	  if (endsWith(name, ' argument')) {
-	    // For cases like 'first argument'
-	    msg = `The ${name} ${determiner} ${oneOf(expected, 'type')}`;
-	  } else {
-	    const type = includes(name, '.') ? 'property' : 'argument';
-	    msg = `The "${name}" ${type} ${determiner} ${oneOf(expected, 'type')}`;
-	  }
-
-	  msg += `. Received type ${typeof actual}`;
-	  return msg;
-	}, TypeError);
-	createErrorType('ERR_STREAM_PUSH_AFTER_EOF', 'stream.push() after EOF');
-	createErrorType('ERR_METHOD_NOT_IMPLEMENTED', function (name) {
-	  return 'The ' + name + ' method is not implemented'
-	});
-	createErrorType('ERR_STREAM_PREMATURE_CLOSE', 'Premature close');
-	createErrorType('ERR_STREAM_DESTROYED', function (name) {
-	  return 'Cannot call ' + name + ' after a stream was destroyed';
-	});
-	createErrorType('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times');
-	createErrorType('ERR_STREAM_CANNOT_PIPE', 'Cannot pipe, not readable');
-	createErrorType('ERR_STREAM_WRITE_AFTER_END', 'write after end');
-	createErrorType('ERR_STREAM_NULL_VALUES', 'May not write null values to stream', TypeError);
-	createErrorType('ERR_UNKNOWN_ENCODING', function (arg) {
-	  return 'Unknown encoding: ' + arg
-	}, TypeError);
-	createErrorType('ERR_STREAM_UNSHIFT_AFTER_END_EVENT', 'stream.unshift() after end event');
-
-	errors.codes = codes;
-	return errors;
-}
-
-var state;
-var hasRequiredState;
-
-function requireState () {
-	if (hasRequiredState) return state;
-	hasRequiredState = 1;
-
-	var ERR_INVALID_OPT_VALUE = requireErrors().codes.ERR_INVALID_OPT_VALUE;
-
-	function highWaterMarkFrom(options, isDuplex, duplexKey) {
-	  return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
-	}
-
-	function getHighWaterMark(state, options, duplexKey, isDuplex) {
-	  var hwm = highWaterMarkFrom(options, isDuplex, duplexKey);
-
-	  if (hwm != null) {
-	    if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
-	      var name = isDuplex ? duplexKey : 'highWaterMark';
-	      throw new ERR_INVALID_OPT_VALUE(name, hwm);
-	    }
-
-	    return Math.floor(hwm);
-	  } // Default value
-
-
-	  return state.objectMode ? 16 : 16 * 1024;
-	}
-
-	state = {
-	  getHighWaterMark: getHighWaterMark
-	};
-	return state;
-}
-
-var inherits = {exports: {}};
-
-var inherits_browser = {exports: {}};
-
-var hasRequiredInherits_browser;
-
-function requireInherits_browser () {
-	if (hasRequiredInherits_browser) return inherits_browser.exports;
-	hasRequiredInherits_browser = 1;
-	if (typeof Object.create === 'function') {
-	  // implementation from standard node.js 'util' module
-	  inherits_browser.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
-	  inherits_browser.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;
-	    }
-	  };
-	}
-	return inherits_browser.exports;
-}
-
-var hasRequiredInherits;
-
-function requireInherits () {
-	if (hasRequiredInherits) return inherits.exports;
-	hasRequiredInherits = 1;
-	(function (module) {
-		try {
-		  var util = require('util');
-		  /* istanbul ignore next */
-		  if (typeof util.inherits !== 'function') throw '';
-		  module.exports = util.inherits;
-		} catch (e) {
-		  /* istanbul ignore next */
-		  module.exports = requireInherits_browser();
-		}
-} (inherits));
-	return inherits.exports;
-}
-
-var node;
-var hasRequiredNode;
-
-function requireNode () {
-	if (hasRequiredNode) return node;
-	hasRequiredNode = 1;
-	/**
-	 * For Node.js, simply re-export the core `util.deprecate` function.
-	 */
-
-	node = require$$1$1.deprecate;
-	return node;
-}
-
-var _stream_writable;
-var hasRequired_stream_writable;
-
-function require_stream_writable () {
-	if (hasRequired_stream_writable) return _stream_writable;
-	hasRequired_stream_writable = 1;
-
-	_stream_writable = Writable;
-	// there will be only 2 of these for each stream
-
-
-	function CorkedRequest(state) {
-	  var _this = this;
-
-	  this.next = null;
-	  this.entry = null;
-
-	  this.finish = function () {
-	    onCorkedFinish(_this, state);
-	  };
-	}
-	/* </replacement> */
-
-	/*<replacement>*/
-
-
-	var Duplex;
-	/*</replacement>*/
-
-	Writable.WritableState = WritableState;
-	/*<replacement>*/
-
-	var internalUtil = {
-	  deprecate: requireNode()
-	};
-	/*</replacement>*/
-
-	/*<replacement>*/
-
-	var Stream = requireStream();
-	/*</replacement>*/
-
-
-	var Buffer = require$$2$1.Buffer;
-
-	var OurUint8Array = commonjsGlobal.Uint8Array || function () {};
-
-	function _uint8ArrayToBuffer(chunk) {
-	  return Buffer.from(chunk);
-	}
-
-	function _isUint8Array(obj) {
-	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
-	}
-
-	var destroyImpl = requireDestroy();
-
-	var _require = requireState(),
-	    getHighWaterMark = _require.getHighWaterMark;
-
-	var _require$codes = requireErrors().codes,
-	    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,
-	    ERR_STREAM_CANNOT_PIPE = _require$codes.ERR_STREAM_CANNOT_PIPE,
-	    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED,
-	    ERR_STREAM_NULL_VALUES = _require$codes.ERR_STREAM_NULL_VALUES,
-	    ERR_STREAM_WRITE_AFTER_END = _require$codes.ERR_STREAM_WRITE_AFTER_END,
-	    ERR_UNKNOWN_ENCODING = _require$codes.ERR_UNKNOWN_ENCODING;
-
-	var errorOrDestroy = destroyImpl.errorOrDestroy;
-
-	requireInherits()(Writable, Stream);
-
-	function nop() {}
-
-	function WritableState(options, stream, isDuplex) {
-	  Duplex = Duplex || require_stream_duplex();
-	  options = options || {}; // Duplex streams are both readable and writable, but share
-	  // the same options object.
-	  // However, some cases require setting options to different
-	  // values for the readable and the writable sides of the duplex stream,
-	  // e.g. options.readableObjectMode vs. options.writableObjectMode, etc.
-
-	  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag to indicate whether or not this stream
-	  // contains buffers or objects.
-
-	  this.objectMode = !!options.objectMode;
-	  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode; // the point at which write() starts returning false
-	  // Note: 0 is a valid value, means that we always return false if
-	  // the entire buffer is not flushed immediately on write()
-
-	  this.highWaterMark = getHighWaterMark(this, options, 'writableHighWaterMark', isDuplex); // if _final has been called
-
-	  this.finalCalled = false; // drain event flag.
-
-	  this.needDrain = false; // at the start of calling end()
-
-	  this.ending = false; // when end() has been called, and returned
-
-	  this.ended = false; // when 'finish' is emitted
-
-	  this.finished = false; // has it been destroyed
-
-	  this.destroyed = false; // should we decode strings into buffers before passing to _write?
-	  // this is here so that some node-core streams can optimize string
-	  // handling at a lower level.
-
-	  var noDecode = options.decodeStrings === false;
-	  this.decodeStrings = !noDecode; // Crypto is kind of old and crusty.  Historically, its default string
-	  // encoding is 'binary' so we have to make this configurable.
-	  // Everything else in the universe uses 'utf8', though.
-
-	  this.defaultEncoding = options.defaultEncoding || 'utf8'; // not an actual buffer we keep track of, but a measurement
-	  // of how much we're waiting to get pushed to some underlying
-	  // socket or file.
-
-	  this.length = 0; // a flag to see when we're in the middle of a write.
-
-	  this.writing = false; // when true all writes will be buffered until .uncork() call
-
-	  this.corked = 0; // a flag to be able to tell if the onwrite cb is called immediately,
-	  // or on a later tick.  We set this to true at first, because any
-	  // actions that shouldn't happen until "later" should generally also
-	  // not happen before the first write call.
-
-	  this.sync = true; // a flag to know if we're processing previously buffered items, which
-	  // may call the _write() callback in the same tick, so that we don't
-	  // end up in an overlapped onwrite situation.
-
-	  this.bufferProcessing = false; // the callback that's passed to _write(chunk,cb)
-
-	  this.onwrite = function (er) {
-	    onwrite(stream, er);
-	  }; // the callback that the user supplies to write(chunk,encoding,cb)
-
-
-	  this.writecb = null; // the amount that is being written when _write is called.
-
-	  this.writelen = 0;
-	  this.bufferedRequest = null;
-	  this.lastBufferedRequest = null; // number of pending user-supplied write callbacks
-	  // this must be 0 before 'finish' can be emitted
-
-	  this.pendingcb = 0; // emit prefinish if the only thing we're waiting for is _write cbs
-	  // This is relevant for synchronous Transform streams
-
-	  this.prefinished = false; // True if the error was already emitted and should not be thrown again
-
-	  this.errorEmitted = false; // Should close be emitted on destroy. Defaults to true.
-
-	  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'finish' (and potentially 'end')
-
-	  this.autoDestroy = !!options.autoDestroy; // count buffered requests
-
-	  this.bufferedRequestCount = 0; // allocate the first CorkedRequest, there is always
-	  // one allocated and free to use, and we maintain at most two
-
-	  this.corkedRequestsFree = new CorkedRequest(this);
-	}
-
-	WritableState.prototype.getBuffer = function getBuffer() {
-	  var current = this.bufferedRequest;
-	  var out = [];
-
-	  while (current) {
-	    out.push(current);
-	    current = current.next;
-	  }
-
-	  return out;
-	};
-
-	(function () {
-	  try {
-	    Object.defineProperty(WritableState.prototype, 'buffer', {
-	      get: internalUtil.deprecate(function writableStateBufferGetter() {
-	        return this.getBuffer();
-	      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')
-	    });
-	  } catch (_) {}
-	})(); // Test _writableState for inheritance to account for Duplex streams,
-	// whose prototype chain only points to Readable.
-
-
-	var realHasInstance;
-
-	if (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {
-	  realHasInstance = Function.prototype[Symbol.hasInstance];
-	  Object.defineProperty(Writable, Symbol.hasInstance, {
-	    value: function value(object) {
-	      if (realHasInstance.call(this, object)) return true;
-	      if (this !== Writable) return false;
-	      return object && object._writableState instanceof WritableState;
-	    }
-	  });
-	} else {
-	  realHasInstance = function realHasInstance(object) {
-	    return object instanceof this;
-	  };
-	}
-
-	function Writable(options) {
-	  Duplex = Duplex || require_stream_duplex(); // 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
-	  // Node.js LazyTransform implementation, which has a non-trivial getter for
-	  // `_writableState` that would lead to infinite recursion.
-	  // Checking for a Stream.Duplex instance is faster here instead of inside
-	  // the WritableState constructor, at least with V8 6.5
-
-	  var isDuplex = this instanceof Duplex;
-	  if (!isDuplex && !realHasInstance.call(Writable, this)) return new Writable(options);
-	  this._writableState = new WritableState(options, this, isDuplex); // legacy.
-
-	  this.writable = true;
-
-	  if (options) {
-	    if (typeof options.write === 'function') this._write = options.write;
-	    if (typeof options.writev === 'function') this._writev = options.writev;
-	    if (typeof options.destroy === 'function') this._destroy = options.destroy;
-	    if (typeof options.final === 'function') this._final = options.final;
-	  }
-
-	  Stream.call(this);
-	} // Otherwise people can pipe Writable streams, which is just wrong.
-
-
-	Writable.prototype.pipe = function () {
-	  errorOrDestroy(this, new ERR_STREAM_CANNOT_PIPE());
-	};
-
-	function writeAfterEnd(stream, cb) {
-	  var er = new ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
-
-	  errorOrDestroy(stream, er);
-	  process.nextTick(cb, er);
-	} // Checks that a user-supplied chunk is valid, especially for the particular
-	// mode the stream is in. Currently this means that `null` is never accepted
-	// and undefined/non-string values are only allowed in object mode.
-
-
-	function validChunk(stream, state, chunk, cb) {
-	  var er;
-
-	  if (chunk === null) {
-	    er = new ERR_STREAM_NULL_VALUES();
-	  } else if (typeof chunk !== 'string' && !state.objectMode) {
-	    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer'], chunk);
-	  }
-
-	  if (er) {
-	    errorOrDestroy(stream, er);
-	    process.nextTick(cb, er);
-	    return false;
-	  }
-
-	  return true;
-	}
-
-	Writable.prototype.write = function (chunk, encoding, cb) {
-	  var state = this._writableState;
-	  var ret = false;
-
-	  var isBuf = !state.objectMode && _isUint8Array(chunk);
-
-	  if (isBuf && !Buffer.isBuffer(chunk)) {
-	    chunk = _uint8ArrayToBuffer(chunk);
-	  }
-
-	  if (typeof encoding === 'function') {
-	    cb = encoding;
-	    encoding = null;
-	  }
-
-	  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;
-	  if (typeof cb !== 'function') cb = nop;
-	  if (state.ending) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {
-	    state.pendingcb++;
-	    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
-	  }
-	  return ret;
-	};
-
-	Writable.prototype.cork = function () {
-	  this._writableState.corked++;
-	};
-
-	Writable.prototype.uncork = function () {
-	  var state = this._writableState;
-
-	  if (state.corked) {
-	    state.corked--;
-	    if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);
-	  }
-	};
-
-	Writable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {
-	  // node::ParseEncoding() requires lower case.
-	  if (typeof encoding === 'string') encoding = encoding.toLowerCase();
-	  if (!(['hex', 'utf8', 'utf-8', 'ascii', 'binary', 'base64', 'ucs2', 'ucs-2', 'utf16le', 'utf-16le', 'raw'].indexOf((encoding + '').toLowerCase()) > -1)) throw new ERR_UNKNOWN_ENCODING(encoding);
-	  this._writableState.defaultEncoding = encoding;
-	  return this;
-	};
-
-	Object.defineProperty(Writable.prototype, 'writableBuffer', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._writableState && this._writableState.getBuffer();
-	  }
-	});
-
-	function decodeChunk(state, chunk, encoding) {
-	  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {
-	    chunk = Buffer.from(chunk, encoding);
-	  }
-
-	  return chunk;
-	}
-
-	Object.defineProperty(Writable.prototype, 'writableHighWaterMark', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._writableState.highWaterMark;
-	  }
-	}); // if we're already writing something, then just put this
-	// in the queue, and wait our turn.  Otherwise, call _write
-	// If we return false, then we need a drain event, so set that flag.
-
-	function writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
-	  if (!isBuf) {
-	    var newChunk = decodeChunk(state, chunk, encoding);
-
-	    if (chunk !== newChunk) {
-	      isBuf = true;
-	      encoding = 'buffer';
-	      chunk = newChunk;
-	    }
-	  }
-
-	  var len = state.objectMode ? 1 : chunk.length;
-	  state.length += len;
-	  var ret = state.length < state.highWaterMark; // we must ensure that previous needDrain will not be reset to false.
-
-	  if (!ret) state.needDrain = true;
-
-	  if (state.writing || state.corked) {
-	    var last = state.lastBufferedRequest;
-	    state.lastBufferedRequest = {
-	      chunk: chunk,
-	      encoding: encoding,
-	      isBuf: isBuf,
-	      callback: cb,
-	      next: null
-	    };
-
-	    if (last) {
-	      last.next = state.lastBufferedRequest;
-	    } else {
-	      state.bufferedRequest = state.lastBufferedRequest;
-	    }
-
-	    state.bufferedRequestCount += 1;
-	  } else {
-	    doWrite(stream, state, false, len, chunk, encoding, cb);
-	  }
-
-	  return ret;
-	}
-
-	function doWrite(stream, state, writev, len, chunk, encoding, cb) {
-	  state.writelen = len;
-	  state.writecb = cb;
-	  state.writing = true;
-	  state.sync = true;
-	  if (state.destroyed) state.onwrite(new ERR_STREAM_DESTROYED('write'));else if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);
-	  state.sync = false;
-	}
-
-	function onwriteError(stream, state, sync, er, cb) {
-	  --state.pendingcb;
-
-	  if (sync) {
-	    // defer the callback if we are being called synchronously
-	    // to avoid piling up things on the stack
-	    process.nextTick(cb, er); // this can emit finish, and it will always happen
-	    // after error
-
-	    process.nextTick(finishMaybe, stream, state);
-	    stream._writableState.errorEmitted = true;
-	    errorOrDestroy(stream, er);
-	  } else {
-	    // the caller expect this to happen before if
-	    // it is async
-	    cb(er);
-	    stream._writableState.errorEmitted = true;
-	    errorOrDestroy(stream, er); // this can emit finish, but finish must
-	    // always follow error
-
-	    finishMaybe(stream, state);
-	  }
-	}
-
-	function onwriteStateUpdate(state) {
-	  state.writing = false;
-	  state.writecb = null;
-	  state.length -= state.writelen;
-	  state.writelen = 0;
-	}
-
-	function onwrite(stream, er) {
-	  var state = stream._writableState;
-	  var sync = state.sync;
-	  var cb = state.writecb;
-	  if (typeof cb !== 'function') throw new ERR_MULTIPLE_CALLBACK();
-	  onwriteStateUpdate(state);
-	  if (er) onwriteError(stream, state, sync, er, cb);else {
-	    // Check if we're actually ready to finish, but don't emit yet
-	    var finished = needFinish(state) || stream.destroyed;
-
-	    if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) {
-	      clearBuffer(stream, state);
-	    }
-
-	    if (sync) {
-	      process.nextTick(afterWrite, stream, state, finished, cb);
-	    } else {
-	      afterWrite(stream, state, finished, cb);
-	    }
-	  }
-	}
-
-	function afterWrite(stream, state, finished, cb) {
-	  if (!finished) onwriteDrain(stream, state);
-	  state.pendingcb--;
-	  cb();
-	  finishMaybe(stream, state);
-	} // Must force callback to be called on nextTick, so that we don't
-	// emit 'drain' before the write() consumer gets the 'false' return
-	// value, and has a chance to attach a 'drain' listener.
-
-
-	function onwriteDrain(stream, state) {
-	  if (state.length === 0 && state.needDrain) {
-	    state.needDrain = false;
-	    stream.emit('drain');
-	  }
-	} // if there's something in the buffer waiting, then process it
-
-
-	function clearBuffer(stream, state) {
-	  state.bufferProcessing = true;
-	  var entry = state.bufferedRequest;
-
-	  if (stream._writev && entry && entry.next) {
-	    // Fast case, write everything using _writev()
-	    var l = state.bufferedRequestCount;
-	    var buffer = new Array(l);
-	    var holder = state.corkedRequestsFree;
-	    holder.entry = entry;
-	    var count = 0;
-	    var allBuffers = true;
-
-	    while (entry) {
-	      buffer[count] = entry;
-	      if (!entry.isBuf) allBuffers = false;
-	      entry = entry.next;
-	      count += 1;
-	    }
-
-	    buffer.allBuffers = allBuffers;
-	    doWrite(stream, state, true, state.length, buffer, '', holder.finish); // doWrite is almost always async, defer these to save a bit of time
-	    // as the hot path ends with doWrite
-
-	    state.pendingcb++;
-	    state.lastBufferedRequest = null;
-
-	    if (holder.next) {
-	      state.corkedRequestsFree = holder.next;
-	      holder.next = null;
-	    } else {
-	      state.corkedRequestsFree = new CorkedRequest(state);
-	    }
-
-	    state.bufferedRequestCount = 0;
-	  } else {
-	    // Slow case, write chunks one-by-one
-	    while (entry) {
-	      var chunk = entry.chunk;
-	      var encoding = entry.encoding;
-	      var cb = entry.callback;
-	      var len = state.objectMode ? 1 : chunk.length;
-	      doWrite(stream, state, false, len, chunk, encoding, cb);
-	      entry = entry.next;
-	      state.bufferedRequestCount--; // if we didn't call the onwrite immediately, then
-	      // it means that we need to wait until it does.
-	      // also, that means that the chunk and cb are currently
-	      // being processed, so move the buffer counter past them.
-
-	      if (state.writing) {
-	        break;
-	      }
-	    }
-
-	    if (entry === null) state.lastBufferedRequest = null;
-	  }
-
-	  state.bufferedRequest = entry;
-	  state.bufferProcessing = false;
-	}
-
-	Writable.prototype._write = function (chunk, encoding, cb) {
-	  cb(new ERR_METHOD_NOT_IMPLEMENTED('_write()'));
-	};
-
-	Writable.prototype._writev = null;
-
-	Writable.prototype.end = function (chunk, encoding, cb) {
-	  var state = this._writableState;
-
-	  if (typeof chunk === 'function') {
-	    cb = chunk;
-	    chunk = null;
-	    encoding = null;
-	  } else if (typeof encoding === 'function') {
-	    cb = encoding;
-	    encoding = null;
-	  }
-
-	  if (chunk !== null && chunk !== undefined) this.write(chunk, encoding); // .end() fully uncorks
-
-	  if (state.corked) {
-	    state.corked = 1;
-	    this.uncork();
-	  } // ignore unnecessary end() calls.
-
-
-	  if (!state.ending) endWritable(this, state, cb);
-	  return this;
-	};
-
-	Object.defineProperty(Writable.prototype, 'writableLength', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._writableState.length;
-	  }
-	});
-
-	function needFinish(state) {
-	  return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
-	}
-
-	function callFinal(stream, state) {
-	  stream._final(function (err) {
-	    state.pendingcb--;
-
-	    if (err) {
-	      errorOrDestroy(stream, err);
-	    }
-
-	    state.prefinished = true;
-	    stream.emit('prefinish');
-	    finishMaybe(stream, state);
-	  });
-	}
-
-	function prefinish(stream, state) {
-	  if (!state.prefinished && !state.finalCalled) {
-	    if (typeof stream._final === 'function' && !state.destroyed) {
-	      state.pendingcb++;
-	      state.finalCalled = true;
-	      process.nextTick(callFinal, stream, state);
-	    } else {
-	      state.prefinished = true;
-	      stream.emit('prefinish');
-	    }
-	  }
-	}
-
-	function finishMaybe(stream, state) {
-	  var need = needFinish(state);
-
-	  if (need) {
-	    prefinish(stream, state);
-
-	    if (state.pendingcb === 0) {
-	      state.finished = true;
-	      stream.emit('finish');
-
-	      if (state.autoDestroy) {
-	        // In case of duplex streams we need a way to detect
-	        // if the readable side is ready for autoDestroy as well
-	        var rState = stream._readableState;
-
-	        if (!rState || rState.autoDestroy && rState.endEmitted) {
-	          stream.destroy();
-	        }
-	      }
-	    }
-	  }
-
-	  return need;
-	}
-
-	function endWritable(stream, state, cb) {
-	  state.ending = true;
-	  finishMaybe(stream, state);
-
-	  if (cb) {
-	    if (state.finished) process.nextTick(cb);else stream.once('finish', cb);
-	  }
-
-	  state.ended = true;
-	  stream.writable = false;
-	}
-
-	function onCorkedFinish(corkReq, state, err) {
-	  var entry = corkReq.entry;
-	  corkReq.entry = null;
-
-	  while (entry) {
-	    var cb = entry.callback;
-	    state.pendingcb--;
-	    cb(err);
-	    entry = entry.next;
-	  } // reuse the free corkReq.
-
-
-	  state.corkedRequestsFree.next = corkReq;
-	}
-
-	Object.defineProperty(Writable.prototype, 'destroyed', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    if (this._writableState === undefined) {
-	      return false;
-	    }
-
-	    return this._writableState.destroyed;
-	  },
-	  set: function set(value) {
-	    // we ignore the value if the stream
-	    // has not been initialized yet
-	    if (!this._writableState) {
-	      return;
-	    } // backward compatibility, the user is explicitly
-	    // managing destroyed
-
-
-	    this._writableState.destroyed = value;
-	  }
-	});
-	Writable.prototype.destroy = destroyImpl.destroy;
-	Writable.prototype._undestroy = destroyImpl.undestroy;
-
-	Writable.prototype._destroy = function (err, cb) {
-	  cb(err);
-	};
-	return _stream_writable;
-}
-
-var _stream_duplex;
-var hasRequired_stream_duplex;
-
-function require_stream_duplex () {
-	if (hasRequired_stream_duplex) return _stream_duplex;
-	hasRequired_stream_duplex = 1;
-	/*<replacement>*/
-
-	var objectKeys = Object.keys || function (obj) {
-	  var keys = [];
-
-	  for (var key in obj) {
-	    keys.push(key);
-	  }
-
-	  return keys;
-	};
-	/*</replacement>*/
-
-
-	_stream_duplex = Duplex;
-
-	var Readable = require_stream_readable();
-
-	var Writable = require_stream_writable();
-
-	requireInherits()(Duplex, Readable);
-
-	{
-	  // Allow the keys array to be GC'ed.
-	  var keys = objectKeys(Writable.prototype);
-
-	  for (var v = 0; v < keys.length; v++) {
-	    var method = keys[v];
-	    if (!Duplex.prototype[method]) Duplex.prototype[method] = Writable.prototype[method];
-	  }
-	}
-
-	function Duplex(options) {
-	  if (!(this instanceof Duplex)) return new Duplex(options);
-	  Readable.call(this, options);
-	  Writable.call(this, options);
-	  this.allowHalfOpen = true;
-
-	  if (options) {
-	    if (options.readable === false) this.readable = false;
-	    if (options.writable === false) this.writable = false;
-
-	    if (options.allowHalfOpen === false) {
-	      this.allowHalfOpen = false;
-	      this.once('end', onend);
-	    }
-	  }
-	}
-
-	Object.defineProperty(Duplex.prototype, 'writableHighWaterMark', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._writableState.highWaterMark;
-	  }
-	});
-	Object.defineProperty(Duplex.prototype, 'writableBuffer', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._writableState && this._writableState.getBuffer();
-	  }
-	});
-	Object.defineProperty(Duplex.prototype, 'writableLength', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._writableState.length;
-	  }
-	}); // the no-half-open enforcer
-
-	function onend() {
-	  // If the writable side ended, then we're ok.
-	  if (this._writableState.ended) return; // no more data can be written.
-	  // But allow more writes to happen in this tick.
-
-	  process.nextTick(onEndNT, this);
-	}
-
-	function onEndNT(self) {
-	  self.end();
-	}
-
-	Object.defineProperty(Duplex.prototype, 'destroyed', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    if (this._readableState === undefined || this._writableState === undefined) {
-	      return false;
-	    }
-
-	    return this._readableState.destroyed && this._writableState.destroyed;
-	  },
-	  set: function set(value) {
-	    // we ignore the value if the stream
-	    // has not been initialized yet
-	    if (this._readableState === undefined || this._writableState === undefined) {
-	      return;
-	    } // backward compatibility, the user is explicitly
-	    // managing destroyed
-
-
-	    this._readableState.destroyed = value;
-	    this._writableState.destroyed = value;
-	  }
-	});
-	return _stream_duplex;
-}
-
-var endOfStream;
-var hasRequiredEndOfStream;
-
-function requireEndOfStream () {
-	if (hasRequiredEndOfStream) return endOfStream;
-	hasRequiredEndOfStream = 1;
-
-	var ERR_STREAM_PREMATURE_CLOSE = requireErrors().codes.ERR_STREAM_PREMATURE_CLOSE;
-
-	function once(callback) {
-	  var called = false;
-	  return function () {
-	    if (called) return;
-	    called = true;
-
-	    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-	      args[_key] = arguments[_key];
-	    }
-
-	    callback.apply(this, args);
-	  };
-	}
-
-	function noop() {}
-
-	function isRequest(stream) {
-	  return stream.setHeader && typeof stream.abort === 'function';
-	}
-
-	function eos(stream, opts, callback) {
-	  if (typeof opts === 'function') return eos(stream, null, opts);
-	  if (!opts) opts = {};
-	  callback = once(callback || noop);
-	  var readable = opts.readable || opts.readable !== false && stream.readable;
-	  var writable = opts.writable || opts.writable !== false && stream.writable;
-
-	  var onlegacyfinish = function onlegacyfinish() {
-	    if (!stream.writable) onfinish();
-	  };
-
-	  var writableEnded = stream._writableState && stream._writableState.finished;
-
-	  var onfinish = function onfinish() {
-	    writable = false;
-	    writableEnded = true;
-	    if (!readable) callback.call(stream);
-	  };
-
-	  var readableEnded = stream._readableState && stream._readableState.endEmitted;
-
-	  var onend = function onend() {
-	    readable = false;
-	    readableEnded = true;
-	    if (!writable) callback.call(stream);
-	  };
-
-	  var onerror = function onerror(err) {
-	    callback.call(stream, err);
-	  };
-
-	  var onclose = function onclose() {
-	    var err;
-
-	    if (readable && !readableEnded) {
-	      if (!stream._readableState || !stream._readableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
-	      return callback.call(stream, err);
-	    }
-
-	    if (writable && !writableEnded) {
-	      if (!stream._writableState || !stream._writableState.ended) err = new ERR_STREAM_PREMATURE_CLOSE();
-	      return callback.call(stream, err);
-	    }
-	  };
-
-	  var onrequest = function onrequest() {
-	    stream.req.on('finish', onfinish);
-	  };
-
-	  if (isRequest(stream)) {
-	    stream.on('complete', onfinish);
-	    stream.on('abort', onclose);
-	    if (stream.req) onrequest();else stream.on('request', onrequest);
-	  } else if (writable && !stream._writableState) {
-	    // legacy streams
-	    stream.on('end', onlegacyfinish);
-	    stream.on('close', onlegacyfinish);
-	  }
-
-	  stream.on('end', onend);
-	  stream.on('finish', onfinish);
-	  if (opts.error !== false) stream.on('error', onerror);
-	  stream.on('close', onclose);
-	  return function () {
-	    stream.removeListener('complete', onfinish);
-	    stream.removeListener('abort', onclose);
-	    stream.removeListener('request', onrequest);
-	    if (stream.req) stream.req.removeListener('finish', onfinish);
-	    stream.removeListener('end', onlegacyfinish);
-	    stream.removeListener('close', onlegacyfinish);
-	    stream.removeListener('finish', onfinish);
-	    stream.removeListener('end', onend);
-	    stream.removeListener('error', onerror);
-	    stream.removeListener('close', onclose);
-	  };
-	}
-
-	endOfStream = eos;
-	return endOfStream;
-}
-
-var async_iterator;
-var hasRequiredAsync_iterator;
-
-function requireAsync_iterator () {
-	if (hasRequiredAsync_iterator) return async_iterator;
-	hasRequiredAsync_iterator = 1;
-
-	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 = requireEndOfStream();
-
-	var kLastResolve = Symbol('lastResolve');
-	var kLastReject = Symbol('lastReject');
-	var kError = Symbol('error');
-	var kEnded = Symbol('ended');
-	var kLastPromise = Symbol('lastPromise');
-	var kHandlePromise = Symbol('handlePromise');
-	var kStream = Symbol('stream');
-
-	function createIterResult(value, done) {
-	  return {
-	    value: value,
-	    done: done
-	  };
-	}
-
-	function readAndResolve(iter) {
-	  var resolve = iter[kLastResolve];
-
-	  if (resolve !== null) {
-	    var data = iter[kStream].read(); // we defer if data is null
-	    // we can be expecting either 'end' or
-	    // 'error'
-
-	    if (data !== null) {
-	      iter[kLastPromise] = null;
-	      iter[kLastResolve] = null;
-	      iter[kLastReject] = null;
-	      resolve(createIterResult(data, false));
-	    }
-	  }
-	}
-
-	function onReadable(iter) {
-	  // we wait for the next tick, because it might
-	  // emit an error with process.nextTick
-	  process.nextTick(readAndResolve, iter);
-	}
-
-	function wrapForNext(lastPromise, iter) {
-	  return function (resolve, reject) {
-	    lastPromise.then(function () {
-	      if (iter[kEnded]) {
-	        resolve(createIterResult(undefined, true));
-	        return;
-	      }
-
-	      iter[kHandlePromise](resolve, reject);
-	    }, reject);
-	  };
-	}
-
-	var AsyncIteratorPrototype = Object.getPrototypeOf(function () {});
-	var ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf((_Object$setPrototypeO = {
-	  get stream() {
-	    return this[kStream];
-	  },
-
-	  next: function next() {
-	    var _this = this;
-
-	    // if we have detected an error in the meanwhile
-	    // reject straight away
-	    var error = this[kError];
-
-	    if (error !== null) {
-	      return Promise.reject(error);
-	    }
-
-	    if (this[kEnded]) {
-	      return Promise.resolve(createIterResult(undefined, true));
-	    }
-
-	    if (this[kStream].destroyed) {
-	      // We need to defer via nextTick because if .destroy(err) is
-	      // called, the error will be emitted via nextTick, and
-	      // we cannot guarantee that there is no error lingering around
-	      // waiting to be emitted.
-	      return new Promise(function (resolve, reject) {
-	        process.nextTick(function () {
-	          if (_this[kError]) {
-	            reject(_this[kError]);
-	          } else {
-	            resolve(createIterResult(undefined, true));
-	          }
-	        });
-	      });
-	    } // if we have multiple next() calls
-	    // we will wait for the previous Promise to finish
-	    // this logic is optimized to support for await loops,
-	    // where next() is only called once at a time
-
-
-	    var lastPromise = this[kLastPromise];
-	    var promise;
-
-	    if (lastPromise) {
-	      promise = new Promise(wrapForNext(lastPromise, this));
-	    } else {
-	      // fast path needed to support multiple this.push()
-	      // without triggering the next() queue
-	      var data = this[kStream].read();
-
-	      if (data !== null) {
-	        return Promise.resolve(createIterResult(data, false));
-	      }
-
-	      promise = new Promise(this[kHandlePromise]);
-	    }
-
-	    this[kLastPromise] = promise;
-	    return promise;
-	  }
-	}, _defineProperty(_Object$setPrototypeO, Symbol.asyncIterator, function () {
-	  return this;
-	}), _defineProperty(_Object$setPrototypeO, "return", function _return() {
-	  var _this2 = this;
-
-	  // destroy(err, cb) is a private API
-	  // we can guarantee we have that here, because we control the
-	  // Readable class this is attached to
-	  return new Promise(function (resolve, reject) {
-	    _this2[kStream].destroy(null, function (err) {
-	      if (err) {
-	        reject(err);
-	        return;
-	      }
-
-	      resolve(createIterResult(undefined, true));
-	    });
-	  });
-	}), _Object$setPrototypeO), AsyncIteratorPrototype);
-
-	var createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
-	  var _Object$create;
-
-	  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, _defineProperty(_Object$create, kStream, {
-	    value: stream,
-	    writable: true
-	  }), _defineProperty(_Object$create, kLastResolve, {
-	    value: null,
-	    writable: true
-	  }), _defineProperty(_Object$create, kLastReject, {
-	    value: null,
-	    writable: true
-	  }), _defineProperty(_Object$create, kError, {
-	    value: null,
-	    writable: true
-	  }), _defineProperty(_Object$create, kEnded, {
-	    value: stream._readableState.endEmitted,
-	    writable: true
-	  }), _defineProperty(_Object$create, kHandlePromise, {
-	    value: function value(resolve, reject) {
-	      var data = iterator[kStream].read();
-
-	      if (data) {
-	        iterator[kLastPromise] = null;
-	        iterator[kLastResolve] = null;
-	        iterator[kLastReject] = null;
-	        resolve(createIterResult(data, false));
-	      } else {
-	        iterator[kLastResolve] = resolve;
-	        iterator[kLastReject] = reject;
-	      }
-	    },
-	    writable: true
-	  }), _Object$create));
-	  iterator[kLastPromise] = null;
-	  finished(stream, function (err) {
-	    if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
-	      var reject = iterator[kLastReject]; // reject if we are waiting for data in the Promise
-	      // returned by next() and store the error
-
-	      if (reject !== null) {
-	        iterator[kLastPromise] = null;
-	        iterator[kLastResolve] = null;
-	        iterator[kLastReject] = null;
-	        reject(err);
-	      }
-
-	      iterator[kError] = err;
-	      return;
-	    }
-
-	    var resolve = iterator[kLastResolve];
-
-	    if (resolve !== null) {
-	      iterator[kLastPromise] = null;
-	      iterator[kLastResolve] = null;
-	      iterator[kLastReject] = null;
-	      resolve(createIterResult(undefined, true));
-	    }
-
-	    iterator[kEnded] = true;
-	  });
-	  stream.on('readable', onReadable.bind(null, iterator));
-	  return iterator;
-	};
-
-	async_iterator = createReadableStreamAsyncIterator;
-	return async_iterator;
-}
-
-var from_1;
-var hasRequiredFrom;
-
-function requireFrom () {
-	if (hasRequiredFrom) return from_1;
-	hasRequiredFrom = 1;
-
-	function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-	function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-	function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
-
-	function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-	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 ERR_INVALID_ARG_TYPE = requireErrors().codes.ERR_INVALID_ARG_TYPE;
-
-	function from(Readable, iterable, opts) {
-	  var iterator;
-
-	  if (iterable && typeof iterable.next === 'function') {
-	    iterator = iterable;
-	  } else if (iterable && iterable[Symbol.asyncIterator]) iterator = iterable[Symbol.asyncIterator]();else if (iterable && iterable[Symbol.iterator]) iterator = iterable[Symbol.iterator]();else throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
-
-	  var readable = new Readable(_objectSpread({
-	    objectMode: true
-	  }, opts)); // Reading boolean to protect against _read
-	  // being called before last iteration completion.
-
-	  var reading = false;
-
-	  readable._read = function () {
-	    if (!reading) {
-	      reading = true;
-	      next();
-	    }
-	  };
-
-	  function next() {
-	    return _next2.apply(this, arguments);
-	  }
-
-	  function _next2() {
-	    _next2 = _asyncToGenerator(function* () {
-	      try {
-	        var _ref = yield iterator.next(),
-	            value = _ref.value,
-	            done = _ref.done;
-
-	        if (done) {
-	          readable.push(null);
-	        } else if (readable.push((yield value))) {
-	          next();
-	        } else {
-	          reading = false;
-	        }
-	      } catch (err) {
-	        readable.destroy(err);
-	      }
-	    });
-	    return _next2.apply(this, arguments);
-	  }
-
-	  return readable;
-	}
-
-	from_1 = from;
-	return from_1;
-}
-
-var _stream_readable;
-var hasRequired_stream_readable;
-
-function require_stream_readable () {
-	if (hasRequired_stream_readable) return _stream_readable;
-	hasRequired_stream_readable = 1;
-
-	_stream_readable = Readable;
-	/*<replacement>*/
-
-	var Duplex;
-	/*</replacement>*/
-
-	Readable.ReadableState = ReadableState;
-	/*<replacement>*/
-
-	require$$0$2.EventEmitter;
-
-	var EElistenerCount = function EElistenerCount(emitter, type) {
-	  return emitter.listeners(type).length;
-	};
-	/*</replacement>*/
-
-	/*<replacement>*/
-
-
-	var Stream = requireStream();
-	/*</replacement>*/
-
-
-	var Buffer = require$$2$1.Buffer;
-
-	var OurUint8Array = commonjsGlobal.Uint8Array || function () {};
-
-	function _uint8ArrayToBuffer(chunk) {
-	  return Buffer.from(chunk);
-	}
-
-	function _isUint8Array(obj) {
-	  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;
-	}
-	/*<replacement>*/
-
-
-	var debugUtil = require$$1$1;
-
-	var debug;
-
-	if (debugUtil && debugUtil.debuglog) {
-	  debug = debugUtil.debuglog('stream');
-	} else {
-	  debug = function debug() {};
-	}
-	/*</replacement>*/
-
-
-	var BufferList = requireBuffer_list();
-
-	var destroyImpl = requireDestroy();
-
-	var _require = requireState(),
-	    getHighWaterMark = _require.getHighWaterMark;
-
-	var _require$codes = requireErrors().codes,
-	    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,
-	    ERR_STREAM_UNSHIFT_AFTER_END_EVENT = _require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.
-
-
-	var StringDecoder;
-	var createReadableStreamAsyncIterator;
-	var from;
-
-	requireInherits()(Readable, Stream);
-
-	var errorOrDestroy = destroyImpl.errorOrDestroy;
-	var kProxyEvents = ['error', 'close', 'destroy', 'pause', 'resume'];
-
-	function prependListener(emitter, event, fn) {
-	  // Sadly this is not cacheable as some libraries bundle their own
-	  // event emitter implementation with them.
-	  if (typeof emitter.prependListener === 'function') return emitter.prependListener(event, fn); // This is a hack to make sure that our error handler is attached before any
-	  // userland ones.  NEVER DO THIS. This is here only because this code needs
-	  // to continue to work with older versions of Node.js that do not include
-	  // the prependListener() method. The goal is to eventually remove this hack.
-
-	  if (!emitter._events || !emitter._events[event]) emitter.on(event, fn);else if (Array.isArray(emitter._events[event])) emitter._events[event].unshift(fn);else emitter._events[event] = [fn, emitter._events[event]];
-	}
-
-	function ReadableState(options, stream, isDuplex) {
-	  Duplex = Duplex || require_stream_duplex();
-	  options = options || {}; // Duplex streams are both readable and writable, but share
-	  // the same options object.
-	  // However, some cases require setting options to different
-	  // values for the readable and the writable sides of the duplex stream.
-	  // These options can be provided separately as readableXXX and writableXXX.
-
-	  if (typeof isDuplex !== 'boolean') isDuplex = stream instanceof Duplex; // object stream flag. Used to make read(n) ignore n and to
-	  // make all the buffer merging and length checks go away
-
-	  this.objectMode = !!options.objectMode;
-	  if (isDuplex) this.objectMode = this.objectMode || !!options.readableObjectMode; // the point at which it stops calling _read() to fill the buffer
-	  // Note: 0 is a valid value, means "don't call _read preemptively ever"
-
-	  this.highWaterMark = getHighWaterMark(this, options, 'readableHighWaterMark', isDuplex); // A linked list is used to store data chunks instead of an array because the
-	  // linked list can remove elements from the beginning faster than
-	  // array.shift()
-
-	  this.buffer = new BufferList();
-	  this.length = 0;
-	  this.pipes = null;
-	  this.pipesCount = 0;
-	  this.flowing = null;
-	  this.ended = false;
-	  this.endEmitted = false;
-	  this.reading = false; // a flag to be able to tell if the event 'readable'/'data' is emitted
-	  // immediately, or on a later tick.  We set this to true at first, because
-	  // any actions that shouldn't happen until "later" should generally also
-	  // not happen before the first read call.
-
-	  this.sync = true; // whenever we return null, then we set a flag to say
-	  // that we're awaiting a 'readable' event emission.
-
-	  this.needReadable = false;
-	  this.emittedReadable = false;
-	  this.readableListening = false;
-	  this.resumeScheduled = false;
-	  this.paused = true; // Should close be emitted on destroy. Defaults to true.
-
-	  this.emitClose = options.emitClose !== false; // Should .destroy() be called after 'end' (and potentially 'finish')
-
-	  this.autoDestroy = !!options.autoDestroy; // has it been destroyed
-
-	  this.destroyed = false; // Crypto is kind of old and crusty.  Historically, its default string
-	  // encoding is 'binary' so we have to make this configurable.
-	  // Everything else in the universe uses 'utf8', though.
-
-	  this.defaultEncoding = options.defaultEncoding || 'utf8'; // the number of writers that are awaiting a drain event in .pipe()s
-
-	  this.awaitDrain = 0; // if true, a maybeReadMore has been scheduled
-
-	  this.readingMore = false;
-	  this.decoder = null;
-	  this.encoding = null;
-
-	  if (options.encoding) {
-	    if (!StringDecoder) StringDecoder = require$$10.StringDecoder;
-	    this.decoder = new StringDecoder(options.encoding);
-	    this.encoding = options.encoding;
-	  }
-	}
-
-	function Readable(options) {
-	  Duplex = Duplex || require_stream_duplex();
-	  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
-
-	  var isDuplex = this instanceof Duplex;
-	  this._readableState = new ReadableState(options, this, isDuplex); // legacy
-
-	  this.readable = true;
-
-	  if (options) {
-	    if (typeof options.read === 'function') this._read = options.read;
-	    if (typeof options.destroy === 'function') this._destroy = options.destroy;
-	  }
-
-	  Stream.call(this);
-	}
-
-	Object.defineProperty(Readable.prototype, 'destroyed', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    if (this._readableState === undefined) {
-	      return false;
-	    }
-
-	    return this._readableState.destroyed;
-	  },
-	  set: function set(value) {
-	    // we ignore the value if the stream
-	    // has not been initialized yet
-	    if (!this._readableState) {
-	      return;
-	    } // backward compatibility, the user is explicitly
-	    // managing destroyed
-
-
-	    this._readableState.destroyed = value;
-	  }
-	});
-	Readable.prototype.destroy = destroyImpl.destroy;
-	Readable.prototype._undestroy = destroyImpl.undestroy;
-
-	Readable.prototype._destroy = function (err, cb) {
-	  cb(err);
-	}; // Manually shove something into the read() buffer.
-	// This returns true if the highWaterMark has not been hit yet,
-	// similar to how Writable.write() returns true if you should
-	// write() some more.
-
-
-	Readable.prototype.push = function (chunk, encoding) {
-	  var state = this._readableState;
-	  var skipChunkCheck;
-
-	  if (!state.objectMode) {
-	    if (typeof chunk === 'string') {
-	      encoding = encoding || state.defaultEncoding;
-
-	      if (encoding !== state.encoding) {
-	        chunk = Buffer.from(chunk, encoding);
-	        encoding = '';
-	      }
-
-	      skipChunkCheck = true;
-	    }
-	  } else {
-	    skipChunkCheck = true;
-	  }
-
-	  return readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
-	}; // Unshift should *always* be something directly out of read()
-
-
-	Readable.prototype.unshift = function (chunk) {
-	  return readableAddChunk(this, chunk, null, true, false);
-	};
-
-	function readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
-	  debug('readableAddChunk', chunk);
-	  var state = stream._readableState;
-
-	  if (chunk === null) {
-	    state.reading = false;
-	    onEofChunk(stream, state);
-	  } else {
-	    var er;
-	    if (!skipChunkCheck) er = chunkInvalid(state, chunk);
-
-	    if (er) {
-	      errorOrDestroy(stream, er);
-	    } else if (state.objectMode || chunk && chunk.length > 0) {
-	      if (typeof chunk !== 'string' && !state.objectMode && Object.getPrototypeOf(chunk) !== Buffer.prototype) {
-	        chunk = _uint8ArrayToBuffer(chunk);
-	      }
-
-	      if (addToFront) {
-	        if (state.endEmitted) errorOrDestroy(stream, new ERR_STREAM_UNSHIFT_AFTER_END_EVENT());else addChunk(stream, state, chunk, true);
-	      } else if (state.ended) {
-	        errorOrDestroy(stream, new ERR_STREAM_PUSH_AFTER_EOF());
-	      } else if (state.destroyed) {
-	        return false;
-	      } else {
-	        state.reading = false;
-
-	        if (state.decoder && !encoding) {
-	          chunk = state.decoder.write(chunk);
-	          if (state.objectMode || chunk.length !== 0) addChunk(stream, state, chunk, false);else maybeReadMore(stream, state);
-	        } else {
-	          addChunk(stream, state, chunk, false);
-	        }
-	      }
-	    } else if (!addToFront) {
-	      state.reading = false;
-	      maybeReadMore(stream, state);
-	    }
-	  } // We can push more data if we are below the highWaterMark.
-	  // Also, if we have no data yet, we can stand some more bytes.
-	  // This is to work around cases where hwm=0, such as the repl.
-
-
-	  return !state.ended && (state.length < state.highWaterMark || state.length === 0);
-	}
-
-	function addChunk(stream, state, chunk, addToFront) {
-	  if (state.flowing && state.length === 0 && !state.sync) {
-	    state.awaitDrain = 0;
-	    stream.emit('data', chunk);
-	  } else {
-	    // update the buffer info.
-	    state.length += state.objectMode ? 1 : chunk.length;
-	    if (addToFront) state.buffer.unshift(chunk);else state.buffer.push(chunk);
-	    if (state.needReadable) emitReadable(stream);
-	  }
-
-	  maybeReadMore(stream, state);
-	}
-
-	function chunkInvalid(state, chunk) {
-	  var er;
-
-	  if (!_isUint8Array(chunk) && typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {
-	    er = new ERR_INVALID_ARG_TYPE('chunk', ['string', 'Buffer', 'Uint8Array'], chunk);
-	  }
-
-	  return er;
-	}
-
-	Readable.prototype.isPaused = function () {
-	  return this._readableState.flowing === false;
-	}; // backwards compatibility.
-
-
-	Readable.prototype.setEncoding = function (enc) {
-	  if (!StringDecoder) StringDecoder = require$$10.StringDecoder;
-	  var decoder = new StringDecoder(enc);
-	  this._readableState.decoder = decoder; // If setEncoding(null), decoder.encoding equals utf8
-
-	  this._readableState.encoding = this._readableState.decoder.encoding; // Iterate over current buffer to convert already stored Buffers:
-
-	  var p = this._readableState.buffer.head;
-	  var content = '';
-
-	  while (p !== null) {
-	    content += decoder.write(p.data);
-	    p = p.next;
-	  }
-
-	  this._readableState.buffer.clear();
-
-	  if (content !== '') this._readableState.buffer.push(content);
-	  this._readableState.length = content.length;
-	  return this;
-	}; // Don't raise the hwm > 1GB
-
-
-	var MAX_HWM = 0x40000000;
-
-	function computeNewHighWaterMark(n) {
-	  if (n >= MAX_HWM) {
-	    // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
-	    n = MAX_HWM;
-	  } else {
-	    // Get the next highest power of 2 to prevent increasing hwm excessively in
-	    // tiny amounts
-	    n--;
-	    n |= n >>> 1;
-	    n |= n >>> 2;
-	    n |= n >>> 4;
-	    n |= n >>> 8;
-	    n |= n >>> 16;
-	    n++;
-	  }
-
-	  return n;
-	} // This function is designed to be inlinable, so please take care when making
-	// changes to the function body.
-
-
-	function howMuchToRead(n, state) {
-	  if (n <= 0 || state.length === 0 && state.ended) return 0;
-	  if (state.objectMode) return 1;
-
-	  if (n !== n) {
-	    // Only flow one buffer at a time
-	    if (state.flowing && state.length) return state.buffer.head.data.length;else return state.length;
-	  } // If we're asking for more than the current hwm, then raise the hwm.
-
-
-	  if (n > state.highWaterMark) state.highWaterMark = computeNewHighWaterMark(n);
-	  if (n <= state.length) return n; // Don't have enough
-
-	  if (!state.ended) {
-	    state.needReadable = true;
-	    return 0;
-	  }
-
-	  return state.length;
-	} // you can override either this method, or the async _read(n) below.
-
-
-	Readable.prototype.read = function (n) {
-	  debug('read', n);
-	  n = parseInt(n, 10);
-	  var state = this._readableState;
-	  var nOrig = n;
-	  if (n !== 0) state.emittedReadable = false; // if we're doing read(0) to trigger a readable event, but we
-	  // already have a bunch of data in the buffer, then just trigger
-	  // the 'readable' event and move on.
-
-	  if (n === 0 && state.needReadable && ((state.highWaterMark !== 0 ? state.length >= state.highWaterMark : state.length > 0) || state.ended)) {
-	    debug('read: emitReadable', state.length, state.ended);
-	    if (state.length === 0 && state.ended) endReadable(this);else emitReadable(this);
-	    return null;
-	  }
-
-	  n = howMuchToRead(n, state); // if we've ended, and we're now clear, then finish it up.
-
-	  if (n === 0 && state.ended) {
-	    if (state.length === 0) endReadable(this);
-	    return null;
-	  } // All the actual chunk generation logic needs to be
-	  // *below* the call to _read.  The reason is that in certain
-	  // synthetic stream cases, such as passthrough streams, _read
-	  // may be a completely synchronous operation which may change
-	  // the state of the read buffer, providing enough data when
-	  // before there was *not* enough.
-	  //
-	  // So, the steps are:
-	  // 1. Figure out what the state of things will be after we do
-	  // a read from the buffer.
-	  //
-	  // 2. If that resulting state will trigger a _read, then call _read.
-	  // Note that this may be asynchronous, or synchronous.  Yes, it is
-	  // deeply ugly to write APIs this way, but that still doesn't mean
-	  // that the Readable class should behave improperly, as streams are
-	  // designed to be sync/async agnostic.
-	  // Take note if the _read call is sync or async (ie, if the read call
-	  // has returned yet), so that we know whether or not it's safe to emit
-	  // 'readable' etc.
-	  //
-	  // 3. Actually pull the requested chunks out of the buffer and return.
-	  // if we need a readable event, then we need to do some reading.
-
-
-	  var doRead = state.needReadable;
-	  debug('need readable', doRead); // if we currently have less than the highWaterMark, then also read some
-
-	  if (state.length === 0 || state.length - n < state.highWaterMark) {
-	    doRead = true;
-	    debug('length less than watermark', doRead);
-	  } // however, if we've ended, then there's no point, and if we're already
-	  // reading, then it's unnecessary.
-
-
-	  if (state.ended || state.reading) {
-	    doRead = false;
-	    debug('reading or ended', doRead);
-	  } else if (doRead) {
-	    debug('do read');
-	    state.reading = true;
-	    state.sync = true; // if the length is currently zero, then we *need* a readable event.
-
-	    if (state.length === 0) state.needReadable = true; // call internal read method
-
-	    this._read(state.highWaterMark);
-
-	    state.sync = false; // If _read pushed data synchronously, then `reading` will be false,
-	    // and we need to re-evaluate how much data we can return to the user.
-
-	    if (!state.reading) n = howMuchToRead(nOrig, state);
-	  }
-
-	  var ret;
-	  if (n > 0) ret = fromList(n, state);else ret = null;
-
-	  if (ret === null) {
-	    state.needReadable = state.length <= state.highWaterMark;
-	    n = 0;
-	  } else {
-	    state.length -= n;
-	    state.awaitDrain = 0;
-	  }
-
-	  if (state.length === 0) {
-	    // If we have nothing in the buffer, then we want to know
-	    // as soon as we *do* get something into the buffer.
-	    if (!state.ended) state.needReadable = true; // If we tried to read() past the EOF, then emit end on the next tick.
-
-	    if (nOrig !== n && state.ended) endReadable(this);
-	  }
-
-	  if (ret !== null) this.emit('data', ret);
-	  return ret;
-	};
-
-	function onEofChunk(stream, state) {
-	  debug('onEofChunk');
-	  if (state.ended) return;
-
-	  if (state.decoder) {
-	    var chunk = state.decoder.end();
-
-	    if (chunk && chunk.length) {
-	      state.buffer.push(chunk);
-	      state.length += state.objectMode ? 1 : chunk.length;
-	    }
-	  }
-
-	  state.ended = true;
-
-	  if (state.sync) {
-	    // if we are sync, wait until next tick to emit the data.
-	    // Otherwise we risk emitting data in the flow()
-	    // the readable code triggers during a read() call
-	    emitReadable(stream);
-	  } else {
-	    // emit 'readable' now to make sure it gets picked up.
-	    state.needReadable = false;
-
-	    if (!state.emittedReadable) {
-	      state.emittedReadable = true;
-	      emitReadable_(stream);
-	    }
-	  }
-	} // Don't emit readable right away in sync mode, because this can trigger
-	// another read() call => stack overflow.  This way, it might trigger
-	// a nextTick recursion warning, but that's not so bad.
-
-
-	function emitReadable(stream) {
-	  var state = stream._readableState;
-	  debug('emitReadable', state.needReadable, state.emittedReadable);
-	  state.needReadable = false;
-
-	  if (!state.emittedReadable) {
-	    debug('emitReadable', state.flowing);
-	    state.emittedReadable = true;
-	    process.nextTick(emitReadable_, stream);
-	  }
-	}
-
-	function emitReadable_(stream) {
-	  var state = stream._readableState;
-	  debug('emitReadable_', state.destroyed, state.length, state.ended);
-
-	  if (!state.destroyed && (state.length || state.ended)) {
-	    stream.emit('readable');
-	    state.emittedReadable = false;
-	  } // The stream needs another readable event if
-	  // 1. It is not flowing, as the flow mechanism will take
-	  //    care of it.
-	  // 2. It is not ended.
-	  // 3. It is below the highWaterMark, so we can schedule
-	  //    another readable later.
-
-
-	  state.needReadable = !state.flowing && !state.ended && state.length <= state.highWaterMark;
-	  flow(stream);
-	} // at this point, the user has presumably seen the 'readable' event,
-	// and called read() to consume some data.  that may have triggered
-	// in turn another _read(n) call, in which case reading = true if
-	// it's in progress.
-	// However, if we're not ended, or reading, and the length < hwm,
-	// then go ahead and try to read some more preemptively.
-
-
-	function maybeReadMore(stream, state) {
-	  if (!state.readingMore) {
-	    state.readingMore = true;
-	    process.nextTick(maybeReadMore_, stream, state);
-	  }
-	}
-
-	function maybeReadMore_(stream, state) {
-	  // Attempt to read more data if we should.
-	  //
-	  // The conditions for reading more data are (one of):
-	  // - Not enough data buffered (state.length < state.highWaterMark). The loop
-	  //   is responsible for filling the buffer with enough data if such data
-	  //   is available. If highWaterMark is 0 and we are not in the flowing mode
-	  //   we should _not_ attempt to buffer any extra data. We'll get more data
-	  //   when the stream consumer calls read() instead.
-	  // - No data in the buffer, and the stream is in flowing mode. In this mode
-	  //   the loop below is responsible for ensuring read() is called. Failing to
-	  //   call read here would abort the flow and there's no other mechanism for
-	  //   continuing the flow if the stream consumer has just subscribed to the
-	  //   'data' event.
-	  //
-	  // In addition to the above conditions to keep reading data, the following
-	  // conditions prevent the data from being read:
-	  // - The stream has ended (state.ended).
-	  // - There is already a pending 'read' operation (state.reading). This is a
-	  //   case where the the stream has called the implementation defined _read()
-	  //   method, but they are processing the call asynchronously and have _not_
-	  //   called push() with new data. In this case we skip performing more
-	  //   read()s. The execution ends in this method again after the _read() ends
-	  //   up calling push() with more data.
-	  while (!state.reading && !state.ended && (state.length < state.highWaterMark || state.flowing && state.length === 0)) {
-	    var len = state.length;
-	    debug('maybeReadMore read 0');
-	    stream.read(0);
-	    if (len === state.length) // didn't get any data, stop spinning.
-	      break;
-	  }
-
-	  state.readingMore = false;
-	} // abstract method.  to be overridden in specific implementation classes.
-	// call cb(er, data) where data is <= n in length.
-	// for virtual (non-string, non-buffer) streams, "length" is somewhat
-	// arbitrary, and perhaps not very meaningful.
-
-
-	Readable.prototype._read = function (n) {
-	  errorOrDestroy(this, new ERR_METHOD_NOT_IMPLEMENTED('_read()'));
-	};
-
-	Readable.prototype.pipe = function (dest, pipeOpts) {
-	  var src = this;
-	  var state = this._readableState;
-
-	  switch (state.pipesCount) {
-	    case 0:
-	      state.pipes = dest;
-	      break;
-
-	    case 1:
-	      state.pipes = [state.pipes, dest];
-	      break;
-
-	    default:
-	      state.pipes.push(dest);
-	      break;
-	  }
-
-	  state.pipesCount += 1;
-	  debug('pipe count=%d opts=%j', state.pipesCount, pipeOpts);
-	  var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== process.stdout && dest !== process.stderr;
-	  var endFn = doEnd ? onend : unpipe;
-	  if (state.endEmitted) process.nextTick(endFn);else src.once('end', endFn);
-	  dest.on('unpipe', onunpipe);
-
-	  function onunpipe(readable, unpipeInfo) {
-	    debug('onunpipe');
-
-	    if (readable === src) {
-	      if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
-	        unpipeInfo.hasUnpiped = true;
-	        cleanup();
-	      }
-	    }
-	  }
-
-	  function onend() {
-	    debug('onend');
-	    dest.end();
-	  } // when the dest drains, it reduces the awaitDrain counter
-	  // on the source.  This would be more elegant with a .once()
-	  // handler in flow(), but adding and removing repeatedly is
-	  // too slow.
-
-
-	  var ondrain = pipeOnDrain(src);
-	  dest.on('drain', ondrain);
-	  var cleanedUp = false;
-
-	  function cleanup() {
-	    debug('cleanup'); // cleanup event handlers once the pipe is broken
-
-	    dest.removeListener('close', onclose);
-	    dest.removeListener('finish', onfinish);
-	    dest.removeListener('drain', ondrain);
-	    dest.removeListener('error', onerror);
-	    dest.removeListener('unpipe', onunpipe);
-	    src.removeListener('end', onend);
-	    src.removeListener('end', unpipe);
-	    src.removeListener('data', ondata);
-	    cleanedUp = true; // if the reader is waiting for a drain event from this
-	    // specific writer, then it would cause it to never start
-	    // flowing again.
-	    // So, if this is awaiting a drain, then we just call it now.
-	    // If we don't know, then assume that we are waiting for one.
-
-	    if (state.awaitDrain && (!dest._writableState || dest._writableState.needDrain)) ondrain();
-	  }
-
-	  src.on('data', ondata);
-
-	  function ondata(chunk) {
-	    debug('ondata');
-	    var ret = dest.write(chunk);
-	    debug('dest.write', ret);
-
-	    if (ret === false) {
-	      // If the user unpiped during `dest.write()`, it is possible
-	      // to get stuck in a permanently paused state if that write
-	      // also returned false.
-	      // => Check whether `dest` is still a piping destination.
-	      if ((state.pipesCount === 1 && state.pipes === dest || state.pipesCount > 1 && indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
-	        debug('false write response, pause', state.awaitDrain);
-	        state.awaitDrain++;
-	      }
-
-	      src.pause();
-	    }
-	  } // if the dest has an error, then stop piping into it.
-	  // however, don't suppress the throwing behavior for this.
-
-
-	  function onerror(er) {
-	    debug('onerror', er);
-	    unpipe();
-	    dest.removeListener('error', onerror);
-	    if (EElistenerCount(dest, 'error') === 0) errorOrDestroy(dest, er);
-	  } // Make sure our error handler is attached before userland ones.
-
-
-	  prependListener(dest, 'error', onerror); // Both close and finish should trigger unpipe, but only once.
-
-	  function onclose() {
-	    dest.removeListener('finish', onfinish);
-	    unpipe();
-	  }
-
-	  dest.once('close', onclose);
-
-	  function onfinish() {
-	    debug('onfinish');
-	    dest.removeListener('close', onclose);
-	    unpipe();
-	  }
-
-	  dest.once('finish', onfinish);
-
-	  function unpipe() {
-	    debug('unpipe');
-	    src.unpipe(dest);
-	  } // tell the dest that it's being piped to
-
-
-	  dest.emit('pipe', src); // start the flow if it hasn't been started already.
-
-	  if (!state.flowing) {
-	    debug('pipe resume');
-	    src.resume();
-	  }
-
-	  return dest;
-	};
-
-	function pipeOnDrain(src) {
-	  return function pipeOnDrainFunctionResult() {
-	    var state = src._readableState;
-	    debug('pipeOnDrain', state.awaitDrain);
-	    if (state.awaitDrain) state.awaitDrain--;
-
-	    if (state.awaitDrain === 0 && EElistenerCount(src, 'data')) {
-	      state.flowing = true;
-	      flow(src);
-	    }
-	  };
-	}
-
-	Readable.prototype.unpipe = function (dest) {
-	  var state = this._readableState;
-	  var unpipeInfo = {
-	    hasUnpiped: false
-	  }; // if we're not piping anywhere, then do nothing.
-
-	  if (state.pipesCount === 0) return this; // just one destination.  most common case.
-
-	  if (state.pipesCount === 1) {
-	    // passed in one, but it's not the right one.
-	    if (dest && dest !== state.pipes) return this;
-	    if (!dest) dest = state.pipes; // got a match.
-
-	    state.pipes = null;
-	    state.pipesCount = 0;
-	    state.flowing = false;
-	    if (dest) dest.emit('unpipe', this, unpipeInfo);
-	    return this;
-	  } // slow case. multiple pipe destinations.
-
-
-	  if (!dest) {
-	    // remove all.
-	    var dests = state.pipes;
-	    var len = state.pipesCount;
-	    state.pipes = null;
-	    state.pipesCount = 0;
-	    state.flowing = false;
-
-	    for (var i = 0; i < len; i++) {
-	      dests[i].emit('unpipe', this, {
-	        hasUnpiped: false
-	      });
-	    }
-
-	    return this;
-	  } // try to find the right one.
-
-
-	  var index = indexOf(state.pipes, dest);
-	  if (index === -1) return this;
-	  state.pipes.splice(index, 1);
-	  state.pipesCount -= 1;
-	  if (state.pipesCount === 1) state.pipes = state.pipes[0];
-	  dest.emit('unpipe', this, unpipeInfo);
-	  return this;
-	}; // set up data events if they are asked for
-	// Ensure readable listeners eventually get something
-
-
-	Readable.prototype.on = function (ev, fn) {
-	  var res = Stream.prototype.on.call(this, ev, fn);
-	  var state = this._readableState;
-
-	  if (ev === 'data') {
-	    // update readableListening so that resume() may be a no-op
-	    // a few lines down. This is needed to support once('readable').
-	    state.readableListening = this.listenerCount('readable') > 0; // Try start flowing on next tick if stream isn't explicitly paused
-
-	    if (state.flowing !== false) this.resume();
-	  } else if (ev === 'readable') {
-	    if (!state.endEmitted && !state.readableListening) {
-	      state.readableListening = state.needReadable = true;
-	      state.flowing = false;
-	      state.emittedReadable = false;
-	      debug('on readable', state.length, state.reading);
-
-	      if (state.length) {
-	        emitReadable(this);
-	      } else if (!state.reading) {
-	        process.nextTick(nReadingNextTick, this);
-	      }
-	    }
-	  }
-
-	  return res;
-	};
-
-	Readable.prototype.addListener = Readable.prototype.on;
-
-	Readable.prototype.removeListener = function (ev, fn) {
-	  var res = Stream.prototype.removeListener.call(this, ev, fn);
-
-	  if (ev === 'readable') {
-	    // We need to check if there is someone still listening to
-	    // readable and reset the state. However this needs to happen
-	    // after readable has been emitted but before I/O (nextTick) to
-	    // support once('readable', fn) cycles. This means that calling
-	    // resume within the same tick will have no
-	    // effect.
-	    process.nextTick(updateReadableListening, this);
-	  }
-
-	  return res;
-	};
-
-	Readable.prototype.removeAllListeners = function (ev) {
-	  var res = Stream.prototype.removeAllListeners.apply(this, arguments);
-
-	  if (ev === 'readable' || ev === undefined) {
-	    // We need to check if there is someone still listening to
-	    // readable and reset the state. However this needs to happen
-	    // after readable has been emitted but before I/O (nextTick) to
-	    // support once('readable', fn) cycles. This means that calling
-	    // resume within the same tick will have no
-	    // effect.
-	    process.nextTick(updateReadableListening, this);
-	  }
-
-	  return res;
-	};
-
-	function updateReadableListening(self) {
-	  var state = self._readableState;
-	  state.readableListening = self.listenerCount('readable') > 0;
-
-	  if (state.resumeScheduled && !state.paused) {
-	    // flowing needs to be set to true now, otherwise
-	    // the upcoming resume will not flow.
-	    state.flowing = true; // crude way to check if we should resume
-	  } else if (self.listenerCount('data') > 0) {
-	    self.resume();
-	  }
-	}
-
-	function nReadingNextTick(self) {
-	  debug('readable nexttick read 0');
-	  self.read(0);
-	} // pause() and resume() are remnants of the legacy readable stream API
-	// If the user uses them, then switch into old mode.
-
-
-	Readable.prototype.resume = function () {
-	  var state = this._readableState;
-
-	  if (!state.flowing) {
-	    debug('resume'); // we flow only if there is no one listening
-	    // for readable, but we still have to call
-	    // resume()
-
-	    state.flowing = !state.readableListening;
-	    resume(this, state);
-	  }
-
-	  state.paused = false;
-	  return this;
-	};
-
-	function resume(stream, state) {
-	  if (!state.resumeScheduled) {
-	    state.resumeScheduled = true;
-	    process.nextTick(resume_, stream, state);
-	  }
-	}
-
-	function resume_(stream, state) {
-	  debug('resume', state.reading);
-
-	  if (!state.reading) {
-	    stream.read(0);
-	  }
-
-	  state.resumeScheduled = false;
-	  stream.emit('resume');
-	  flow(stream);
-	  if (state.flowing && !state.reading) stream.read(0);
-	}
-
-	Readable.prototype.pause = function () {
-	  debug('call pause flowing=%j', this._readableState.flowing);
-
-	  if (this._readableState.flowing !== false) {
-	    debug('pause');
-	    this._readableState.flowing = false;
-	    this.emit('pause');
-	  }
-
-	  this._readableState.paused = true;
-	  return this;
-	};
-
-	function flow(stream) {
-	  var state = stream._readableState;
-	  debug('flow', state.flowing);
-
-	  while (state.flowing && stream.read() !== null) {
-	  }
-	} // wrap an old-style stream as the async data source.
-	// This is *not* part of the readable stream interface.
-	// It is an ugly unfortunate mess of history.
-
-
-	Readable.prototype.wrap = function (stream) {
-	  var _this = this;
-
-	  var state = this._readableState;
-	  var paused = false;
-	  stream.on('end', function () {
-	    debug('wrapped end');
-
-	    if (state.decoder && !state.ended) {
-	      var chunk = state.decoder.end();
-	      if (chunk && chunk.length) _this.push(chunk);
-	    }
-
-	    _this.push(null);
-	  });
-	  stream.on('data', function (chunk) {
-	    debug('wrapped data');
-	    if (state.decoder) chunk = state.decoder.write(chunk); // don't skip over falsy values in objectMode
-
-	    if (state.objectMode && (chunk === null || chunk === undefined)) return;else if (!state.objectMode && (!chunk || !chunk.length)) return;
-
-	    var ret = _this.push(chunk);
-
-	    if (!ret) {
-	      paused = true;
-	      stream.pause();
-	    }
-	  }); // proxy all the other methods.
-	  // important when wrapping filters and duplexes.
-
-	  for (var i in stream) {
-	    if (this[i] === undefined && typeof stream[i] === 'function') {
-	      this[i] = function methodWrap(method) {
-	        return function methodWrapReturnFunction() {
-	          return stream[method].apply(stream, arguments);
-	        };
-	      }(i);
-	    }
-	  } // proxy certain important events.
-
-
-	  for (var n = 0; n < kProxyEvents.length; n++) {
-	    stream.on(kProxyEvents[n], this.emit.bind(this, kProxyEvents[n]));
-	  } // when we try to consume some more bytes, simply unpause the
-	  // underlying stream.
-
-
-	  this._read = function (n) {
-	    debug('wrapped _read', n);
-
-	    if (paused) {
-	      paused = false;
-	      stream.resume();
-	    }
-	  };
-
-	  return this;
-	};
-
-	if (typeof Symbol === 'function') {
-	  Readable.prototype[Symbol.asyncIterator] = function () {
-	    if (createReadableStreamAsyncIterator === undefined) {
-	      createReadableStreamAsyncIterator = requireAsync_iterator();
-	    }
-
-	    return createReadableStreamAsyncIterator(this);
-	  };
-	}
-
-	Object.defineProperty(Readable.prototype, 'readableHighWaterMark', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._readableState.highWaterMark;
-	  }
-	});
-	Object.defineProperty(Readable.prototype, 'readableBuffer', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._readableState && this._readableState.buffer;
-	  }
-	});
-	Object.defineProperty(Readable.prototype, 'readableFlowing', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._readableState.flowing;
-	  },
-	  set: function set(state) {
-	    if (this._readableState) {
-	      this._readableState.flowing = state;
-	    }
-	  }
-	}); // exposed for testing purposes only.
-
-	Readable._fromList = fromList;
-	Object.defineProperty(Readable.prototype, 'readableLength', {
-	  // making it explicit this property is not enumerable
-	  // because otherwise some prototype manipulation in
-	  // userland will fail
-	  enumerable: false,
-	  get: function get() {
-	    return this._readableState.length;
-	  }
-	}); // Pluck off n bytes from an array of buffers.
-	// Length is the combined lengths of all the buffers in the list.
-	// This function is designed to be inlinable, so please take care when making
-	// changes to the function body.
-
-	function fromList(n, state) {
-	  // nothing buffered
-	  if (state.length === 0) return null;
-	  var ret;
-	  if (state.objectMode) ret = state.buffer.shift();else if (!n || n >= state.length) {
-	    // read it all, truncate the list
-	    if (state.decoder) ret = state.buffer.join('');else if (state.buffer.length === 1) ret = state.buffer.first();else ret = state.buffer.concat(state.length);
-	    state.buffer.clear();
-	  } else {
-	    // read part of list
-	    ret = state.buffer.consume(n, state.decoder);
-	  }
-	  return ret;
-	}
-
-	function endReadable(stream) {
-	  var state = stream._readableState;
-	  debug('endReadable', state.endEmitted);
-
-	  if (!state.endEmitted) {
-	    state.ended = true;
-	    process.nextTick(endReadableNT, state, stream);
-	  }
-	}
-
-	function endReadableNT(state, stream) {
-	  debug('endReadableNT', state.endEmitted, state.length); // Check that we didn't get one last unshift.
-
-	  if (!state.endEmitted && state.length === 0) {
-	    state.endEmitted = true;
-	    stream.readable = false;
-	    stream.emit('end');
-
-	    if (state.autoDestroy) {
-	      // In case of duplex streams we need a way to detect
-	      // if the writable side is ready for autoDestroy as well
-	      var wState = stream._writableState;
-
-	      if (!wState || wState.autoDestroy && wState.finished) {
-	        stream.destroy();
-	      }
-	    }
-	  }
-	}
-
-	if (typeof Symbol === 'function') {
-	  Readable.from = function (iterable, opts) {
-	    if (from === undefined) {
-	      from = requireFrom();
-	    }
-
-	    return from(Readable, iterable, opts);
-	  };
-	}
-
-	function indexOf(xs, x) {
-	  for (var i = 0, l = xs.length; i < l; i++) {
-	    if (xs[i] === x) return i;
-	  }
-
-	  return -1;
-	}
-	return _stream_readable;
-}
-
-var _stream_transform;
-var hasRequired_stream_transform;
-
-function require_stream_transform () {
-	if (hasRequired_stream_transform) return _stream_transform;
-	hasRequired_stream_transform = 1;
-
-	_stream_transform = Transform;
-
-	var _require$codes = requireErrors().codes,
-	    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 = require_stream_duplex();
-
-	requireInherits()(Transform, Duplex);
-
-	function afterTransform(er, data) {
-	  var ts = this._transformState;
-	  ts.transforming = false;
-	  var cb = ts.writecb;
-
-	  if (cb === null) {
-	    return this.emit('error', new ERR_MULTIPLE_CALLBACK());
-	  }
-
-	  ts.writechunk = null;
-	  ts.writecb = null;
-	  if (data != null) // single equals check for both `null` and `undefined`
-	    this.push(data);
-	  cb(er);
-	  var rs = this._readableState;
-	  rs.reading = false;
-
-	  if (rs.needReadable || rs.length < rs.highWaterMark) {
-	    this._read(rs.highWaterMark);
-	  }
-	}
-
-	function Transform(options) {
-	  if (!(this instanceof Transform)) return new Transform(options);
-	  Duplex.call(this, options);
-	  this._transformState = {
-	    afterTransform: afterTransform.bind(this),
-	    needTransform: false,
-	    transforming: false,
-	    writecb: null,
-	    writechunk: null,
-	    writeencoding: null
-	  }; // start out asking for a readable event once data is transformed.
-
-	  this._readableState.needReadable = true; // we have implemented the _read method, and done the other things
-	  // that Readable wants before the first _read call, so unset the
-	  // sync guard flag.
-
-	  this._readableState.sync = false;
-
-	  if (options) {
-	    if (typeof options.transform === 'function') this._transform = options.transform;
-	    if (typeof options.flush === 'function') this._flush = options.flush;
-	  } // When the writable side finishes, then flush out anything remaining.
-
-
-	  this.on('prefinish', prefinish);
-	}
-
-	function prefinish() {
-	  var _this = this;
-
-	  if (typeof this._flush === 'function' && !this._readableState.destroyed) {
-	    this._flush(function (er, data) {
-	      done(_this, er, data);
-	    });
-	  } else {
-	    done(this, null, null);
-	  }
-	}
-
-	Transform.prototype.push = function (chunk, encoding) {
-	  this._transformState.needTransform = false;
-	  return Duplex.prototype.push.call(this, chunk, encoding);
-	}; // This is the part where you do stuff!
-	// override this function in implementation classes.
-	// 'chunk' is an input chunk.
-	//
-	// Call `push(newChunk)` to pass along transformed output
-	// to the readable side.  You may call 'push' zero or more times.
-	//
-	// Call `cb(err)` when you are done with this chunk.  If you pass
-	// an error, then that'll put the hurt on the whole operation.  If you
-	// never call cb(), then you'll never get another chunk.
-
-
-	Transform.prototype._transform = function (chunk, encoding, cb) {
-	  cb(new ERR_METHOD_NOT_IMPLEMENTED('_transform()'));
-	};
-
-	Transform.prototype._write = function (chunk, encoding, cb) {
-	  var ts = this._transformState;
-	  ts.writecb = cb;
-	  ts.writechunk = chunk;
-	  ts.writeencoding = encoding;
-
-	  if (!ts.transforming) {
-	    var rs = this._readableState;
-	    if (ts.needTransform || rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
-	  }
-	}; // Doesn't matter what the args are here.
-	// _transform does all the work.
-	// That we got here means that the readable side wants more data.
-
-
-	Transform.prototype._read = function (n) {
-	  var ts = this._transformState;
-
-	  if (ts.writechunk !== null && !ts.transforming) {
-	    ts.transforming = true;
-
-	    this._transform(ts.writechunk, ts.writeencoding, ts.afterTransform);
-	  } else {
-	    // mark that we need a transform, so that any data that comes in
-	    // will get processed, now that we've asked for it.
-	    ts.needTransform = true;
-	  }
-	};
-
-	Transform.prototype._destroy = function (err, cb) {
-	  Duplex.prototype._destroy.call(this, err, function (err2) {
-	    cb(err2);
-	  });
-	};
-
-	function done(stream, er, data) {
-	  if (er) return stream.emit('error', er);
-	  if (data != null) // single equals check for both `null` and `undefined`
-	    stream.push(data); // TODO(BridgeAR): Write a test for these two error cases
-	  // if there's nothing in the write buffer, then that means
-	  // that nothing more will ever be provided
-
-	  if (stream._writableState.length) throw new ERR_TRANSFORM_WITH_LENGTH_0();
-	  if (stream._transformState.transforming) throw new ERR_TRANSFORM_ALREADY_TRANSFORMING();
-	  return stream.push(null);
-	}
-	return _stream_transform;
-}
-
-var _stream_passthrough;
-var hasRequired_stream_passthrough;
-
-function require_stream_passthrough () {
-	if (hasRequired_stream_passthrough) return _stream_passthrough;
-	hasRequired_stream_passthrough = 1;
-
-	_stream_passthrough = PassThrough;
-
-	var Transform = require_stream_transform();
-
-	requireInherits()(PassThrough, Transform);
-
-	function PassThrough(options) {
-	  if (!(this instanceof PassThrough)) return new PassThrough(options);
-	  Transform.call(this, options);
-	}
-
-	PassThrough.prototype._transform = function (chunk, encoding, cb) {
-	  cb(null, chunk);
-	};
-	return _stream_passthrough;
-}
-
-var pipeline_1;
-var hasRequiredPipeline;
-
-function requirePipeline () {
-	if (hasRequiredPipeline) return pipeline_1;
-	hasRequiredPipeline = 1;
-
-	var eos;
-
-	function once(callback) {
-	  var called = false;
-	  return function () {
-	    if (called) return;
-	    called = true;
-	    callback.apply(void 0, arguments);
-	  };
-	}
-
-	var _require$codes = requireErrors().codes,
-	    ERR_MISSING_ARGS = _require$codes.ERR_MISSING_ARGS,
-	    ERR_STREAM_DESTROYED = _require$codes.ERR_STREAM_DESTROYED;
-
-	function noop(err) {
-	  // Rethrow the error if it exists to avoid swallowing it
-	  if (err) throw err;
-	}
-
-	function isRequest(stream) {
-	  return stream.setHeader && typeof stream.abort === 'function';
-	}
-
-	function destroyer(stream, reading, writing, callback) {
-	  callback = once(callback);
-	  var closed = false;
-	  stream.on('close', function () {
-	    closed = true;
-	  });
-	  if (eos === undefined) eos = requireEndOfStream();
-	  eos(stream, {
-	    readable: reading,
-	    writable: writing
-	  }, function (err) {
-	    if (err) return callback(err);
-	    closed = true;
-	    callback();
-	  });
-	  var destroyed = false;
-	  return function (err) {
-	    if (closed) return;
-	    if (destroyed) return;
-	    destroyed = true; // request.destroy just do .end - .abort is what we want
-
-	    if (isRequest(stream)) return stream.abort();
-	    if (typeof stream.destroy === 'function') return stream.destroy();
-	    callback(err || new ERR_STREAM_DESTROYED('pipe'));
-	  };
-	}
-
-	function call(fn) {
-	  fn();
-	}
-
-	function pipe(from, to) {
-	  return from.pipe(to);
-	}
-
-	function popCallback(streams) {
-	  if (!streams.length) return noop;
-	  if (typeof streams[streams.length - 1] !== 'function') return noop;
-	  return streams.pop();
-	}
-
-	function pipeline() {
-	  for (var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++) {
-	    streams[_key] = arguments[_key];
-	  }
-
-	  var callback = popCallback(streams);
-	  if (Array.isArray(streams[0])) streams = streams[0];
-
-	  if (streams.length < 2) {
-	    throw new ERR_MISSING_ARGS('streams');
-	  }
-
-	  var error;
-	  var destroys = streams.map(function (stream, i) {
-	    var reading = i < streams.length - 1;
-	    var writing = i > 0;
-	    return destroyer(stream, reading, writing, function (err) {
-	      if (!error) error = err;
-	      if (err) destroys.forEach(call);
-	      if (reading) return;
-	      destroys.forEach(call);
-	      callback(error);
-	    });
-	  });
-	  return streams.reduce(pipe);
-	}
-
-	pipeline_1 = pipeline;
-	return pipeline_1;
-}
-
-var hasRequiredReadable;
-
-function requireReadable () {
-	if (hasRequiredReadable) return readable.exports;
-	hasRequiredReadable = 1;
-	(function (module, exports) {
-		var Stream = require$$0$1;
-		if (process.env.READABLE_STREAM === 'disable' && Stream) {
-		  module.exports = Stream.Readable;
-		  Object.assign(module.exports, Stream);
-		  module.exports.Stream = Stream;
-		} else {
-		  exports = module.exports = require_stream_readable();
-		  exports.Stream = Stream || exports;
-		  exports.Readable = exports;
-		  exports.Writable = require_stream_writable();
-		  exports.Duplex = require_stream_duplex();
-		  exports.Transform = require_stream_transform();
-		  exports.PassThrough = require_stream_passthrough();
-		  exports.finished = requireEndOfStream();
-		  exports.pipeline = requirePipeline();
-		}
-} (readable, readable.exports));
-	return readable.exports;
-}
-
-var keccak$1;
-var hasRequiredKeccak$1;
-
-function requireKeccak$1 () {
-	if (hasRequiredKeccak$1) return keccak$1;
-	hasRequiredKeccak$1 = 1;
-	const { Transform } = requireReadable();
-
-	keccak$1 = (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);
-	    this._finalized = false;
-	  }
-
-	  _transform (chunk, encoding, callback) {
-	    let error = null;
-	    try {
-	      this.update(chunk, encoding);
-	    } catch (err) {
-	      error = err;
-	    }
-
-	    callback(error);
-	  }
-
-	  _flush (callback) {
-	    let error = null;
-	    try {
-	      this.push(this.digest());
-	    } catch (err) {
-	      error = err;
-	    }
-
-	    callback(error);
-	  }
-
-	  update (data, encoding) {
-	    if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')
-	    if (this._finalized) throw new Error('Digest already called')
-	    if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding);
-
-	    this._state.absorb(data);
-
-	    return this
-	  }
-
-	  digest (encoding) {
-	    if (this._finalized) throw new Error('Digest already called')
-	    this._finalized = true;
-
-	    if (this._delimitedSuffix) this._state.absorbLastFewBits(this._delimitedSuffix);
-	    let digest = this._state.squeeze(this._hashBitLength / 8);
-	    if (encoding !== undefined) digest = digest.toString(encoding);
-
-	    this._resetState();
-
-	    return digest
-	  }
-
-	  // remove result from memory
-	  _resetState () {
-	    this._state.initialize(this._rate, this._capacity);
-	    return this
-	  }
-
-	  // because sometimes we need hash right now and little later
-	  _clone () {
-	    const clone = new Keccak(this._rate, this._capacity, this._delimitedSuffix, this._hashBitLength, this._options);
-	    this._state.copy(clone._state);
-	    clone._finalized = this._finalized;
-
-	    return clone
-	  }
-	};
-	return keccak$1;
-}
-
-var shake;
-var hasRequiredShake;
-
-function requireShake () {
-	if (hasRequiredShake) return shake;
-	hasRequiredShake = 1;
-	const { Transform } = requireReadable();
-
-	shake = (KeccakState) => class Shake extends Transform {
-	  constructor (rate, capacity, delimitedSuffix, options) {
-	    super(options);
-
-	    this._rate = rate;
-	    this._capacity = capacity;
-	    this._delimitedSuffix = delimitedSuffix;
-	    this._options = options;
-
-	    this._state = new KeccakState();
-	    this._state.initialize(rate, capacity);
-	    this._finalized = false;
-	  }
-
-	  _transform (chunk, encoding, callback) {
-	    let error = null;
-	    try {
-	      this.update(chunk, encoding);
-	    } catch (err) {
-	      error = err;
-	    }
-
-	    callback(error);
-	  }
-
-	  _flush () {}
-
-	  _read (size) {
-	    this.push(this.squeeze(size));
-	  }
-
-	  update (data, encoding) {
-	    if (!Buffer.isBuffer(data) && typeof data !== 'string') throw new TypeError('Data must be a string or a buffer')
-	    if (this._finalized) throw new Error('Squeeze already called')
-	    if (!Buffer.isBuffer(data)) data = Buffer.from(data, encoding);
-
-	    this._state.absorb(data);
-
-	    return this
-	  }
-
-	  squeeze (dataByteLength, encoding) {
-	    if (!this._finalized) {
-	      this._finalized = true;
-	      this._state.absorbLastFewBits(this._delimitedSuffix);
-	    }
-
-	    let data = this._state.squeeze(dataByteLength);
-	    if (encoding !== undefined) data = data.toString(encoding);
-
-	    return data
-	  }
-
-	  _resetState () {
-	    this._state.initialize(this._rate, this._capacity);
-	    return this
-	  }
-
-	  _clone () {
-	    const clone = new Shake(this._rate, this._capacity, this._delimitedSuffix, this._options);
-	    this._state.copy(clone._state);
-	    clone._finalized = this._finalized;
-
-	    return clone
-	  }
-	};
-	return shake;
-}
-
-var api;
-var hasRequiredApi;
-
-function requireApi () {
-	if (hasRequiredApi) return api;
-	hasRequiredApi = 1;
-	const createKeccak = requireKeccak$1();
-	const createShake = requireShake();
-
-	api = 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)
-	    }
-	  }
-	};
-	return api;
-}
-
-function commonjsRequire(path) {
-	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
-}
-
-var nodeGypBuild;
-var hasRequiredNodeGypBuild;
-
-function requireNodeGypBuild () {
-	if (hasRequiredNodeGypBuild) return nodeGypBuild;
-	hasRequiredNodeGypBuild = 1;
-	var fs = require$$0$3;
-	var path = require$$1$2;
-	var os = require$$2$2;
-
-	// Workaround to fix webpack's build warnings: 'the request of a dependency is an expression'
-	var runtimeRequire = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : commonjsRequire; // eslint-disable-line
-
-	var vars = (process.config && process.config.variables) || {};
-	var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
-	var abi = process.versions.modules; // TODO: support old node where this is undef
-	var runtime = isElectron() ? 'electron' : (isNwjs() ? 'node-webkit' : 'node');
-
-	var arch = process.env.npm_config_arch || os.arch();
-	var platform = process.env.npm_config_platform || os.platform();
-	var libc = process.env.LIBC || (isAlpine(platform) ? 'musl' : 'glibc');
-	var armv = process.env.ARM_VERSION || (arch === 'arm64' ? '8' : vars.arm_version) || '';
-	var uv = (process.versions.uv || '').split('.')[0];
-
-	nodeGypBuild = load;
-
-	function load (dir) {
-	  return runtimeRequire(load.path(dir))
-	}
-
-	load.path = function (dir) {
-	  dir = path.resolve(dir || '.');
-
-	  try {
-	    var name = runtimeRequire(path.join(dir, 'package.json')).name.toUpperCase().replace(/-/g, '_');
-	    if (process.env[name + '_PREBUILD']) dir = process.env[name + '_PREBUILD'];
-	  } catch (err) {}
-
-	  if (!prebuildsOnly) {
-	    var release = getFirst(path.join(dir, 'build/Release'), matchBuild);
-	    if (release) return release
-
-	    var debug = getFirst(path.join(dir, 'build/Debug'), matchBuild);
-	    if (debug) return debug
-	  }
-
-	  var prebuild = resolve(dir);
-	  if (prebuild) return prebuild
-
-	  var nearby = resolve(path.dirname(process.execPath));
-	  if (nearby) return nearby
-
-	  var target = [
-	    'platform=' + platform,
-	    'arch=' + arch,
-	    'runtime=' + runtime,
-	    'abi=' + abi,
-	    'uv=' + uv,
-	    armv ? 'armv=' + armv : '',
-	    'libc=' + libc,
-	    'node=' + process.versions.node,
-	    process.versions.electron ? 'electron=' + process.versions.electron : '',
-	    typeof __webpack_require__ === 'function' ? 'webpack=true' : '' // eslint-disable-line
-	  ].filter(Boolean).join(' ');
-
-	  throw new Error('No native build was found for ' + target + '\n    loaded from: ' + dir + '\n')
-
-	  function resolve (dir) {
-	    // Find matching "prebuilds/<platform>-<arch>" directory
-	    var tuples = readdirSync(path.join(dir, 'prebuilds')).map(parseTuple);
-	    var tuple = tuples.filter(matchTuple(platform, arch)).sort(compareTuples)[0];
-	    if (!tuple) return
-
-	    // Find most specific flavor first
-	    var prebuilds = path.join(dir, 'prebuilds', tuple.name);
-	    var parsed = readdirSync(prebuilds).map(parseTags);
-	    var candidates = parsed.filter(matchTags(runtime, abi));
-	    var winner = candidates.sort(compareTags(runtime))[0];
-	    if (winner) return path.join(prebuilds, winner.file)
-	  }
-	};
-
-	function readdirSync (dir) {
-	  try {
-	    return fs.readdirSync(dir)
-	  } catch (err) {
-	    return []
-	  }
-	}
-
-	function getFirst (dir, filter) {
-	  var files = readdirSync(dir).filter(filter);
-	  return files[0] && path.join(dir, files[0])
-	}
-
-	function matchBuild (name) {
-	  return /\.node$/.test(name)
-	}
-
-	function parseTuple (name) {
-	  // Example: darwin-x64+arm64
-	  var arr = name.split('-');
-	  if (arr.length !== 2) return
-
-	  var platform = arr[0];
-	  var architectures = arr[1].split('+');
-
-	  if (!platform) return
-	  if (!architectures.length) return
-	  if (!architectures.every(Boolean)) return
-
-	  return { name, platform, architectures }
-	}
-
-	function matchTuple (platform, arch) {
-	  return function (tuple) {
-	    if (tuple == null) return false
-	    if (tuple.platform !== platform) return false
-	    return tuple.architectures.includes(arch)
-	  }
-	}
-
-	function compareTuples (a, b) {
-	  // Prefer single-arch prebuilds over multi-arch
-	  return a.architectures.length - b.architectures.length
-	}
-
-	function parseTags (file) {
-	  var arr = file.split('.');
-	  var extension = arr.pop();
-	  var tags = { file: file, specificity: 0 };
-
-	  if (extension !== 'node') return
-
-	  for (var i = 0; i < arr.length; i++) {
-	    var tag = arr[i];
-
-	    if (tag === 'node' || tag === 'electron' || tag === 'node-webkit') {
-	      tags.runtime = tag;
-	    } else if (tag === 'napi') {
-	      tags.napi = true;
-	    } else if (tag.slice(0, 3) === 'abi') {
-	      tags.abi = tag.slice(3);
-	    } else if (tag.slice(0, 2) === 'uv') {
-	      tags.uv = tag.slice(2);
-	    } else if (tag.slice(0, 4) === 'armv') {
-	      tags.armv = tag.slice(4);
-	    } else if (tag === 'glibc' || tag === 'musl') {
-	      tags.libc = tag;
-	    } else {
-	      continue
-	    }
-
-	    tags.specificity++;
-	  }
-
-	  return tags
-	}
-
-	function matchTags (runtime, abi) {
-	  return function (tags) {
-	    if (tags == null) return false
-	    if (tags.runtime !== runtime && !runtimeAgnostic(tags)) return false
-	    if (tags.abi !== abi && !tags.napi) return false
-	    if (tags.uv && tags.uv !== uv) return false
-	    if (tags.armv && tags.armv !== armv) return false
-	    if (tags.libc && tags.libc !== libc) return false
-
-	    return true
-	  }
-	}
-
-	function runtimeAgnostic (tags) {
-	  return tags.runtime === 'node' && tags.napi
-	}
-
-	function compareTags (runtime) {
-	  // Precedence: non-agnostic runtime, abi over napi, then by specificity.
-	  return function (a, b) {
-	    if (a.runtime !== b.runtime) {
-	      return a.runtime === runtime ? -1 : 1
-	    } else if (a.abi !== b.abi) {
-	      return a.abi ? -1 : 1
-	    } else if (a.specificity !== b.specificity) {
-	      return a.specificity > b.specificity ? -1 : 1
-	    } else {
-	      return 0
-	    }
-	  }
-	}
-
-	function isNwjs () {
-	  return !!(process.versions && process.versions.nw)
-	}
-
-	function isElectron () {
-	  if (process.versions && process.versions.electron) return true
-	  if (process.env.ELECTRON_RUN_AS_NODE) return true
-	  return typeof window !== 'undefined' && window.process && window.process.type === 'renderer'
-	}
-
-	function isAlpine (platform) {
-	  return platform === 'linux' && fs.existsSync('/etc/alpine-release')
-	}
-
-	// Exposed for unit tests
-	// TODO: move to lib
-	load.parseTags = parseTags;
-	load.matchTags = matchTags;
-	load.compareTags = compareTags;
-	load.parseTuple = parseTuple;
-	load.matchTuple = matchTuple;
-	load.compareTuples = compareTuples;
-	return nodeGypBuild;
-}
-
-var bindings;
-var hasRequiredBindings;
-
-function requireBindings () {
-	if (hasRequiredBindings) return bindings;
-	hasRequiredBindings = 1;
-	bindings = requireApi()(requireNodeGypBuild()(__dirname));
-	return bindings;
-}
-
-var keccakStateUnroll = {};
-
-var hasRequiredKeccakStateUnroll;
-
-function requireKeccakStateUnroll () {
-	if (hasRequiredKeccakStateUnroll) return keccakStateUnroll;
-	hasRequiredKeccakStateUnroll = 1;
-	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];
-
-	keccakStateUnroll.p1600 = function (s) {
-	  for (let round = 0; round < 24; ++round) {
-	    // theta
-	    const lo0 = s[0] ^ s[10] ^ s[20] ^ s[30] ^ s[40];
-	    const hi0 = s[1] ^ s[11] ^ s[21] ^ s[31] ^ s[41];
-	    const lo1 = s[2] ^ s[12] ^ s[22] ^ s[32] ^ s[42];
-	    const hi1 = s[3] ^ s[13] ^ s[23] ^ s[33] ^ s[43];
-	    const lo2 = s[4] ^ s[14] ^ s[24] ^ s[34] ^ s[44];
-	    const hi2 = s[5] ^ s[15] ^ s[25] ^ s[35] ^ s[45];
-	    const lo3 = s[6] ^ s[16] ^ s[26] ^ s[36] ^ s[46];
-	    const hi3 = s[7] ^ s[17] ^ s[27] ^ s[37] ^ s[47];
-	    const lo4 = s[8] ^ s[18] ^ s[28] ^ s[38] ^ s[48];
-	    const hi4 = s[9] ^ s[19] ^ s[29] ^ s[39] ^ s[49];
-
-	    let lo = lo4 ^ (lo1 << 1 | hi1 >>> 31);
-	    let hi = hi4 ^ (hi1 << 1 | lo1 >>> 31);
-	    const t1slo0 = s[0] ^ lo;
-	    const t1shi0 = s[1] ^ hi;
-	    const t1slo5 = s[10] ^ lo;
-	    const t1shi5 = s[11] ^ hi;
-	    const t1slo10 = s[20] ^ lo;
-	    const t1shi10 = s[21] ^ hi;
-	    const t1slo15 = s[30] ^ lo;
-	    const t1shi15 = s[31] ^ hi;
-	    const t1slo20 = s[40] ^ lo;
-	    const t1shi20 = s[41] ^ hi;
-	    lo = lo0 ^ (lo2 << 1 | hi2 >>> 31);
-	    hi = hi0 ^ (hi2 << 1 | lo2 >>> 31);
-	    const t1slo1 = s[2] ^ lo;
-	    const t1shi1 = s[3] ^ hi;
-	    const t1slo6 = s[12] ^ lo;
-	    const t1shi6 = s[13] ^ hi;
-	    const t1slo11 = s[22] ^ lo;
-	    const t1shi11 = s[23] ^ hi;
-	    const t1slo16 = s[32] ^ lo;
-	    const t1shi16 = s[33] ^ hi;
-	    const t1slo21 = s[42] ^ lo;
-	    const t1shi21 = s[43] ^ hi;
-	    lo = lo1 ^ (lo3 << 1 | hi3 >>> 31);
-	    hi = hi1 ^ (hi3 << 1 | lo3 >>> 31);
-	    const t1slo2 = s[4] ^ lo;
-	    const t1shi2 = s[5] ^ hi;
-	    const t1slo7 = s[14] ^ lo;
-	    const t1shi7 = s[15] ^ hi;
-	    const t1slo12 = s[24] ^ lo;
-	    const t1shi12 = s[25] ^ hi;
-	    const t1slo17 = s[34] ^ lo;
-	    const t1shi17 = s[35] ^ hi;
-	    const t1slo22 = s[44] ^ lo;
-	    const t1shi22 = s[45] ^ hi;
-	    lo = lo2 ^ (lo4 << 1 | hi4 >>> 31);
-	    hi = hi2 ^ (hi4 << 1 | lo4 >>> 31);
-	    const t1slo3 = s[6] ^ lo;
-	    const t1shi3 = s[7] ^ hi;
-	    const t1slo8 = s[16] ^ lo;
-	    const t1shi8 = s[17] ^ hi;
-	    const t1slo13 = s[26] ^ lo;
-	    const t1shi13 = s[27] ^ hi;
-	    const t1slo18 = s[36] ^ lo;
-	    const t1shi18 = s[37] ^ hi;
-	    const t1slo23 = s[46] ^ lo;
-	    const t1shi23 = s[47] ^ hi;
-	    lo = lo3 ^ (lo0 << 1 | hi0 >>> 31);
-	    hi = hi3 ^ (hi0 << 1 | lo0 >>> 31);
-	    const t1slo4 = s[8] ^ lo;
-	    const t1shi4 = s[9] ^ hi;
-	    const t1slo9 = s[18] ^ lo;
-	    const t1shi9 = s[19] ^ hi;
-	    const t1slo14 = s[28] ^ lo;
-	    const t1shi14 = s[29] ^ hi;
-	    const t1slo19 = s[38] ^ lo;
-	    const t1shi19 = s[39] ^ hi;
-	    const t1slo24 = s[48] ^ lo;
-	    const t1shi24 = s[49] ^ hi;
-
-	    // rho & pi
-	    const t2slo0 = t1slo0;
-	    const t2shi0 = t1shi0;
-	    const t2slo16 = (t1shi5 << 4 | t1slo5 >>> 28);
-	    const t2shi16 = (t1slo5 << 4 | t1shi5 >>> 28);
-	    const t2slo7 = (t1slo10 << 3 | t1shi10 >>> 29);
-	    const t2shi7 = (t1shi10 << 3 | t1slo10 >>> 29);
-	    const t2slo23 = (t1shi15 << 9 | t1slo15 >>> 23);
-	    const t2shi23 = (t1slo15 << 9 | t1shi15 >>> 23);
-	    const t2slo14 = (t1slo20 << 18 | t1shi20 >>> 14);
-	    const t2shi14 = (t1shi20 << 18 | t1slo20 >>> 14);
-	    const t2slo10 = (t1slo1 << 1 | t1shi1 >>> 31);
-	    const t2shi10 = (t1shi1 << 1 | t1slo1 >>> 31);
-	    const t2slo1 = (t1shi6 << 12 | t1slo6 >>> 20);
-	    const t2shi1 = (t1slo6 << 12 | t1shi6 >>> 20);
-	    const t2slo17 = (t1slo11 << 10 | t1shi11 >>> 22);
-	    const t2shi17 = (t1shi11 << 10 | t1slo11 >>> 22);
-	    const t2slo8 = (t1shi16 << 13 | t1slo16 >>> 19);
-	    const t2shi8 = (t1slo16 << 13 | t1shi16 >>> 19);
-	    const t2slo24 = (t1slo21 << 2 | t1shi21 >>> 30);
-	    const t2shi24 = (t1shi21 << 2 | t1slo21 >>> 30);
-	    const t2slo20 = (t1shi2 << 30 | t1slo2 >>> 2);
-	    const t2shi20 = (t1slo2 << 30 | t1shi2 >>> 2);
-	    const t2slo11 = (t1slo7 << 6 | t1shi7 >>> 26);
-	    const t2shi11 = (t1shi7 << 6 | t1slo7 >>> 26);
-	    const t2slo2 = (t1shi12 << 11 | t1slo12 >>> 21);
-	    const t2shi2 = (t1slo12 << 11 | t1shi12 >>> 21);
-	    const t2slo18 = (t1slo17 << 15 | t1shi17 >>> 17);
-	    const t2shi18 = (t1shi17 << 15 | t1slo17 >>> 17);
-	    const t2slo9 = (t1shi22 << 29 | t1slo22 >>> 3);
-	    const t2shi9 = (t1slo22 << 29 | t1shi22 >>> 3);
-	    const t2slo5 = (t1slo3 << 28 | t1shi3 >>> 4);
-	    const t2shi5 = (t1shi3 << 28 | t1slo3 >>> 4);
-	    const t2slo21 = (t1shi8 << 23 | t1slo8 >>> 9);
-	    const t2shi21 = (t1slo8 << 23 | t1shi8 >>> 9);
-	    const t2slo12 = (t1slo13 << 25 | t1shi13 >>> 7);
-	    const t2shi12 = (t1shi13 << 25 | t1slo13 >>> 7);
-	    const t2slo3 = (t1slo18 << 21 | t1shi18 >>> 11);
-	    const t2shi3 = (t1shi18 << 21 | t1slo18 >>> 11);
-	    const t2slo19 = (t1shi23 << 24 | t1slo23 >>> 8);
-	    const t2shi19 = (t1slo23 << 24 | t1shi23 >>> 8);
-	    const t2slo15 = (t1slo4 << 27 | t1shi4 >>> 5);
-	    const t2shi15 = (t1shi4 << 27 | t1slo4 >>> 5);
-	    const t2slo6 = (t1slo9 << 20 | t1shi9 >>> 12);
-	    const t2shi6 = (t1shi9 << 20 | t1slo9 >>> 12);
-	    const t2slo22 = (t1shi14 << 7 | t1slo14 >>> 25);
-	    const t2shi22 = (t1slo14 << 7 | t1shi14 >>> 25);
-	    const t2slo13 = (t1slo19 << 8 | t1shi19 >>> 24);
-	    const t2shi13 = (t1shi19 << 8 | t1slo19 >>> 24);
-	    const t2slo4 = (t1slo24 << 14 | t1shi24 >>> 18);
-	    const t2shi4 = (t1shi24 << 14 | t1slo24 >>> 18);
-
-	    // chi
-	    s[0] = t2slo0 ^ (~t2slo1 & t2slo2);
-	    s[1] = t2shi0 ^ (~t2shi1 & t2shi2);
-	    s[10] = t2slo5 ^ (~t2slo6 & t2slo7);
-	    s[11] = t2shi5 ^ (~t2shi6 & t2shi7);
-	    s[20] = t2slo10 ^ (~t2slo11 & t2slo12);
-	    s[21] = t2shi10 ^ (~t2shi11 & t2shi12);
-	    s[30] = t2slo15 ^ (~t2slo16 & t2slo17);
-	    s[31] = t2shi15 ^ (~t2shi16 & t2shi17);
-	    s[40] = t2slo20 ^ (~t2slo21 & t2slo22);
-	    s[41] = t2shi20 ^ (~t2shi21 & t2shi22);
-	    s[2] = t2slo1 ^ (~t2slo2 & t2slo3);
-	    s[3] = t2shi1 ^ (~t2shi2 & t2shi3);
-	    s[12] = t2slo6 ^ (~t2slo7 & t2slo8);
-	    s[13] = t2shi6 ^ (~t2shi7 & t2shi8);
-	    s[22] = t2slo11 ^ (~t2slo12 & t2slo13);
-	    s[23] = t2shi11 ^ (~t2shi12 & t2shi13);
-	    s[32] = t2slo16 ^ (~t2slo17 & t2slo18);
-	    s[33] = t2shi16 ^ (~t2shi17 & t2shi18);
-	    s[42] = t2slo21 ^ (~t2slo22 & t2slo23);
-	    s[43] = t2shi21 ^ (~t2shi22 & t2shi23);
-	    s[4] = t2slo2 ^ (~t2slo3 & t2slo4);
-	    s[5] = t2shi2 ^ (~t2shi3 & t2shi4);
-	    s[14] = t2slo7 ^ (~t2slo8 & t2slo9);
-	    s[15] = t2shi7 ^ (~t2shi8 & t2shi9);
-	    s[24] = t2slo12 ^ (~t2slo13 & t2slo14);
-	    s[25] = t2shi12 ^ (~t2shi13 & t2shi14);
-	    s[34] = t2slo17 ^ (~t2slo18 & t2slo19);
-	    s[35] = t2shi17 ^ (~t2shi18 & t2shi19);
-	    s[44] = t2slo22 ^ (~t2slo23 & t2slo24);
-	    s[45] = t2shi22 ^ (~t2shi23 & t2shi24);
-	    s[6] = t2slo3 ^ (~t2slo4 & t2slo0);
-	    s[7] = t2shi3 ^ (~t2shi4 & t2shi0);
-	    s[16] = t2slo8 ^ (~t2slo9 & t2slo5);
-	    s[17] = t2shi8 ^ (~t2shi9 & t2shi5);
-	    s[26] = t2slo13 ^ (~t2slo14 & t2slo10);
-	    s[27] = t2shi13 ^ (~t2shi14 & t2shi10);
-	    s[36] = t2slo18 ^ (~t2slo19 & t2slo15);
-	    s[37] = t2shi18 ^ (~t2shi19 & t2shi15);
-	    s[46] = t2slo23 ^ (~t2slo24 & t2slo20);
-	    s[47] = t2shi23 ^ (~t2shi24 & t2shi20);
-	    s[8] = t2slo4 ^ (~t2slo0 & t2slo1);
-	    s[9] = t2shi4 ^ (~t2shi0 & t2shi1);
-	    s[18] = t2slo9 ^ (~t2slo5 & t2slo6);
-	    s[19] = t2shi9 ^ (~t2shi5 & t2shi6);
-	    s[28] = t2slo14 ^ (~t2slo10 & t2slo11);
-	    s[29] = t2shi14 ^ (~t2shi10 & t2shi11);
-	    s[38] = t2slo19 ^ (~t2slo15 & t2slo16);
-	    s[39] = t2shi19 ^ (~t2shi15 & t2shi16);
-	    s[48] = t2slo24 ^ (~t2slo20 & t2slo21);
-	    s[49] = t2shi24 ^ (~t2shi20 & t2shi21);
-
-	    // iota
-	    s[0] ^= P1600_ROUND_CONSTANTS[round * 2];
-	    s[1] ^= P1600_ROUND_CONSTANTS[round * 2 + 1];
-	  }
-	};
-	return keccakStateUnroll;
-}
-
-var keccak;
-var hasRequiredKeccak;
-
-function requireKeccak () {
-	if (hasRequiredKeccak) return keccak;
-	hasRequiredKeccak = 1;
-	const keccakState = requireKeccakStateUnroll();
-
-	function Keccak () {
-	  // much faster than `new Array(50)`
-	  this.state = [
-	    0, 0, 0, 0, 0,
-	    0, 0, 0, 0, 0,
-	    0, 0, 0, 0, 0,
-	    0, 0, 0, 0, 0,
-	    0, 0, 0, 0, 0
-	  ];
-
-	  this.blockSize = null;
-	  this.count = 0;
-	  this.squeezing = false;
-	}
-
-	Keccak.prototype.initialize = function (rate, capacity) {
-	  for (let i = 0; i < 50; ++i) this.state[i] = 0;
-	  this.blockSize = rate / 8;
-	  this.count = 0;
-	  this.squeezing = false;
-	};
-
-	Keccak.prototype.absorb = function (data) {
-	  for (let i = 0; i < data.length; ++i) {
-	    this.state[~~(this.count / 4)] ^= data[i] << (8 * (this.count % 4));
-	    this.count += 1;
-	    if (this.count === this.blockSize) {
-	      keccakState.p1600(this.state);
-	      this.count = 0;
-	    }
-	  }
-	};
-
-	Keccak.prototype.absorbLastFewBits = function (bits) {
-	  this.state[~~(this.count / 4)] ^= bits << (8 * (this.count % 4));
-	  if ((bits & 0x80) !== 0 && this.count === (this.blockSize - 1)) keccakState.p1600(this.state);
-	  this.state[~~((this.blockSize - 1) / 4)] ^= 0x80 << (8 * ((this.blockSize - 1) % 4));
-	  keccakState.p1600(this.state);
-	  this.count = 0;
-	  this.squeezing = true;
-	};
-
-	Keccak.prototype.squeeze = function (length) {
-	  if (!this.squeezing) this.absorbLastFewBits(0x01);
-
-	  const output = Buffer.alloc(length);
-	  for (let i = 0; i < length; ++i) {
-	    output[i] = (this.state[~~(this.count / 4)] >>> (8 * (this.count % 4))) & 0xff;
-	    this.count += 1;
-	    if (this.count === this.blockSize) {
-	      keccakState.p1600(this.state);
-	      this.count = 0;
-	    }
-	  }
-
-	  return output
-	};
-
-	Keccak.prototype.copy = function (dest) {
-	  for (let i = 0; i < 50; ++i) dest.state[i] = this.state[i];
-	  dest.blockSize = this.blockSize;
-	  dest.count = this.count;
-	  dest.squeezing = this.squeezing;
-	};
-
-	keccak = Keccak;
-	return keccak;
-}
-
-var js;
-var hasRequiredJs;
-
-function requireJs () {
-	if (hasRequiredJs) return js;
-	hasRequiredJs = 1;
-	js = requireApi()(requireKeccak());
-	return js;
-}
-
-(function (module) {
-	try {
-	  module.exports = requireBindings();
-	} catch (err) {
-	  module.exports = requireJs();
-	}
-} (keccak$2));
-
-Object.defineProperty(dist, '__esModule', { value: true });
-
-var bs32 = require$$0;
-var bs58 = require$$1;
-var isHex = require$$2;
-var varint = varint$1;
-var createKeccakHash = keccak$2.exports;
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-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);
-
-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()
-    }
-  }
-}
-
-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',
-  }
-};
-
-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
-  }
-}
-
-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,
-    }
-  }
-}
-
-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) {
-    let encoded;
-    if (!decoded) decoded = this.decoded;
-    const codec = new PeernetCodec(this.name);
-
-    if (decoded instanceof Uint8Array) encoded = decoded;
-    else 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))
-    )
-  }
-}
-
-const BasicInterface = BasicInterface$1;
-const FormatInterface = FormatInterface$1;
-const CodecHash = CodecHash$1;
-const Codec = PeernetCodec;
-const Codecs = codecs;
-
-dist.BasicInterface = BasicInterface;
-dist.Codec = Codec;
-dist.CodecHash = CodecHash;
-dist.Codecs = Codecs;
-var FormatInterface_1 = dist.FormatInterface = FormatInterface;
-
-class EasyWorker {
-  #messageEvent = 'message'
-  #errorEvent = 'error'
-  #isBrowser = false
-  #isWorker = false
-
-  get isWorker() {
-    return this.#isWorker
-  }
-  constructor(url, options) {
-    return this.#init(url, options)
-  }
-
-  #init(url, options = {}) {
-    if (url) {
-      if (globalThis.Worker) {
-        this.#isBrowser = true;
-        this.worker = new Worker(url, {...options});
-      } else {
-        return new Promise(async (resolve, reject) => {
-          const {fork} = await import('child_process');  
-          this.worker = fork(url, ['easy-worker-child'], options);
-          resolve(this);
-        })
-      }
-    } else {
-      this.#isWorker = true;
-      if (globalThis.process?.argv[2] === 'easy-worker-child') {
-        this.worker = process;
-      } else {
-        this.#isBrowser = true;
-        this.worker = globalThis;
-      }
-    }
-    
-    return this
-  }
-
-  onmessage(fn) {
-    if (this.#isBrowser) this.worker.onmessage = ({data}) => fn(data);
-    else this.worker.on(this.#messageEvent, fn);
-  }
-
-  postMessage(message) {
-    if (this.#isBrowser) this.worker.postMessage(message);
-    else this.worker.send(message);
-  }
-
-  terminate() {
-    if (this.#isBrowser) this.worker.terminate();
-    else this.worker.kill();
-  }
-
-  onerror(fn) {
-    if (this.#isBrowser) this.worker.onerror = fn;
-    else this.worker.on(this.#errorEvent, fn);
-  }
-
-  /**
-   * 
-   * @param {*} data 
-   * @returns {Promise} resolves result onmessage & rejects on error
-   */
-  once(data) {
-    return new Promise((resolve, reject) => {
-      this.onmessage(message => {
-        resolve(message);
-        this.terminate();
-      });
-      this.onerror(error => {
-        reject(error);
-        this.terminate();
-      });
-      this.postMessage(data);
-    })    
-  }  
-}
-
-export { EasyWorker as E, FormatInterface_1 as F, commonjsGlobal as c };