@leofcoin/codec-format-interface 1.3.0 → 1.3.1

package/dist/browser.js

@@ -0,0 +1,4228 @@
+import * as $gHtSl$buffer from "buffer";
+import {nextTick as $gHtSl$nextTick, stdout as $gHtSl$stdout, stderr as $gHtSl$stderr} from "process";
+import {EventEmitter as $gHtSl$EventEmitter} from "events";
+
+var $parcel$global =
+typeof globalThis !== 'undefined'
+  ? globalThis
+  : typeof self !== 'undefined'
+  ? self
+  : typeof window !== 'undefined'
+  ? window
+  : typeof global !== 'undefined'
+  ? global
+  : {};
+function $parcel$export(e, n, v, s) {
+  Object.defineProperty(e, n, {get: v, set: s, enumerable: true, configurable: true});
+}
+function $parcel$interopDefault(a) {
+  return a && a.__esModule ? a.default : a;
+}
+var $parcel$modules = {};
+var $parcel$inits = {};
+
+var parcelRequire = $parcel$global["parcelRequire8c5b"];
+if (parcelRequire == null) {
+  parcelRequire = function(id) {
+    if (id in $parcel$modules) {
+      return $parcel$modules[id].exports;
+    }
+    if (id in $parcel$inits) {
+      var init = $parcel$inits[id];
+      delete $parcel$inits[id];
+      var module = {id: id, exports: {}};
+      $parcel$modules[id] = module;
+      init.call(module.exports, module, module.exports);
+      return module.exports;
+    }
+    var err = new Error("Cannot find module '" + id + "'");
+    err.code = 'MODULE_NOT_FOUND';
+    throw err;
+  };
+
+  parcelRequire.register = function register(id, init) {
+    $parcel$inits[id] = init;
+  };
+
+  $parcel$global["parcelRequire8c5b"] = parcelRequire;
+}
+parcelRequire.register("O0X0N", function(module, exports) {
+module.exports = $0965686fca2f0b23$var$encode;
+var $0965686fca2f0b23$var$MSB = 0x80, $0965686fca2f0b23$var$REST = 0x7F, $0965686fca2f0b23$var$MSBALL = ~$0965686fca2f0b23$var$REST, $0965686fca2f0b23$var$INT = Math.pow(2, 31);
+function $0965686fca2f0b23$var$encode(num, out, offset) {
+    if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+        $0965686fca2f0b23$var$encode.bytes = 0;
+        throw new RangeError("Could not encode varint");
+    }
+    out = out || [];
+    offset = offset || 0;
+    var oldOffset = offset;
+    while(num >= $0965686fca2f0b23$var$INT){
+        out[offset++] = num & 0xFF | $0965686fca2f0b23$var$MSB;
+        num /= 128;
+    }
+    while(num & $0965686fca2f0b23$var$MSBALL){
+        out[offset++] = num & 0xFF | $0965686fca2f0b23$var$MSB;
+        num >>>= 7;
+    }
+    out[offset] = num | 0;
+    $0965686fca2f0b23$var$encode.bytes = offset - oldOffset + 1;
+    return out;
+}
+
+});
+
+parcelRequire.register("c0YY7", function(module, exports) {
+module.exports = $8bf4c73d37fa4e04$var$read;
+var $8bf4c73d37fa4e04$var$MSB = 0x80, $8bf4c73d37fa4e04$var$REST = 0x7F;
+function $8bf4c73d37fa4e04$var$read(buf, offset) {
+    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+    do {
+        if (counter >= l || shift > 49) {
+            $8bf4c73d37fa4e04$var$read.bytes = 0;
+            throw new RangeError("Could not decode varint");
+        }
+        b = buf[counter++];
+        res += shift < 28 ? (b & $8bf4c73d37fa4e04$var$REST) << shift : (b & $8bf4c73d37fa4e04$var$REST) * Math.pow(2, shift);
+        shift += 7;
+    }while (b >= $8bf4c73d37fa4e04$var$MSB);
+    $8bf4c73d37fa4e04$var$read.bytes = counter - offset;
+    return res;
+}
+
+});
+
+parcelRequire.register("1H9q1", function(module, exports) {
+var $13c11cf855e8ad94$var$N1 = Math.pow(2, 7);
+var $13c11cf855e8ad94$var$N2 = Math.pow(2, 14);
+var $13c11cf855e8ad94$var$N3 = Math.pow(2, 21);
+var $13c11cf855e8ad94$var$N4 = Math.pow(2, 28);
+var $13c11cf855e8ad94$var$N5 = Math.pow(2, 35);
+var $13c11cf855e8ad94$var$N6 = Math.pow(2, 42);
+var $13c11cf855e8ad94$var$N7 = Math.pow(2, 49);
+var $13c11cf855e8ad94$var$N8 = Math.pow(2, 56);
+var $13c11cf855e8ad94$var$N9 = Math.pow(2, 63);
+module.exports = function(value) {
+    return value < $13c11cf855e8ad94$var$N1 ? 1 : value < $13c11cf855e8ad94$var$N2 ? 2 : value < $13c11cf855e8ad94$var$N3 ? 3 : value < $13c11cf855e8ad94$var$N4 ? 4 : value < $13c11cf855e8ad94$var$N5 ? 5 : value < $13c11cf855e8ad94$var$N6 ? 6 : value < $13c11cf855e8ad94$var$N7 ? 7 : value < $13c11cf855e8ad94$var$N8 ? 8 : value < $13c11cf855e8ad94$var$N9 ? 9 : 10;
+};
+
+});
+
+parcelRequire.register("4n0nt", function(module, exports) {
+
+var $hYVtA = parcelRequire("hYVtA");
+
+var $6hFBI = parcelRequire("6hFBI");
+module.exports = function(KeccakState) {
+    const Keccak = $hYVtA(KeccakState);
+    const Shake = $6hFBI(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);
+        }
+    };
+};
+
+});
+parcelRequire.register("hYVtA", function(module, exports) {
+
+var $d1749fd7588e76b4$require$Buffer = $gHtSl$Buffer;
+
+var $4VNAq = parcelRequire("4VNAq");
+var $d1749fd7588e76b4$require$Transform = $4VNAq.Transform;
+module.exports = (KeccakState)=>{
+    class Keccak extends $d1749fd7588e76b4$require$Transform {
+        _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 (!$d1749fd7588e76b4$require$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 (!$d1749fd7588e76b4$require$Buffer.isBuffer(data)) data = $d1749fd7588e76b4$require$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;
+        }
+        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;
+        }
+    }
+    return Keccak;
+};
+
+});
+parcelRequire.register("4VNAq", function(module, exports) {
+
+exports = module.exports = (parcelRequire("dRV5p"));
+exports.Stream = exports;
+exports.Readable = exports;
+
+exports.Writable = (parcelRequire("8T77c"));
+
+exports.Duplex = (parcelRequire("cK2wf"));
+
+exports.Transform = (parcelRequire("az4hH"));
+
+exports.PassThrough = (parcelRequire("dnNlY"));
+
+exports.finished = (parcelRequire("7wU83"));
+
+exports.pipeline = (parcelRequire("jq29e"));
+
+});
+parcelRequire.register("dRV5p", function(module, exports) {
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+"use strict";
+
+module.exports = $a18c81ba90bd587c$var$Readable;
+/*<replacement>*/ var $a18c81ba90bd587c$var$Duplex;
+/*</replacement>*/ $a18c81ba90bd587c$var$Readable.ReadableState = $a18c81ba90bd587c$var$ReadableState;
+
+var $a18c81ba90bd587c$require$EE = $gHtSl$EventEmitter;
+var $a18c81ba90bd587c$var$EElistenerCount = function EElistenerCount(emitter, type) {
+    return emitter.listeners(type).length;
+};
+
+var $47Ymo = parcelRequire("47Ymo");
+
+var $a18c81ba90bd587c$require$Buffer = $gHtSl$Buffer;
+var $a18c81ba90bd587c$var$OurUint8Array = $parcel$global.Uint8Array || function() {};
+function $a18c81ba90bd587c$var$_uint8ArrayToBuffer(chunk) {
+    return $a18c81ba90bd587c$require$Buffer.from(chunk);
+}
+function $a18c81ba90bd587c$var$_isUint8Array(obj) {
+    return $a18c81ba90bd587c$require$Buffer.isBuffer(obj) || obj instanceof $a18c81ba90bd587c$var$OurUint8Array;
+}
+
+var $2ueGT = parcelRequire("2ueGT");
+var $a18c81ba90bd587c$var$debug;
+if ($2ueGT && $2ueGT.debuglog) $a18c81ba90bd587c$var$debug = $2ueGT.debuglog("stream");
+else $a18c81ba90bd587c$var$debug = function debug() {};
+
+var $3N6Yx = parcelRequire("3N6Yx");
+
+var $dU5xr = parcelRequire("dU5xr");
+
+var $eGsJg = parcelRequire("eGsJg");
+var $a18c81ba90bd587c$var$getHighWaterMark = $eGsJg.getHighWaterMark;
+
+var $6vYby = parcelRequire("6vYby");
+var $a18c81ba90bd587c$require$_require$codes = $6vYby.codes;
+var $a18c81ba90bd587c$var$ERR_INVALID_ARG_TYPE = $a18c81ba90bd587c$require$_require$codes.ERR_INVALID_ARG_TYPE, $a18c81ba90bd587c$var$ERR_STREAM_PUSH_AFTER_EOF = $a18c81ba90bd587c$require$_require$codes.ERR_STREAM_PUSH_AFTER_EOF, $a18c81ba90bd587c$var$ERR_METHOD_NOT_IMPLEMENTED = $a18c81ba90bd587c$require$_require$codes.ERR_METHOD_NOT_IMPLEMENTED, $a18c81ba90bd587c$var$ERR_STREAM_UNSHIFT_AFTER_END_EVENT = $a18c81ba90bd587c$require$_require$codes.ERR_STREAM_UNSHIFT_AFTER_END_EVENT; // Lazy loaded to improve the startup performance.
+var $a18c81ba90bd587c$var$StringDecoder;
+var $a18c81ba90bd587c$var$createReadableStreamAsyncIterator;
+var $a18c81ba90bd587c$var$from;
+
+(parcelRequire("ghwEg"))($a18c81ba90bd587c$var$Readable, $47Ymo);
+var $a18c81ba90bd587c$var$errorOrDestroy = $dU5xr.errorOrDestroy;
+var $a18c81ba90bd587c$var$kProxyEvents = [
+    "error",
+    "close",
+    "destroy",
+    "pause",
+    "resume"
+];
+function $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$ReadableState(options, stream, isDuplex) {
+    $a18c81ba90bd587c$var$Duplex = $a18c81ba90bd587c$var$Duplex || (parcelRequire("cK2wf"));
+    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 $a18c81ba90bd587c$var$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 = $a18c81ba90bd587c$var$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 $3N6Yx();
+    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 (!$a18c81ba90bd587c$var$StringDecoder) $a18c81ba90bd587c$var$StringDecoder = (parcelRequire("aCyUD")).StringDecoder;
+        this.decoder = new $a18c81ba90bd587c$var$StringDecoder(options.encoding);
+        this.encoding = options.encoding;
+    }
+}
+
+function $a18c81ba90bd587c$var$Readable(options) {
+    $a18c81ba90bd587c$var$Duplex = $a18c81ba90bd587c$var$Duplex || (parcelRequire("cK2wf"));
+    if (!(this instanceof $a18c81ba90bd587c$var$Readable)) return new $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$Duplex;
+    this._readableState = new $a18c81ba90bd587c$var$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;
+    }
+    $47Ymo.call(this);
+}
+Object.defineProperty($a18c81ba90bd587c$var$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;
+    }
+});
+$a18c81ba90bd587c$var$Readable.prototype.destroy = $dU5xr.destroy;
+$a18c81ba90bd587c$var$Readable.prototype._undestroy = $dU5xr.undestroy;
+$a18c81ba90bd587c$var$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.
+$a18c81ba90bd587c$var$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 = $a18c81ba90bd587c$require$Buffer.from(chunk, encoding);
+                encoding = "";
+            }
+            skipChunkCheck = true;
+        }
+    } else skipChunkCheck = true;
+    return $a18c81ba90bd587c$var$readableAddChunk(this, chunk, encoding, false, skipChunkCheck);
+}; // Unshift should *always* be something directly out of read()
+$a18c81ba90bd587c$var$Readable.prototype.unshift = function(chunk) {
+    return $a18c81ba90bd587c$var$readableAddChunk(this, chunk, null, true, false);
+};
+function $a18c81ba90bd587c$var$readableAddChunk(stream, chunk, encoding, addToFront, skipChunkCheck) {
+    $a18c81ba90bd587c$var$debug("readableAddChunk", chunk);
+    var state = stream._readableState;
+    if (chunk === null) {
+        state.reading = false;
+        $a18c81ba90bd587c$var$onEofChunk(stream, state);
+    } else {
+        var er;
+        if (!skipChunkCheck) er = $a18c81ba90bd587c$var$chunkInvalid(state, chunk);
+        if (er) $a18c81ba90bd587c$var$errorOrDestroy(stream, er);
+        else if (state.objectMode || chunk && chunk.length > 0) {
+            if (typeof chunk !== "string" && !state.objectMode && Object.getPrototypeOf(chunk) !== $a18c81ba90bd587c$require$Buffer.prototype) chunk = $a18c81ba90bd587c$var$_uint8ArrayToBuffer(chunk);
+            if (addToFront) {
+                if (state.endEmitted) $a18c81ba90bd587c$var$errorOrDestroy(stream, new $a18c81ba90bd587c$var$ERR_STREAM_UNSHIFT_AFTER_END_EVENT());
+                else $a18c81ba90bd587c$var$addChunk(stream, state, chunk, true);
+            } else if (state.ended) $a18c81ba90bd587c$var$errorOrDestroy(stream, new $a18c81ba90bd587c$var$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) $a18c81ba90bd587c$var$addChunk(stream, state, chunk, false);
+                    else $a18c81ba90bd587c$var$maybeReadMore(stream, state);
+                } else $a18c81ba90bd587c$var$addChunk(stream, state, chunk, false);
+            }
+        } else if (!addToFront) {
+            state.reading = false;
+            $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$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) $a18c81ba90bd587c$var$emitReadable(stream);
+    }
+    $a18c81ba90bd587c$var$maybeReadMore(stream, state);
+}
+function $a18c81ba90bd587c$var$chunkInvalid(state, chunk) {
+    var er;
+    if (!$a18c81ba90bd587c$var$_isUint8Array(chunk) && typeof chunk !== "string" && chunk !== undefined && !state.objectMode) er = new $a18c81ba90bd587c$var$ERR_INVALID_ARG_TYPE("chunk", [
+        "string",
+        "Buffer",
+        "Uint8Array"
+    ], chunk);
+    return er;
+}
+$a18c81ba90bd587c$var$Readable.prototype.isPaused = function() {
+    return this._readableState.flowing === false;
+}; // backwards compatibility.
+
+$a18c81ba90bd587c$var$Readable.prototype.setEncoding = function(enc) {
+    if (!$a18c81ba90bd587c$var$StringDecoder) $a18c81ba90bd587c$var$StringDecoder = (parcelRequire("aCyUD")).StringDecoder;
+    var decoder = new $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$MAX_HWM = 0x40000000;
+function $a18c81ba90bd587c$var$computeNewHighWaterMark(n) {
+    if (n >= $a18c81ba90bd587c$var$MAX_HWM) // TODO(ronag): Throw ERR_VALUE_OUT_OF_RANGE.
+    n = $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$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 = $a18c81ba90bd587c$var$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.
+$a18c81ba90bd587c$var$Readable.prototype.read = function(n) {
+    $a18c81ba90bd587c$var$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)) {
+        $a18c81ba90bd587c$var$debug("read: emitReadable", state.length, state.ended);
+        if (state.length === 0 && state.ended) $a18c81ba90bd587c$var$endReadable(this);
+        else $a18c81ba90bd587c$var$emitReadable(this);
+        return null;
+    }
+    n = $a18c81ba90bd587c$var$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) $a18c81ba90bd587c$var$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;
+    $a18c81ba90bd587c$var$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;
+        $a18c81ba90bd587c$var$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;
+        $a18c81ba90bd587c$var$debug("reading or ended", doRead);
+    } else if (doRead) {
+        $a18c81ba90bd587c$var$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 = $a18c81ba90bd587c$var$howMuchToRead(nOrig, state);
+    }
+    var ret;
+    if (n > 0) ret = $a18c81ba90bd587c$var$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) $a18c81ba90bd587c$var$endReadable(this);
+    }
+    if (ret !== null) this.emit("data", ret);
+    return ret;
+};
+function $a18c81ba90bd587c$var$onEofChunk(stream, state) {
+    $a18c81ba90bd587c$var$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
+    $a18c81ba90bd587c$var$emitReadable(stream);
+    else {
+        // emit 'readable' now to make sure it gets picked up.
+        state.needReadable = false;
+        if (!state.emittedReadable) {
+            state.emittedReadable = true;
+            $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$emitReadable(stream) {
+    var state = stream._readableState;
+    $a18c81ba90bd587c$var$debug("emitReadable", state.needReadable, state.emittedReadable);
+    state.needReadable = false;
+    if (!state.emittedReadable) {
+        $a18c81ba90bd587c$var$debug("emitReadable", state.flowing);
+        state.emittedReadable = true;
+        $gHtSl$nextTick($a18c81ba90bd587c$var$emitReadable_, stream);
+    }
+}
+function $a18c81ba90bd587c$var$emitReadable_(stream) {
+    var state = stream._readableState;
+    $a18c81ba90bd587c$var$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;
+    $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$maybeReadMore(stream, state) {
+    if (!state.readingMore) {
+        state.readingMore = true;
+        $gHtSl$nextTick($a18c81ba90bd587c$var$maybeReadMore_, stream, state);
+    }
+}
+function $a18c81ba90bd587c$var$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;
+        $a18c81ba90bd587c$var$debug("maybeReadMore read 0");
+        stream.read(0);
+        if (len === state.length) 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.
+$a18c81ba90bd587c$var$Readable.prototype._read = function(n) {
+    $a18c81ba90bd587c$var$errorOrDestroy(this, new $a18c81ba90bd587c$var$ERR_METHOD_NOT_IMPLEMENTED("_read()"));
+};
+$a18c81ba90bd587c$var$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;
+    $a18c81ba90bd587c$var$debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);
+    var doEnd = (!pipeOpts || pipeOpts.end !== false) && dest !== $gHtSl$stdout && dest !== $gHtSl$stderr;
+    var endFn = doEnd ? onend : unpipe;
+    if (state.endEmitted) $gHtSl$nextTick(endFn);
+    else src.once("end", endFn);
+    dest.on("unpipe", onunpipe);
+    function onunpipe(readable, unpipeInfo) {
+        $a18c81ba90bd587c$var$debug("onunpipe");
+        if (readable === src) {
+            if (unpipeInfo && unpipeInfo.hasUnpiped === false) {
+                unpipeInfo.hasUnpiped = true;
+                cleanup();
+            }
+        }
+    }
+    function onend() {
+        $a18c81ba90bd587c$var$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 = $a18c81ba90bd587c$var$pipeOnDrain(src);
+    dest.on("drain", ondrain);
+    var cleanedUp = false;
+    function cleanup() {
+        $a18c81ba90bd587c$var$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) {
+        $a18c81ba90bd587c$var$debug("ondata");
+        var ret = dest.write(chunk);
+        $a18c81ba90bd587c$var$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 && $a18c81ba90bd587c$var$indexOf(state.pipes, dest) !== -1) && !cleanedUp) {
+                $a18c81ba90bd587c$var$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) {
+        $a18c81ba90bd587c$var$debug("onerror", er);
+        unpipe();
+        dest.removeListener("error", onerror);
+        if ($a18c81ba90bd587c$var$EElistenerCount(dest, "error") === 0) $a18c81ba90bd587c$var$errorOrDestroy(dest, er);
+    } // Make sure our error handler is attached before userland ones.
+    $a18c81ba90bd587c$var$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() {
+        $a18c81ba90bd587c$var$debug("onfinish");
+        dest.removeListener("close", onclose);
+        unpipe();
+    }
+    dest.once("finish", onfinish);
+    function unpipe() {
+        $a18c81ba90bd587c$var$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) {
+        $a18c81ba90bd587c$var$debug("pipe resume");
+        src.resume();
+    }
+    return dest;
+};
+function $a18c81ba90bd587c$var$pipeOnDrain(src) {
+    return function pipeOnDrainFunctionResult() {
+        var state = src._readableState;
+        $a18c81ba90bd587c$var$debug("pipeOnDrain", state.awaitDrain);
+        if (state.awaitDrain) state.awaitDrain--;
+        if (state.awaitDrain === 0 && $a18c81ba90bd587c$var$EElistenerCount(src, "data")) {
+            state.flowing = true;
+            $a18c81ba90bd587c$var$flow(src);
+        }
+    };
+}
+$a18c81ba90bd587c$var$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 = $a18c81ba90bd587c$var$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
+$a18c81ba90bd587c$var$Readable.prototype.on = function(ev, fn) {
+    var res = $47Ymo.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;
+            $a18c81ba90bd587c$var$debug("on readable", state.length, state.reading);
+            if (state.length) $a18c81ba90bd587c$var$emitReadable(this);
+            else if (!state.reading) $gHtSl$nextTick($a18c81ba90bd587c$var$nReadingNextTick, this);
+        }
+    }
+    return res;
+};
+$a18c81ba90bd587c$var$Readable.prototype.addListener = $a18c81ba90bd587c$var$Readable.prototype.on;
+$a18c81ba90bd587c$var$Readable.prototype.removeListener = function(ev, fn) {
+    var res = $47Ymo.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.
+    $gHtSl$nextTick($a18c81ba90bd587c$var$updateReadableListening, this);
+    return res;
+};
+$a18c81ba90bd587c$var$Readable.prototype.removeAllListeners = function(ev) {
+    var res = $47Ymo.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.
+    $gHtSl$nextTick($a18c81ba90bd587c$var$updateReadableListening, this);
+    return res;
+};
+function $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$nReadingNextTick(self) {
+    $a18c81ba90bd587c$var$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.
+$a18c81ba90bd587c$var$Readable.prototype.resume = function() {
+    var state = this._readableState;
+    if (!state.flowing) {
+        $a18c81ba90bd587c$var$debug("resume"); // we flow only if there is no one listening
+        // for readable, but we still have to call
+        // resume()
+        state.flowing = !state.readableListening;
+        $a18c81ba90bd587c$var$resume(this, state);
+    }
+    state.paused = false;
+    return this;
+};
+function $a18c81ba90bd587c$var$resume(stream, state) {
+    if (!state.resumeScheduled) {
+        state.resumeScheduled = true;
+        $gHtSl$nextTick($a18c81ba90bd587c$var$resume_, stream, state);
+    }
+}
+function $a18c81ba90bd587c$var$resume_(stream, state) {
+    $a18c81ba90bd587c$var$debug("resume", state.reading);
+    if (!state.reading) stream.read(0);
+    state.resumeScheduled = false;
+    stream.emit("resume");
+    $a18c81ba90bd587c$var$flow(stream);
+    if (state.flowing && !state.reading) stream.read(0);
+}
+$a18c81ba90bd587c$var$Readable.prototype.pause = function() {
+    $a18c81ba90bd587c$var$debug("call pause flowing=%j", this._readableState.flowing);
+    if (this._readableState.flowing !== false) {
+        $a18c81ba90bd587c$var$debug("pause");
+        this._readableState.flowing = false;
+        this.emit("pause");
+    }
+    this._readableState.paused = true;
+    return this;
+};
+function $a18c81ba90bd587c$var$flow(stream) {
+    var state = stream._readableState;
+    $a18c81ba90bd587c$var$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.
+$a18c81ba90bd587c$var$Readable.prototype.wrap = function(stream) {
+    var _this = this;
+    var state = this._readableState;
+    var paused = false;
+    stream.on("end", function() {
+        $a18c81ba90bd587c$var$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) {
+        $a18c81ba90bd587c$var$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 < $a18c81ba90bd587c$var$kProxyEvents.length; n++)stream.on($a18c81ba90bd587c$var$kProxyEvents[n], this.emit.bind(this, $a18c81ba90bd587c$var$kProxyEvents[n]));
+     // when we try to consume some more bytes, simply unpause the
+    // underlying stream.
+    this._read = function(n) {
+        $a18c81ba90bd587c$var$debug("wrapped _read", n);
+        if (paused) {
+            paused = false;
+            stream.resume();
+        }
+    };
+    return this;
+};
+
+if (typeof Symbol === "function") $a18c81ba90bd587c$var$Readable.prototype[Symbol.asyncIterator] = function() {
+    if ($a18c81ba90bd587c$var$createReadableStreamAsyncIterator === undefined) $a18c81ba90bd587c$var$createReadableStreamAsyncIterator = (parcelRequire("5Q095"));
+    return $a18c81ba90bd587c$var$createReadableStreamAsyncIterator(this);
+};
+Object.defineProperty($a18c81ba90bd587c$var$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($a18c81ba90bd587c$var$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($a18c81ba90bd587c$var$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.
+$a18c81ba90bd587c$var$Readable._fromList = $a18c81ba90bd587c$var$fromList;
+Object.defineProperty($a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$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 $a18c81ba90bd587c$var$endReadable(stream) {
+    var state = stream._readableState;
+    $a18c81ba90bd587c$var$debug("endReadable", state.endEmitted);
+    if (!state.endEmitted) {
+        state.ended = true;
+        $gHtSl$nextTick($a18c81ba90bd587c$var$endReadableNT, state, stream);
+    }
+}
+function $a18c81ba90bd587c$var$endReadableNT(state, stream) {
+    $a18c81ba90bd587c$var$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") $a18c81ba90bd587c$var$Readable.from = function(iterable, opts) {
+    if ($a18c81ba90bd587c$var$from === undefined) $a18c81ba90bd587c$var$from = (parcelRequire("3AJhl"));
+    return $a18c81ba90bd587c$var$from($a18c81ba90bd587c$var$Readable, iterable, opts);
+};
+function $a18c81ba90bd587c$var$indexOf(xs, x) {
+    for(var i = 0, l = xs.length; i < l; i++){
+        if (xs[i] === x) return i;
+    }
+    return -1;
+}
+
+});
+parcelRequire.register("47Ymo", function(module, exports) {
+
+module.exports = $gHtSl$EventEmitter;
+
+});
+
+parcelRequire.register("2ueGT", function(module, exports) {
+"use strict";
+
+});
+
+parcelRequire.register("3N6Yx", function(module, exports) {
+"use strict";
+function $2c2b5be471529de8$var$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 $2c2b5be471529de8$var$_objectSpread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        if (i % 2) $2c2b5be471529de8$var$ownKeys(Object(source), true).forEach(function(key) {
+            $2c2b5be471529de8$var$_defineProperty(target, key, source[key]);
+        });
+        else if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+        else $2c2b5be471529de8$var$ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function $2c2b5be471529de8$var$_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 $2c2b5be471529de8$var$_classCallCheck(instance, Constructor) {
+    if (!(instance instanceof Constructor)) throw new TypeError("Cannot call a class as a function");
+}
+function $2c2b5be471529de8$var$_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 $2c2b5be471529de8$var$_createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) $2c2b5be471529de8$var$_defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) $2c2b5be471529de8$var$_defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+
+var $2c2b5be471529de8$var$Buffer = $gHtSl$Buffer;
+
+var $2ueGT = parcelRequire("2ueGT");
+var $2c2b5be471529de8$var$inspect = $2ueGT.inspect;
+var $2c2b5be471529de8$var$custom = $2c2b5be471529de8$var$inspect && $2c2b5be471529de8$var$inspect.custom || "inspect";
+function $2c2b5be471529de8$var$copyBuffer(src, target, offset) {
+    $2c2b5be471529de8$var$Buffer.prototype.copy.call(src, target, offset);
+}
+module.exports = /*#__PURE__*/ function() {
+    function BufferList() {
+        $2c2b5be471529de8$var$_classCallCheck(this, BufferList);
+        this.head = null;
+        this.tail = null;
+        this.length = 0;
+    }
+    $2c2b5be471529de8$var$_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 $2c2b5be471529de8$var$Buffer.alloc(0);
+                var ret = $2c2b5be471529de8$var$Buffer.allocUnsafe(n >>> 0);
+                var p = this.head;
+                var i = 0;
+                while(p){
+                    $2c2b5be471529de8$var$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 = $2c2b5be471529de8$var$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: $2c2b5be471529de8$var$custom,
+            value: function value(_, options) {
+                return $2c2b5be471529de8$var$inspect(this, $2c2b5be471529de8$var$_objectSpread({}, options, {
+                    // Only inspect one level.
+                    depth: 0,
+                    // It should not recurse.
+                    customInspect: false
+                }));
+            }
+        }
+    ]);
+    return BufferList;
+}();
+
+});
+
+parcelRequire.register("dU5xr", function(module, exports) {
+"use strict"; // undocumented cb() API, needed for core, not for public API
+
+function $a1f4cd1ecedd7243$var$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) $gHtSl$nextTick($a1f4cd1ecedd7243$var$emitErrorNT, this, err);
+            else if (!this._writableState.errorEmitted) {
+                this._writableState.errorEmitted = true;
+                $gHtSl$nextTick($a1f4cd1ecedd7243$var$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) $gHtSl$nextTick($a1f4cd1ecedd7243$var$emitErrorAndCloseNT, _this, err);
+            else if (!_this._writableState.errorEmitted) {
+                _this._writableState.errorEmitted = true;
+                $gHtSl$nextTick($a1f4cd1ecedd7243$var$emitErrorAndCloseNT, _this, err);
+            } else $gHtSl$nextTick($a1f4cd1ecedd7243$var$emitCloseNT, _this);
+        } else if (cb) {
+            $gHtSl$nextTick($a1f4cd1ecedd7243$var$emitCloseNT, _this);
+            cb(err);
+        } else $gHtSl$nextTick($a1f4cd1ecedd7243$var$emitCloseNT, _this);
+    });
+    return this;
+}
+function $a1f4cd1ecedd7243$var$emitErrorAndCloseNT(self, err) {
+    $a1f4cd1ecedd7243$var$emitErrorNT(self, err);
+    $a1f4cd1ecedd7243$var$emitCloseNT(self);
+}
+function $a1f4cd1ecedd7243$var$emitCloseNT(self) {
+    if (self._writableState && !self._writableState.emitClose) return;
+    if (self._readableState && !self._readableState.emitClose) return;
+    self.emit("close");
+}
+function $a1f4cd1ecedd7243$var$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 $a1f4cd1ecedd7243$var$emitErrorNT(self, err) {
+    self.emit("error", err);
+}
+function $a1f4cd1ecedd7243$var$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);
+}
+module.exports = {
+    destroy: $a1f4cd1ecedd7243$var$destroy,
+    undestroy: $a1f4cd1ecedd7243$var$undestroy,
+    errorOrDestroy: $a1f4cd1ecedd7243$var$errorOrDestroy
+};
+
+});
+
+parcelRequire.register("eGsJg", function(module, exports) {
+"use strict";
+
+var $6vYby = parcelRequire("6vYby");
+var $ab0b45e6eae1438e$var$ERR_INVALID_OPT_VALUE = $6vYby.codes.ERR_INVALID_OPT_VALUE;
+function $ab0b45e6eae1438e$var$highWaterMarkFrom(options, isDuplex, duplexKey) {
+    return options.highWaterMark != null ? options.highWaterMark : isDuplex ? options[duplexKey] : null;
+}
+function $ab0b45e6eae1438e$var$getHighWaterMark(state, options, duplexKey, isDuplex) {
+    var hwm = $ab0b45e6eae1438e$var$highWaterMarkFrom(options, isDuplex, duplexKey);
+    if (hwm != null) {
+        if (!(isFinite(hwm) && Math.floor(hwm) === hwm) || hwm < 0) {
+            var name = isDuplex ? duplexKey : "highWaterMark";
+            throw new $ab0b45e6eae1438e$var$ERR_INVALID_OPT_VALUE(name, hwm);
+        }
+        return Math.floor(hwm);
+    } // Default value
+    return state.objectMode ? 16 : 16384;
+}
+module.exports = {
+    getHighWaterMark: $ab0b45e6eae1438e$var$getHighWaterMark
+};
+
+});
+parcelRequire.register("6vYby", function(module, exports) {
+
+$parcel$export(module.exports, "codes", function () { return $4be452dd8f02bf99$export$e45cb6485273080e; }, function (v) { return $4be452dd8f02bf99$export$e45cb6485273080e = v; });
+var $4be452dd8f02bf99$export$e45cb6485273080e;
+"use strict";
+function $4be452dd8f02bf99$var$_inheritsLoose(subClass, superClass) {
+    subClass.prototype = Object.create(superClass.prototype);
+    subClass.prototype.constructor = subClass;
+    subClass.__proto__ = superClass;
+}
+var $4be452dd8f02bf99$var$codes = {};
+function $4be452dd8f02bf99$var$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);
+    }
+    var NodeError = /*#__PURE__*/ function(_Base) {
+        $4be452dd8f02bf99$var$_inheritsLoose(NodeError, _Base);
+        function NodeError(arg1, arg2, arg3) {
+            return _Base.call(this, getMessage(arg1, arg2, arg3)) || this;
+        }
+        return NodeError;
+    }(Base);
+    NodeError.prototype.name = Base.name;
+    NodeError.prototype.code = code;
+    $4be452dd8f02bf99$var$codes[code] = NodeError;
+} // https://github.com/nodejs/node/blob/v10.8.0/lib/internal/errors.js
+function $4be452dd8f02bf99$var$oneOf(expected, thing) {
+    if (Array.isArray(expected)) {
+        var len = expected.length;
+        expected = expected.map(function(i) {
+            return String(i);
+        });
+        if (len > 2) return "one of ".concat(thing, " ").concat(expected.slice(0, len - 1).join(", "), ", or ") + expected[len - 1];
+        else if (len === 2) return "one of ".concat(thing, " ").concat(expected[0], " or ").concat(expected[1]);
+        else return "of ".concat(thing, " ").concat(expected[0]);
+    } else return "of ".concat(thing, " ").concat(String(expected));
+} // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith
+function $4be452dd8f02bf99$var$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 $4be452dd8f02bf99$var$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 $4be452dd8f02bf99$var$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;
+}
+$4be452dd8f02bf99$var$createErrorType("ERR_INVALID_OPT_VALUE", function(name, value) {
+    return 'The value "' + value + '" is invalid for option "' + name + '"';
+}, TypeError);
+$4be452dd8f02bf99$var$createErrorType("ERR_INVALID_ARG_TYPE", function(name, expected, actual) {
+    // determiner: 'must be' or 'must not be'
+    var determiner;
+    if (typeof expected === "string" && $4be452dd8f02bf99$var$startsWith(expected, "not ")) {
+        determiner = "must not be";
+        expected = expected.replace(/^not /, "");
+    } else determiner = "must be";
+    var msg;
+    if ($4be452dd8f02bf99$var$endsWith(name, " argument")) // For cases like 'first argument'
+    msg = "The ".concat(name, " ").concat(determiner, " ").concat($4be452dd8f02bf99$var$oneOf(expected, "type"));
+    else {
+        var type = $4be452dd8f02bf99$var$includes(name, ".") ? "property" : "argument";
+        msg = 'The "'.concat(name, '" ').concat(type, " ").concat(determiner, " ").concat($4be452dd8f02bf99$var$oneOf(expected, "type"));
+    }
+    msg += ". Received type ".concat(typeof actual);
+    return msg;
+}, TypeError);
+$4be452dd8f02bf99$var$createErrorType("ERR_STREAM_PUSH_AFTER_EOF", "stream.push() after EOF");
+$4be452dd8f02bf99$var$createErrorType("ERR_METHOD_NOT_IMPLEMENTED", function(name) {
+    return "The " + name + " method is not implemented";
+});
+$4be452dd8f02bf99$var$createErrorType("ERR_STREAM_PREMATURE_CLOSE", "Premature close");
+$4be452dd8f02bf99$var$createErrorType("ERR_STREAM_DESTROYED", function(name) {
+    return "Cannot call " + name + " after a stream was destroyed";
+});
+$4be452dd8f02bf99$var$createErrorType("ERR_MULTIPLE_CALLBACK", "Callback called multiple times");
+$4be452dd8f02bf99$var$createErrorType("ERR_STREAM_CANNOT_PIPE", "Cannot pipe, not readable");
+$4be452dd8f02bf99$var$createErrorType("ERR_STREAM_WRITE_AFTER_END", "write after end");
+$4be452dd8f02bf99$var$createErrorType("ERR_STREAM_NULL_VALUES", "May not write null values to stream", TypeError);
+$4be452dd8f02bf99$var$createErrorType("ERR_UNKNOWN_ENCODING", function(arg) {
+    return "Unknown encoding: " + arg;
+}, TypeError);
+$4be452dd8f02bf99$var$createErrorType("ERR_STREAM_UNSHIFT_AFTER_END_EVENT", "stream.unshift() after end event");
+$4be452dd8f02bf99$export$e45cb6485273080e = $4be452dd8f02bf99$var$codes;
+
+});
+
+
+parcelRequire.register("ghwEg", function(module, exports) {
+if (typeof Object.create === "function") // implementation from standard node.js 'util' module
+module.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+        ctor.super_ = superCtor;
+        ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+                value: ctor,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+    }
+};
+else // old school shim for old browsers
+module.exports = function inherits(ctor, superCtor) {
+    if (superCtor) {
+        ctor.super_ = superCtor;
+        var TempCtor = function() {};
+        TempCtor.prototype = superCtor.prototype;
+        ctor.prototype = new TempCtor();
+        ctor.prototype.constructor = ctor;
+    }
+};
+
+});
+
+parcelRequire.register("cK2wf", function(module, exports) {
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// a duplex stream is just a stream that is both readable and writable.
+// Since JS doesn't have multiple prototypal inheritance, this class
+// prototypally inherits from Readable, and then parasitically from
+// Writable.
+"use strict";
+
+/*<replacement>*/ var $946bbc2642280585$var$objectKeys = Object.keys || function(obj) {
+    var keys = [];
+    for(var key in obj)keys.push(key);
+    return keys;
+};
+/*</replacement>*/ module.exports = $946bbc2642280585$var$Duplex;
+
+var $dRV5p = parcelRequire("dRV5p");
+
+var $8T77c = parcelRequire("8T77c");
+
+(parcelRequire("ghwEg"))($946bbc2642280585$var$Duplex, $dRV5p);
+// Allow the keys array to be GC'ed.
+var $946bbc2642280585$var$keys = $946bbc2642280585$var$objectKeys($8T77c.prototype);
+for(var $946bbc2642280585$var$v = 0; $946bbc2642280585$var$v < $946bbc2642280585$var$keys.length; $946bbc2642280585$var$v++){
+    var $946bbc2642280585$var$method = $946bbc2642280585$var$keys[$946bbc2642280585$var$v];
+    if (!$946bbc2642280585$var$Duplex.prototype[$946bbc2642280585$var$method]) $946bbc2642280585$var$Duplex.prototype[$946bbc2642280585$var$method] = $8T77c.prototype[$946bbc2642280585$var$method];
+}
+function $946bbc2642280585$var$Duplex(options) {
+    if (!(this instanceof $946bbc2642280585$var$Duplex)) return new $946bbc2642280585$var$Duplex(options);
+    $dRV5p.call(this, options);
+    $8T77c.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", $946bbc2642280585$var$onend);
+        }
+    }
+}
+Object.defineProperty($946bbc2642280585$var$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($946bbc2642280585$var$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($946bbc2642280585$var$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 $946bbc2642280585$var$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.
+    $gHtSl$nextTick($946bbc2642280585$var$onEndNT, this);
+}
+function $946bbc2642280585$var$onEndNT(self) {
+    self.end();
+}
+Object.defineProperty($946bbc2642280585$var$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;
+    }
+});
+
+});
+parcelRequire.register("8T77c", function(module, exports) {
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// A bit simpler than readable streams.
+// Implement an async ._write(chunk, encoding, cb), and it'll handle all
+// the drain event emission and buffering.
+"use strict";
+
+module.exports = $6788fab3cd405652$var$Writable;
+/* <replacement> */ function $6788fab3cd405652$var$WriteReq(chunk, encoding, cb) {
+    this.chunk = chunk;
+    this.encoding = encoding;
+    this.callback = cb;
+    this.next = null;
+} // It seems a linked list but it is not
+// there will be only 2 of these for each stream
+function $6788fab3cd405652$var$CorkedRequest(state) {
+    var _this = this;
+    this.next = null;
+    this.entry = null;
+    this.finish = function() {
+        $6788fab3cd405652$var$onCorkedFinish(_this, state);
+    };
+}
+/* </replacement> */ /*<replacement>*/ var $6788fab3cd405652$var$Duplex;
+/*</replacement>*/ $6788fab3cd405652$var$Writable.WritableState = $6788fab3cd405652$var$WritableState;
+
+/*<replacement>*/ var $6788fab3cd405652$var$internalUtil = {
+    deprecate: (parcelRequire("gj4lB"))
+};
+
+var $47Ymo = parcelRequire("47Ymo");
+
+var $6788fab3cd405652$require$Buffer = $gHtSl$Buffer;
+var $6788fab3cd405652$var$OurUint8Array = $parcel$global.Uint8Array || function() {};
+function $6788fab3cd405652$var$_uint8ArrayToBuffer(chunk) {
+    return $6788fab3cd405652$require$Buffer.from(chunk);
+}
+function $6788fab3cd405652$var$_isUint8Array(obj) {
+    return $6788fab3cd405652$require$Buffer.isBuffer(obj) || obj instanceof $6788fab3cd405652$var$OurUint8Array;
+}
+
+var $dU5xr = parcelRequire("dU5xr");
+
+var $eGsJg = parcelRequire("eGsJg");
+var $6788fab3cd405652$var$getHighWaterMark = $eGsJg.getHighWaterMark;
+
+var $6vYby = parcelRequire("6vYby");
+var $6788fab3cd405652$require$_require$codes = $6vYby.codes;
+var $6788fab3cd405652$var$ERR_INVALID_ARG_TYPE = $6788fab3cd405652$require$_require$codes.ERR_INVALID_ARG_TYPE, $6788fab3cd405652$var$ERR_METHOD_NOT_IMPLEMENTED = $6788fab3cd405652$require$_require$codes.ERR_METHOD_NOT_IMPLEMENTED, $6788fab3cd405652$var$ERR_MULTIPLE_CALLBACK = $6788fab3cd405652$require$_require$codes.ERR_MULTIPLE_CALLBACK, $6788fab3cd405652$var$ERR_STREAM_CANNOT_PIPE = $6788fab3cd405652$require$_require$codes.ERR_STREAM_CANNOT_PIPE, $6788fab3cd405652$var$ERR_STREAM_DESTROYED = $6788fab3cd405652$require$_require$codes.ERR_STREAM_DESTROYED, $6788fab3cd405652$var$ERR_STREAM_NULL_VALUES = $6788fab3cd405652$require$_require$codes.ERR_STREAM_NULL_VALUES, $6788fab3cd405652$var$ERR_STREAM_WRITE_AFTER_END = $6788fab3cd405652$require$_require$codes.ERR_STREAM_WRITE_AFTER_END, $6788fab3cd405652$var$ERR_UNKNOWN_ENCODING = $6788fab3cd405652$require$_require$codes.ERR_UNKNOWN_ENCODING;
+var $6788fab3cd405652$var$errorOrDestroy = $dU5xr.errorOrDestroy;
+
+(parcelRequire("ghwEg"))($6788fab3cd405652$var$Writable, $47Ymo);
+function $6788fab3cd405652$var$nop() {}
+
+function $6788fab3cd405652$var$WritableState(options, stream, isDuplex) {
+    $6788fab3cd405652$var$Duplex = $6788fab3cd405652$var$Duplex || (parcelRequire("cK2wf"));
+    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 $6788fab3cd405652$var$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 = $6788fab3cd405652$var$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) {
+        $6788fab3cd405652$var$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 $6788fab3cd405652$var$CorkedRequest(this);
+}
+$6788fab3cd405652$var$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($6788fab3cd405652$var$WritableState.prototype, "buffer", {
+            get: $6788fab3cd405652$var$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 $6788fab3cd405652$var$realHasInstance;
+if (typeof Symbol === "function" && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === "function") {
+    $6788fab3cd405652$var$realHasInstance = Function.prototype[Symbol.hasInstance];
+    Object.defineProperty($6788fab3cd405652$var$Writable, Symbol.hasInstance, {
+        value: function value(object) {
+            if ($6788fab3cd405652$var$realHasInstance.call(this, object)) return true;
+            if (this !== $6788fab3cd405652$var$Writable) return false;
+            return object && object._writableState instanceof $6788fab3cd405652$var$WritableState;
+        }
+    });
+} else $6788fab3cd405652$var$realHasInstance = function realHasInstance(object) {
+    return object instanceof this;
+};
+
+function $6788fab3cd405652$var$Writable(options) {
+    $6788fab3cd405652$var$Duplex = $6788fab3cd405652$var$Duplex || (parcelRequire("cK2wf")); // 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 $6788fab3cd405652$var$Duplex;
+    if (!isDuplex && !$6788fab3cd405652$var$realHasInstance.call($6788fab3cd405652$var$Writable, this)) return new $6788fab3cd405652$var$Writable(options);
+    this._writableState = new $6788fab3cd405652$var$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;
+    }
+    $47Ymo.call(this);
+} // Otherwise people can pipe Writable streams, which is just wrong.
+$6788fab3cd405652$var$Writable.prototype.pipe = function() {
+    $6788fab3cd405652$var$errorOrDestroy(this, new $6788fab3cd405652$var$ERR_STREAM_CANNOT_PIPE());
+};
+function $6788fab3cd405652$var$writeAfterEnd(stream, cb) {
+    var er = new $6788fab3cd405652$var$ERR_STREAM_WRITE_AFTER_END(); // TODO: defer error events consistently everywhere, not just the cb
+    $6788fab3cd405652$var$errorOrDestroy(stream, er);
+    $gHtSl$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 $6788fab3cd405652$var$validChunk(stream, state, chunk, cb) {
+    var er;
+    if (chunk === null) er = new $6788fab3cd405652$var$ERR_STREAM_NULL_VALUES();
+    else if (typeof chunk !== "string" && !state.objectMode) er = new $6788fab3cd405652$var$ERR_INVALID_ARG_TYPE("chunk", [
+        "string",
+        "Buffer"
+    ], chunk);
+    if (er) {
+        $6788fab3cd405652$var$errorOrDestroy(stream, er);
+        $gHtSl$nextTick(cb, er);
+        return false;
+    }
+    return true;
+}
+$6788fab3cd405652$var$Writable.prototype.write = function(chunk, encoding, cb) {
+    var state = this._writableState;
+    var ret = false;
+    var isBuf = !state.objectMode && $6788fab3cd405652$var$_isUint8Array(chunk);
+    if (isBuf && !$6788fab3cd405652$require$Buffer.isBuffer(chunk)) chunk = $6788fab3cd405652$var$_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 = $6788fab3cd405652$var$nop;
+    if (state.ending) $6788fab3cd405652$var$writeAfterEnd(this, cb);
+    else if (isBuf || $6788fab3cd405652$var$validChunk(this, state, chunk, cb)) {
+        state.pendingcb++;
+        ret = $6788fab3cd405652$var$writeOrBuffer(this, state, isBuf, chunk, encoding, cb);
+    }
+    return ret;
+};
+$6788fab3cd405652$var$Writable.prototype.cork = function() {
+    this._writableState.corked++;
+};
+$6788fab3cd405652$var$Writable.prototype.uncork = function() {
+    var state = this._writableState;
+    if (state.corked) {
+        state.corked--;
+        if (!state.writing && !state.corked && !state.bufferProcessing && state.bufferedRequest) $6788fab3cd405652$var$clearBuffer(this, state);
+    }
+};
+$6788fab3cd405652$var$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 $6788fab3cd405652$var$ERR_UNKNOWN_ENCODING(encoding);
+    this._writableState.defaultEncoding = encoding;
+    return this;
+};
+Object.defineProperty($6788fab3cd405652$var$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 $6788fab3cd405652$var$decodeChunk(state, chunk, encoding) {
+    if (!state.objectMode && state.decodeStrings !== false && typeof chunk === "string") chunk = $6788fab3cd405652$require$Buffer.from(chunk, encoding);
+    return chunk;
+}
+Object.defineProperty($6788fab3cd405652$var$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 $6788fab3cd405652$var$writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {
+    if (!isBuf) {
+        var newChunk = $6788fab3cd405652$var$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 $6788fab3cd405652$var$doWrite(stream, state, false, len, chunk, encoding, cb);
+    return ret;
+}
+function $6788fab3cd405652$var$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 $6788fab3cd405652$var$ERR_STREAM_DESTROYED("write"));
+    else if (writev) stream._writev(chunk, state.onwrite);
+    else stream._write(chunk, encoding, state.onwrite);
+    state.sync = false;
+}
+function $6788fab3cd405652$var$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
+        $gHtSl$nextTick(cb, er); // this can emit finish, and it will always happen
+        // after error
+        $gHtSl$nextTick($6788fab3cd405652$var$finishMaybe, stream, state);
+        stream._writableState.errorEmitted = true;
+        $6788fab3cd405652$var$errorOrDestroy(stream, er);
+    } else {
+        // the caller expect this to happen before if
+        // it is async
+        cb(er);
+        stream._writableState.errorEmitted = true;
+        $6788fab3cd405652$var$errorOrDestroy(stream, er); // this can emit finish, but finish must
+        // always follow error
+        $6788fab3cd405652$var$finishMaybe(stream, state);
+    }
+}
+function $6788fab3cd405652$var$onwriteStateUpdate(state) {
+    state.writing = false;
+    state.writecb = null;
+    state.length -= state.writelen;
+    state.writelen = 0;
+}
+function $6788fab3cd405652$var$onwrite(stream, er) {
+    var state = stream._writableState;
+    var sync = state.sync;
+    var cb = state.writecb;
+    if (typeof cb !== "function") throw new $6788fab3cd405652$var$ERR_MULTIPLE_CALLBACK();
+    $6788fab3cd405652$var$onwriteStateUpdate(state);
+    if (er) $6788fab3cd405652$var$onwriteError(stream, state, sync, er, cb);
+    else {
+        // Check if we're actually ready to finish, but don't emit yet
+        var finished = $6788fab3cd405652$var$needFinish(state) || stream.destroyed;
+        if (!finished && !state.corked && !state.bufferProcessing && state.bufferedRequest) $6788fab3cd405652$var$clearBuffer(stream, state);
+        if (sync) $gHtSl$nextTick($6788fab3cd405652$var$afterWrite, stream, state, finished, cb);
+        else $6788fab3cd405652$var$afterWrite(stream, state, finished, cb);
+    }
+}
+function $6788fab3cd405652$var$afterWrite(stream, state, finished, cb) {
+    if (!finished) $6788fab3cd405652$var$onwriteDrain(stream, state);
+    state.pendingcb--;
+    cb();
+    $6788fab3cd405652$var$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 $6788fab3cd405652$var$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 $6788fab3cd405652$var$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;
+        $6788fab3cd405652$var$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 $6788fab3cd405652$var$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;
+            $6788fab3cd405652$var$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;
+}
+$6788fab3cd405652$var$Writable.prototype._write = function(chunk, encoding, cb) {
+    cb(new $6788fab3cd405652$var$ERR_METHOD_NOT_IMPLEMENTED("_write()"));
+};
+$6788fab3cd405652$var$Writable.prototype._writev = null;
+$6788fab3cd405652$var$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) $6788fab3cd405652$var$endWritable(this, state, cb);
+    return this;
+};
+Object.defineProperty($6788fab3cd405652$var$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 $6788fab3cd405652$var$needFinish(state) {
+    return state.ending && state.length === 0 && state.bufferedRequest === null && !state.finished && !state.writing;
+}
+function $6788fab3cd405652$var$callFinal(stream, state) {
+    stream._final(function(err) {
+        state.pendingcb--;
+        if (err) $6788fab3cd405652$var$errorOrDestroy(stream, err);
+        state.prefinished = true;
+        stream.emit("prefinish");
+        $6788fab3cd405652$var$finishMaybe(stream, state);
+    });
+}
+function $6788fab3cd405652$var$prefinish(stream, state) {
+    if (!state.prefinished && !state.finalCalled) {
+        if (typeof stream._final === "function" && !state.destroyed) {
+            state.pendingcb++;
+            state.finalCalled = true;
+            $gHtSl$nextTick($6788fab3cd405652$var$callFinal, stream, state);
+        } else {
+            state.prefinished = true;
+            stream.emit("prefinish");
+        }
+    }
+}
+function $6788fab3cd405652$var$finishMaybe(stream, state) {
+    var need = $6788fab3cd405652$var$needFinish(state);
+    if (need) {
+        $6788fab3cd405652$var$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 $6788fab3cd405652$var$endWritable(stream, state, cb) {
+    state.ending = true;
+    $6788fab3cd405652$var$finishMaybe(stream, state);
+    if (cb) {
+        if (state.finished) $gHtSl$nextTick(cb);
+        else stream.once("finish", cb);
+    }
+    state.ended = true;
+    stream.writable = false;
+}
+function $6788fab3cd405652$var$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($6788fab3cd405652$var$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;
+    }
+});
+$6788fab3cd405652$var$Writable.prototype.destroy = $dU5xr.destroy;
+$6788fab3cd405652$var$Writable.prototype._undestroy = $dU5xr.undestroy;
+$6788fab3cd405652$var$Writable.prototype._destroy = function(err, cb) {
+    cb(err);
+};
+
+});
+parcelRequire.register("gj4lB", function(module, exports) {
+/**
+ * Module exports.
+ */ module.exports = $bdf1cafec9128d38$var$deprecate;
+/**
+ * Mark that a method should not be used.
+ * Returns a modified function which warns once by default.
+ *
+ * If `localStorage.noDeprecation = true` is set, then it is a no-op.
+ *
+ * If `localStorage.throwDeprecation = true` is set, then deprecated functions
+ * will throw an Error when invoked.
+ *
+ * If `localStorage.traceDeprecation = true` is set, then deprecated functions
+ * will invoke `console.trace()` instead of `console.error()`.
+ *
+ * @param {Function} fn - the function to deprecate
+ * @param {String} msg - the string to print to the console when `fn` is invoked
+ * @returns {Function} a new "deprecated" version of `fn`
+ * @api public
+ */ function $bdf1cafec9128d38$var$deprecate(fn, msg) {
+    if ($bdf1cafec9128d38$var$config("noDeprecation")) return fn;
+    var warned = false;
+    function deprecated() {
+        if (!warned) {
+            if ($bdf1cafec9128d38$var$config("throwDeprecation")) throw new Error(msg);
+            else if ($bdf1cafec9128d38$var$config("traceDeprecation")) console.trace(msg);
+            else console.warn(msg);
+            warned = true;
+        }
+        return fn.apply(this, arguments);
+    }
+    return deprecated;
+}
+/**
+ * Checks `localStorage` for boolean values for the given `name`.
+ *
+ * @param {String} name
+ * @returns {Boolean}
+ * @api private
+ */ function $bdf1cafec9128d38$var$config(name) {
+    // accessing global.localStorage can trigger a DOMException in sandboxed iframes
+    try {
+        if (!$parcel$global.localStorage) return false;
+    } catch (_) {
+        return false;
+    }
+    var val = $parcel$global.localStorage[name];
+    if (null == val) return false;
+    return String(val).toLowerCase() === "true";
+}
+
+});
+
+
+
+parcelRequire.register("aCyUD", function(module, exports) {
+
+$parcel$export(module.exports, "StringDecoder", function () { return $7bb888e688ae7644$export$63a7aa211a91ed69; }, function (v) { return $7bb888e688ae7644$export$63a7aa211a91ed69 = v; });
+// StringDecoder provides an interface for efficiently splitting a series of
+// buffers into a series of JS strings without breaking apart multi-byte
+// characters.
+var $7bb888e688ae7644$export$63a7aa211a91ed69;
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+"use strict";
+
+var $4MS1v = parcelRequire("4MS1v");
+var $7bb888e688ae7644$require$Buffer = $4MS1v.Buffer;
+/*</replacement>*/ var $7bb888e688ae7644$var$isEncoding = $7bb888e688ae7644$require$Buffer.isEncoding || function(encoding) {
+    encoding = "" + encoding;
+    switch(encoding && encoding.toLowerCase()){
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+        case "raw":
+            return true;
+        default:
+            return false;
+    }
+};
+function $7bb888e688ae7644$var$_normalizeEncoding(enc) {
+    if (!enc) return "utf8";
+    var retried;
+    while(true)switch(enc){
+        case "utf8":
+        case "utf-8":
+            return "utf8";
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+            return "utf16le";
+        case "latin1":
+        case "binary":
+            return "latin1";
+        case "base64":
+        case "ascii":
+        case "hex":
+            return enc;
+        default:
+            if (retried) return; // undefined
+            enc = ("" + enc).toLowerCase();
+            retried = true;
+    }
+}
+// Do not cache `Buffer.isEncoding` when checking encoding names as some
+// modules monkey-patch it to support additional encodings
+function $7bb888e688ae7644$var$normalizeEncoding(enc) {
+    var nenc = $7bb888e688ae7644$var$_normalizeEncoding(enc);
+    if (typeof nenc !== "string" && ($7bb888e688ae7644$require$Buffer.isEncoding === $7bb888e688ae7644$var$isEncoding || !$7bb888e688ae7644$var$isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
+    return nenc || enc;
+}
+$7bb888e688ae7644$export$63a7aa211a91ed69 = $7bb888e688ae7644$var$StringDecoder;
+function $7bb888e688ae7644$var$StringDecoder(encoding) {
+    this.encoding = $7bb888e688ae7644$var$normalizeEncoding(encoding);
+    var nb;
+    switch(this.encoding){
+        case "utf16le":
+            this.text = $7bb888e688ae7644$var$utf16Text;
+            this.end = $7bb888e688ae7644$var$utf16End;
+            nb = 4;
+            break;
+        case "utf8":
+            this.fillLast = $7bb888e688ae7644$var$utf8FillLast;
+            nb = 4;
+            break;
+        case "base64":
+            this.text = $7bb888e688ae7644$var$base64Text;
+            this.end = $7bb888e688ae7644$var$base64End;
+            nb = 3;
+            break;
+        default:
+            this.write = $7bb888e688ae7644$var$simpleWrite;
+            this.end = $7bb888e688ae7644$var$simpleEnd;
+            return;
+    }
+    this.lastNeed = 0;
+    this.lastTotal = 0;
+    this.lastChar = $7bb888e688ae7644$require$Buffer.allocUnsafe(nb);
+}
+$7bb888e688ae7644$var$StringDecoder.prototype.write = function(buf) {
+    if (buf.length === 0) return "";
+    var r;
+    var i;
+    if (this.lastNeed) {
+        r = this.fillLast(buf);
+        if (r === undefined) return "";
+        i = this.lastNeed;
+        this.lastNeed = 0;
+    } else i = 0;
+    if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
+    return r || "";
+};
+$7bb888e688ae7644$var$StringDecoder.prototype.end = $7bb888e688ae7644$var$utf8End;
+// Returns only complete characters in a Buffer
+$7bb888e688ae7644$var$StringDecoder.prototype.text = $7bb888e688ae7644$var$utf8Text;
+// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer
+$7bb888e688ae7644$var$StringDecoder.prototype.fillLast = function(buf) {
+    if (this.lastNeed <= buf.length) {
+        buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
+        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    }
+    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
+    this.lastNeed -= buf.length;
+};
+// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a
+// continuation byte. If an invalid byte is detected, -2 is returned.
+function $7bb888e688ae7644$var$utf8CheckByte(byte) {
+    if (byte <= 0x7F) return 0;
+    else if (byte >> 5 === 0x06) return 2;
+    else if (byte >> 4 === 0x0E) return 3;
+    else if (byte >> 3 === 0x1E) return 4;
+    return byte >> 6 === 0x02 ? -1 : -2;
+}
+// Checks at most 3 bytes at the end of a Buffer in order to detect an
+// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)
+// needed to complete the UTF-8 character (if applicable) are returned.
+function $7bb888e688ae7644$var$utf8CheckIncomplete(self, buf, i) {
+    var j = buf.length - 1;
+    if (j < i) return 0;
+    var nb = $7bb888e688ae7644$var$utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+        if (nb > 0) self.lastNeed = nb - 1;
+        return nb;
+    }
+    if (--j < i || nb === -2) return 0;
+    nb = $7bb888e688ae7644$var$utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+        if (nb > 0) self.lastNeed = nb - 2;
+        return nb;
+    }
+    if (--j < i || nb === -2) return 0;
+    nb = $7bb888e688ae7644$var$utf8CheckByte(buf[j]);
+    if (nb >= 0) {
+        if (nb > 0) {
+            if (nb === 2) nb = 0;
+            else self.lastNeed = nb - 3;
+        }
+        return nb;
+    }
+    return 0;
+}
+// Validates as many continuation bytes for a multi-byte UTF-8 character as
+// needed or are available. If we see a non-continuation byte where we expect
+// one, we "replace" the validated continuation bytes we've seen so far with
+// a single UTF-8 replacement character ('\ufffd'), to match v8's UTF-8 decoding
+// behavior. The continuation byte check is included three times in the case
+// where all of the continuation bytes for a character exist in the same buffer.
+// It is also done this way as a slight performance increase instead of using a
+// loop.
+function $7bb888e688ae7644$var$utf8CheckExtraBytes(self, buf, p) {
+    if ((buf[0] & 0xC0) !== 0x80) {
+        self.lastNeed = 0;
+        return "�";
+    }
+    if (self.lastNeed > 1 && buf.length > 1) {
+        if ((buf[1] & 0xC0) !== 0x80) {
+            self.lastNeed = 1;
+            return "�";
+        }
+        if (self.lastNeed > 2 && buf.length > 2) {
+            if ((buf[2] & 0xC0) !== 0x80) {
+                self.lastNeed = 2;
+                return "�";
+            }
+        }
+    }
+}
+// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.
+function $7bb888e688ae7644$var$utf8FillLast(buf) {
+    var p = this.lastTotal - this.lastNeed;
+    var r = $7bb888e688ae7644$var$utf8CheckExtraBytes(this, buf, p);
+    if (r !== undefined) return r;
+    if (this.lastNeed <= buf.length) {
+        buf.copy(this.lastChar, p, 0, this.lastNeed);
+        return this.lastChar.toString(this.encoding, 0, this.lastTotal);
+    }
+    buf.copy(this.lastChar, p, 0, buf.length);
+    this.lastNeed -= buf.length;
+}
+// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a
+// partial character, the character's bytes are buffered until the required
+// number of bytes are available.
+function $7bb888e688ae7644$var$utf8Text(buf, i) {
+    var total = $7bb888e688ae7644$var$utf8CheckIncomplete(this, buf, i);
+    if (!this.lastNeed) return buf.toString("utf8", i);
+    this.lastTotal = total;
+    var end = buf.length - (total - this.lastNeed);
+    buf.copy(this.lastChar, 0, end);
+    return buf.toString("utf8", i, end);
+}
+// For UTF-8, a replacement character is added when ending on a partial
+// character.
+function $7bb888e688ae7644$var$utf8End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) return r + "�";
+    return r;
+}
+// UTF-16LE typically needs two bytes per character, but even if we have an even
+// number of bytes available, we need to check if we end on a leading/high
+// surrogate. In that case, we need to wait for the next two bytes in order to
+// decode the last character properly.
+function $7bb888e688ae7644$var$utf16Text(buf, i) {
+    if ((buf.length - i) % 2 === 0) {
+        var r = buf.toString("utf16le", i);
+        if (r) {
+            var c = r.charCodeAt(r.length - 1);
+            if (c >= 0xD800 && c <= 0xDBFF) {
+                this.lastNeed = 2;
+                this.lastTotal = 4;
+                this.lastChar[0] = buf[buf.length - 2];
+                this.lastChar[1] = buf[buf.length - 1];
+                return r.slice(0, -1);
+            }
+        }
+        return r;
+    }
+    this.lastNeed = 1;
+    this.lastTotal = 2;
+    this.lastChar[0] = buf[buf.length - 1];
+    return buf.toString("utf16le", i, buf.length - 1);
+}
+// For UTF-16LE we do not explicitly append special replacement characters if we
+// end on a partial character, we simply let v8 handle that.
+function $7bb888e688ae7644$var$utf16End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) {
+        var end = this.lastTotal - this.lastNeed;
+        return r + this.lastChar.toString("utf16le", 0, end);
+    }
+    return r;
+}
+function $7bb888e688ae7644$var$base64Text(buf, i) {
+    var n = (buf.length - i) % 3;
+    if (n === 0) return buf.toString("base64", i);
+    this.lastNeed = 3 - n;
+    this.lastTotal = 3;
+    if (n === 1) this.lastChar[0] = buf[buf.length - 1];
+    else {
+        this.lastChar[0] = buf[buf.length - 2];
+        this.lastChar[1] = buf[buf.length - 1];
+    }
+    return buf.toString("base64", i, buf.length - n);
+}
+function $7bb888e688ae7644$var$base64End(buf) {
+    var r = buf && buf.length ? this.write(buf) : "";
+    if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
+    return r;
+}
+// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)
+function $7bb888e688ae7644$var$simpleWrite(buf) {
+    return buf.toString(this.encoding);
+}
+function $7bb888e688ae7644$var$simpleEnd(buf) {
+    return buf && buf.length ? this.write(buf) : "";
+}
+
+});
+parcelRequire.register("4MS1v", function(module, exports) {
+
+var $37c58d00832292ca$var$Buffer = $gHtSl$buffer.Buffer;
+// alternative to using Object.keys for old browsers
+function $37c58d00832292ca$var$copyProps(src, dst) {
+    for(var key in src)dst[key] = src[key];
+}
+if ($37c58d00832292ca$var$Buffer.from && $37c58d00832292ca$var$Buffer.alloc && $37c58d00832292ca$var$Buffer.allocUnsafe && $37c58d00832292ca$var$Buffer.allocUnsafeSlow) module.exports = $gHtSl$buffer;
+else {
+    // Copy properties from require('buffer')
+    $37c58d00832292ca$var$copyProps($gHtSl$buffer, module.exports);
+    module.exports.Buffer = $37c58d00832292ca$var$SafeBuffer;
+}
+function $37c58d00832292ca$var$SafeBuffer(arg, encodingOrOffset, length) {
+    return $37c58d00832292ca$var$Buffer(arg, encodingOrOffset, length);
+}
+$37c58d00832292ca$var$SafeBuffer.prototype = Object.create($37c58d00832292ca$var$Buffer.prototype);
+// Copy static methods from Buffer
+$37c58d00832292ca$var$copyProps($37c58d00832292ca$var$Buffer, $37c58d00832292ca$var$SafeBuffer);
+$37c58d00832292ca$var$SafeBuffer.from = function(arg, encodingOrOffset, length) {
+    if (typeof arg === "number") throw new TypeError("Argument must not be a number");
+    return $37c58d00832292ca$var$Buffer(arg, encodingOrOffset, length);
+};
+$37c58d00832292ca$var$SafeBuffer.alloc = function(size, fill, encoding) {
+    if (typeof size !== "number") throw new TypeError("Argument must be a number");
+    var buf = $37c58d00832292ca$var$Buffer(size);
+    if (fill !== undefined) {
+        if (typeof encoding === "string") buf.fill(fill, encoding);
+        else buf.fill(fill);
+    } else buf.fill(0);
+    return buf;
+};
+$37c58d00832292ca$var$SafeBuffer.allocUnsafe = function(size) {
+    if (typeof size !== "number") throw new TypeError("Argument must be a number");
+    return $37c58d00832292ca$var$Buffer(size);
+};
+$37c58d00832292ca$var$SafeBuffer.allocUnsafeSlow = function(size) {
+    if (typeof size !== "number") throw new TypeError("Argument must be a number");
+    return $gHtSl$buffer.SlowBuffer(size);
+};
+
+});
+
+
+parcelRequire.register("5Q095", function(module, exports) {
+"use strict";
+
+var $4401ec01a5b39b8a$var$_Object$setPrototypeO;
+function $4401ec01a5b39b8a$var$_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 $7wU83 = parcelRequire("7wU83");
+var $4401ec01a5b39b8a$var$kLastResolve = Symbol("lastResolve");
+var $4401ec01a5b39b8a$var$kLastReject = Symbol("lastReject");
+var $4401ec01a5b39b8a$var$kError = Symbol("error");
+var $4401ec01a5b39b8a$var$kEnded = Symbol("ended");
+var $4401ec01a5b39b8a$var$kLastPromise = Symbol("lastPromise");
+var $4401ec01a5b39b8a$var$kHandlePromise = Symbol("handlePromise");
+var $4401ec01a5b39b8a$var$kStream = Symbol("stream");
+function $4401ec01a5b39b8a$var$createIterResult(value, done) {
+    return {
+        value: value,
+        done: done
+    };
+}
+function $4401ec01a5b39b8a$var$readAndResolve(iter) {
+    var resolve = iter[$4401ec01a5b39b8a$var$kLastResolve];
+    if (resolve !== null) {
+        var data = iter[$4401ec01a5b39b8a$var$kStream].read(); // we defer if data is null
+        // we can be expecting either 'end' or
+        // 'error'
+        if (data !== null) {
+            iter[$4401ec01a5b39b8a$var$kLastPromise] = null;
+            iter[$4401ec01a5b39b8a$var$kLastResolve] = null;
+            iter[$4401ec01a5b39b8a$var$kLastReject] = null;
+            resolve($4401ec01a5b39b8a$var$createIterResult(data, false));
+        }
+    }
+}
+function $4401ec01a5b39b8a$var$onReadable(iter) {
+    // we wait for the next tick, because it might
+    // emit an error with process.nextTick
+    $gHtSl$nextTick($4401ec01a5b39b8a$var$readAndResolve, iter);
+}
+function $4401ec01a5b39b8a$var$wrapForNext(lastPromise, iter) {
+    return function(resolve, reject) {
+        lastPromise.then(function() {
+            if (iter[$4401ec01a5b39b8a$var$kEnded]) {
+                resolve($4401ec01a5b39b8a$var$createIterResult(undefined, true));
+                return;
+            }
+            iter[$4401ec01a5b39b8a$var$kHandlePromise](resolve, reject);
+        }, reject);
+    };
+}
+var $4401ec01a5b39b8a$var$AsyncIteratorPrototype = Object.getPrototypeOf(function() {});
+var $4401ec01a5b39b8a$var$ReadableStreamAsyncIteratorPrototype = Object.setPrototypeOf(($4401ec01a5b39b8a$var$_Object$setPrototypeO = {
+    get stream () {
+        return this[$4401ec01a5b39b8a$var$kStream];
+    },
+    next: function next() {
+        var _this = this;
+        // if we have detected an error in the meanwhile
+        // reject straight away
+        var error = this[$4401ec01a5b39b8a$var$kError];
+        if (error !== null) return Promise.reject(error);
+        if (this[$4401ec01a5b39b8a$var$kEnded]) return Promise.resolve($4401ec01a5b39b8a$var$createIterResult(undefined, true));
+        if (this[$4401ec01a5b39b8a$var$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) {
+            $gHtSl$nextTick(function() {
+                if (_this[$4401ec01a5b39b8a$var$kError]) reject(_this[$4401ec01a5b39b8a$var$kError]);
+                else resolve($4401ec01a5b39b8a$var$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[$4401ec01a5b39b8a$var$kLastPromise];
+        var promise;
+        if (lastPromise) promise = new Promise($4401ec01a5b39b8a$var$wrapForNext(lastPromise, this));
+        else {
+            // fast path needed to support multiple this.push()
+            // without triggering the next() queue
+            var data = this[$4401ec01a5b39b8a$var$kStream].read();
+            if (data !== null) return Promise.resolve($4401ec01a5b39b8a$var$createIterResult(data, false));
+            promise = new Promise(this[$4401ec01a5b39b8a$var$kHandlePromise]);
+        }
+        this[$4401ec01a5b39b8a$var$kLastPromise] = promise;
+        return promise;
+    }
+}, $4401ec01a5b39b8a$var$_defineProperty($4401ec01a5b39b8a$var$_Object$setPrototypeO, Symbol.asyncIterator, function() {
+    return this;
+}), $4401ec01a5b39b8a$var$_defineProperty($4401ec01a5b39b8a$var$_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[$4401ec01a5b39b8a$var$kStream].destroy(null, function(err) {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve($4401ec01a5b39b8a$var$createIterResult(undefined, true));
+        });
+    });
+}), $4401ec01a5b39b8a$var$_Object$setPrototypeO), $4401ec01a5b39b8a$var$AsyncIteratorPrototype);
+var $4401ec01a5b39b8a$var$createReadableStreamAsyncIterator = function createReadableStreamAsyncIterator(stream) {
+    var _Object$create;
+    var iterator = Object.create($4401ec01a5b39b8a$var$ReadableStreamAsyncIteratorPrototype, (_Object$create = {}, $4401ec01a5b39b8a$var$_defineProperty(_Object$create, $4401ec01a5b39b8a$var$kStream, {
+        value: stream,
+        writable: true
+    }), $4401ec01a5b39b8a$var$_defineProperty(_Object$create, $4401ec01a5b39b8a$var$kLastResolve, {
+        value: null,
+        writable: true
+    }), $4401ec01a5b39b8a$var$_defineProperty(_Object$create, $4401ec01a5b39b8a$var$kLastReject, {
+        value: null,
+        writable: true
+    }), $4401ec01a5b39b8a$var$_defineProperty(_Object$create, $4401ec01a5b39b8a$var$kError, {
+        value: null,
+        writable: true
+    }), $4401ec01a5b39b8a$var$_defineProperty(_Object$create, $4401ec01a5b39b8a$var$kEnded, {
+        value: stream._readableState.endEmitted,
+        writable: true
+    }), $4401ec01a5b39b8a$var$_defineProperty(_Object$create, $4401ec01a5b39b8a$var$kHandlePromise, {
+        value: function value(resolve, reject) {
+            var data = iterator[$4401ec01a5b39b8a$var$kStream].read();
+            if (data) {
+                iterator[$4401ec01a5b39b8a$var$kLastPromise] = null;
+                iterator[$4401ec01a5b39b8a$var$kLastResolve] = null;
+                iterator[$4401ec01a5b39b8a$var$kLastReject] = null;
+                resolve($4401ec01a5b39b8a$var$createIterResult(data, false));
+            } else {
+                iterator[$4401ec01a5b39b8a$var$kLastResolve] = resolve;
+                iterator[$4401ec01a5b39b8a$var$kLastReject] = reject;
+            }
+        },
+        writable: true
+    }), _Object$create));
+    iterator[$4401ec01a5b39b8a$var$kLastPromise] = null;
+    $7wU83(stream, function(err) {
+        if (err && err.code !== "ERR_STREAM_PREMATURE_CLOSE") {
+            var reject = iterator[$4401ec01a5b39b8a$var$kLastReject]; // reject if we are waiting for data in the Promise
+            // returned by next() and store the error
+            if (reject !== null) {
+                iterator[$4401ec01a5b39b8a$var$kLastPromise] = null;
+                iterator[$4401ec01a5b39b8a$var$kLastResolve] = null;
+                iterator[$4401ec01a5b39b8a$var$kLastReject] = null;
+                reject(err);
+            }
+            iterator[$4401ec01a5b39b8a$var$kError] = err;
+            return;
+        }
+        var resolve = iterator[$4401ec01a5b39b8a$var$kLastResolve];
+        if (resolve !== null) {
+            iterator[$4401ec01a5b39b8a$var$kLastPromise] = null;
+            iterator[$4401ec01a5b39b8a$var$kLastResolve] = null;
+            iterator[$4401ec01a5b39b8a$var$kLastReject] = null;
+            resolve($4401ec01a5b39b8a$var$createIterResult(undefined, true));
+        }
+        iterator[$4401ec01a5b39b8a$var$kEnded] = true;
+    });
+    stream.on("readable", $4401ec01a5b39b8a$var$onReadable.bind(null, iterator));
+    return iterator;
+};
+module.exports = $4401ec01a5b39b8a$var$createReadableStreamAsyncIterator;
+
+});
+parcelRequire.register("7wU83", function(module, exports) {
+// Ported from https://github.com/mafintosh/end-of-stream with
+// permission from the author, Mathias Buus (@mafintosh).
+"use strict";
+
+var $6vYby = parcelRequire("6vYby");
+var $57b70f9bbfbf8638$var$ERR_STREAM_PREMATURE_CLOSE = $6vYby.codes.ERR_STREAM_PREMATURE_CLOSE;
+function $57b70f9bbfbf8638$var$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 $57b70f9bbfbf8638$var$noop() {}
+function $57b70f9bbfbf8638$var$isRequest(stream) {
+    return stream.setHeader && typeof stream.abort === "function";
+}
+function $57b70f9bbfbf8638$var$eos(stream, opts, callback) {
+    if (typeof opts === "function") return $57b70f9bbfbf8638$var$eos(stream, null, opts);
+    if (!opts) opts = {};
+    callback = $57b70f9bbfbf8638$var$once(callback || $57b70f9bbfbf8638$var$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 $57b70f9bbfbf8638$var$ERR_STREAM_PREMATURE_CLOSE();
+            return callback.call(stream, err);
+        }
+        if (writable && !writableEnded) {
+            if (!stream._writableState || !stream._writableState.ended) err = new $57b70f9bbfbf8638$var$ERR_STREAM_PREMATURE_CLOSE();
+            return callback.call(stream, err);
+        }
+    };
+    var onrequest = function onrequest() {
+        stream.req.on("finish", onfinish);
+    };
+    if ($57b70f9bbfbf8638$var$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);
+    };
+}
+module.exports = $57b70f9bbfbf8638$var$eos;
+
+});
+
+
+parcelRequire.register("3AJhl", function(module, exports) {
+module.exports = function() {
+    throw new Error("Readable.from is not available in the browser");
+};
+
+});
+
+
+parcelRequire.register("az4hH", function(module, exports) {
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// a transform stream is a readable/writable stream where you do
+// something with the data.  Sometimes it's called a "filter",
+// but that's not a great name for it, since that implies a thing where
+// some bits pass through, and others are simply ignored.  (That would
+// be a valid example of a transform, of course.)
+//
+// While the output is causally related to the input, it's not a
+// necessarily symmetric or synchronous transformation.  For example,
+// a zlib stream might take multiple plain-text writes(), and then
+// emit a single compressed chunk some time in the future.
+//
+// Here's how this works:
+//
+// The Transform stream has all the aspects of the readable and writable
+// stream classes.  When you write(chunk), that calls _write(chunk,cb)
+// internally, and returns false if there's a lot of pending writes
+// buffered up.  When you call read(), that calls _read(n) until
+// there's enough pending readable data buffered up.
+//
+// In a transform stream, the written data is placed in a buffer.  When
+// _read(n) is called, it transforms the queued up data, calling the
+// buffered _write cb's as it consumes chunks.  If consuming a single
+// written chunk would result in multiple output chunks, then the first
+// outputted bit calls the readcb, and subsequent chunks just go into
+// the read buffer, and will cause it to emit 'readable' if necessary.
+//
+// This way, back-pressure is actually determined by the reading side,
+// since _read has to be called to start processing a new chunk.  However,
+// a pathological inflate type of transform can cause excessive buffering
+// here.  For example, imagine a stream where every byte of input is
+// interpreted as an integer from 0-255, and then results in that many
+// bytes of output.  Writing the 4 bytes {ff,ff,ff,ff} would result in
+// 1kb of data being output.  In this case, you could write a very small
+// amount of input, and end up with a very large amount of output.  In
+// such a pathological inflating mechanism, there'd be no way to tell
+// the system to stop doing the transform.  A single 4MB write could
+// cause the system to run out of memory.
+//
+// However, even in such a pathological case, only a single written chunk
+// would be consumed, and then the rest would wait (un-transformed) until
+// the results of the previous transformed chunk were consumed.
+"use strict";
+module.exports = $7b107f185708c2ae$var$Transform;
+
+var $6vYby = parcelRequire("6vYby");
+var $7b107f185708c2ae$require$_require$codes = $6vYby.codes;
+var $7b107f185708c2ae$var$ERR_METHOD_NOT_IMPLEMENTED = $7b107f185708c2ae$require$_require$codes.ERR_METHOD_NOT_IMPLEMENTED, $7b107f185708c2ae$var$ERR_MULTIPLE_CALLBACK = $7b107f185708c2ae$require$_require$codes.ERR_MULTIPLE_CALLBACK, $7b107f185708c2ae$var$ERR_TRANSFORM_ALREADY_TRANSFORMING = $7b107f185708c2ae$require$_require$codes.ERR_TRANSFORM_ALREADY_TRANSFORMING, $7b107f185708c2ae$var$ERR_TRANSFORM_WITH_LENGTH_0 = $7b107f185708c2ae$require$_require$codes.ERR_TRANSFORM_WITH_LENGTH_0;
+
+var $cK2wf = parcelRequire("cK2wf");
+
+(parcelRequire("ghwEg"))($7b107f185708c2ae$var$Transform, $cK2wf);
+function $7b107f185708c2ae$var$afterTransform(er, data) {
+    var ts = this._transformState;
+    ts.transforming = false;
+    var cb = ts.writecb;
+    if (cb === null) return this.emit("error", new $7b107f185708c2ae$var$ERR_MULTIPLE_CALLBACK());
+    ts.writechunk = null;
+    ts.writecb = null;
+    if (data != null) this.push(data);
+    cb(er);
+    var rs = this._readableState;
+    rs.reading = false;
+    if (rs.needReadable || rs.length < rs.highWaterMark) this._read(rs.highWaterMark);
+}
+function $7b107f185708c2ae$var$Transform(options) {
+    if (!(this instanceof $7b107f185708c2ae$var$Transform)) return new $7b107f185708c2ae$var$Transform(options);
+    $cK2wf.call(this, options);
+    this._transformState = {
+        afterTransform: $7b107f185708c2ae$var$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", $7b107f185708c2ae$var$prefinish);
+}
+function $7b107f185708c2ae$var$prefinish() {
+    var _this = this;
+    if (typeof this._flush === "function" && !this._readableState.destroyed) this._flush(function(er, data) {
+        $7b107f185708c2ae$var$done(_this, er, data);
+    });
+    else $7b107f185708c2ae$var$done(this, null, null);
+}
+$7b107f185708c2ae$var$Transform.prototype.push = function(chunk, encoding) {
+    this._transformState.needTransform = false;
+    return $cK2wf.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.
+$7b107f185708c2ae$var$Transform.prototype._transform = function(chunk, encoding, cb) {
+    cb(new $7b107f185708c2ae$var$ERR_METHOD_NOT_IMPLEMENTED("_transform()"));
+};
+$7b107f185708c2ae$var$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.
+$7b107f185708c2ae$var$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;
+};
+$7b107f185708c2ae$var$Transform.prototype._destroy = function(err, cb) {
+    $cK2wf.prototype._destroy.call(this, err, function(err2) {
+        cb(err2);
+    });
+};
+function $7b107f185708c2ae$var$done(stream, er, data) {
+    if (er) return stream.emit("error", er);
+    if (data != null) 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 $7b107f185708c2ae$var$ERR_TRANSFORM_WITH_LENGTH_0();
+    if (stream._transformState.transforming) throw new $7b107f185708c2ae$var$ERR_TRANSFORM_ALREADY_TRANSFORMING();
+    return stream.push(null);
+}
+
+});
+
+parcelRequire.register("dnNlY", function(module, exports) {
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+// a passthrough stream.
+// basically just the most minimal sort of Transform stream.
+// Every written chunk gets output as-is.
+"use strict";
+module.exports = $9be3b4ec608b5234$var$PassThrough;
+
+var $az4hH = parcelRequire("az4hH");
+
+(parcelRequire("ghwEg"))($9be3b4ec608b5234$var$PassThrough, $az4hH);
+function $9be3b4ec608b5234$var$PassThrough(options) {
+    if (!(this instanceof $9be3b4ec608b5234$var$PassThrough)) return new $9be3b4ec608b5234$var$PassThrough(options);
+    $az4hH.call(this, options);
+}
+$9be3b4ec608b5234$var$PassThrough.prototype._transform = function(chunk, encoding, cb) {
+    cb(null, chunk);
+};
+
+});
+
+parcelRequire.register("jq29e", function(module, exports) {
+// Ported from https://github.com/mafintosh/pump with
+// permission from the author, Mathias Buus (@mafintosh).
+"use strict";
+var $e2321c935d2086ef$var$eos;
+function $e2321c935d2086ef$var$once(callback) {
+    var called = false;
+    return function() {
+        if (called) return;
+        called = true;
+        callback.apply(void 0, arguments);
+    };
+}
+
+var $6vYby = parcelRequire("6vYby");
+var $e2321c935d2086ef$require$_require$codes = $6vYby.codes;
+var $e2321c935d2086ef$var$ERR_MISSING_ARGS = $e2321c935d2086ef$require$_require$codes.ERR_MISSING_ARGS, $e2321c935d2086ef$var$ERR_STREAM_DESTROYED = $e2321c935d2086ef$require$_require$codes.ERR_STREAM_DESTROYED;
+function $e2321c935d2086ef$var$noop(err) {
+    // Rethrow the error if it exists to avoid swallowing it
+    if (err) throw err;
+}
+function $e2321c935d2086ef$var$isRequest(stream) {
+    return stream.setHeader && typeof stream.abort === "function";
+}
+
+function $e2321c935d2086ef$var$destroyer(stream, reading, writing, callback) {
+    callback = $e2321c935d2086ef$var$once(callback);
+    var closed = false;
+    stream.on("close", function() {
+        closed = true;
+    });
+    if ($e2321c935d2086ef$var$eos === undefined) $e2321c935d2086ef$var$eos = (parcelRequire("7wU83"));
+    $e2321c935d2086ef$var$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 ($e2321c935d2086ef$var$isRequest(stream)) return stream.abort();
+        if (typeof stream.destroy === "function") return stream.destroy();
+        callback(err || new $e2321c935d2086ef$var$ERR_STREAM_DESTROYED("pipe"));
+    };
+}
+function $e2321c935d2086ef$var$call(fn) {
+    fn();
+}
+function $e2321c935d2086ef$var$pipe(from, to) {
+    return from.pipe(to);
+}
+function $e2321c935d2086ef$var$popCallback(streams) {
+    if (!streams.length) return $e2321c935d2086ef$var$noop;
+    if (typeof streams[streams.length - 1] !== "function") return $e2321c935d2086ef$var$noop;
+    return streams.pop();
+}
+function $e2321c935d2086ef$var$pipeline() {
+    for(var _len = arguments.length, streams = new Array(_len), _key = 0; _key < _len; _key++)streams[_key] = arguments[_key];
+    var callback = $e2321c935d2086ef$var$popCallback(streams);
+    if (Array.isArray(streams[0])) streams = streams[0];
+    if (streams.length < 2) throw new $e2321c935d2086ef$var$ERR_MISSING_ARGS("streams");
+    var error;
+    var destroys = streams.map(function(stream, i) {
+        var reading = i < streams.length - 1;
+        var writing = i > 0;
+        return $e2321c935d2086ef$var$destroyer(stream, reading, writing, function(err) {
+            if (!error) error = err;
+            if (err) destroys.forEach($e2321c935d2086ef$var$call);
+            if (reading) return;
+            destroys.forEach($e2321c935d2086ef$var$call);
+            callback(error);
+        });
+    });
+    return streams.reduce($e2321c935d2086ef$var$pipe);
+}
+module.exports = $e2321c935d2086ef$var$pipeline;
+
+});
+
+
+
+parcelRequire.register("6hFBI", function(module, exports) {
+
+var $49349af5670fa154$require$Buffer = $gHtSl$Buffer;
+
+var $4VNAq = parcelRequire("4VNAq");
+var $49349af5670fa154$require$Transform = $4VNAq.Transform;
+module.exports = (KeccakState)=>{
+    class Shake extends $49349af5670fa154$require$Transform {
+        _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 (!$49349af5670fa154$require$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 (!$49349af5670fa154$require$Buffer.isBuffer(data)) data = $49349af5670fa154$require$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;
+        }
+        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;
+        }
+    }
+    return Shake;
+};
+
+});
+
+
+parcelRequire.register("3isIp", function(module, exports) {
+
+var $266953d1151965c2$require$Buffer = $gHtSl$Buffer;
+
+var $avhw2 = parcelRequire("avhw2");
+function $266953d1151965c2$var$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;
+}
+$266953d1151965c2$var$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;
+};
+$266953d1151965c2$var$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) {
+            $avhw2.p1600(this.state);
+            this.count = 0;
+        }
+    }
+};
+$266953d1151965c2$var$Keccak.prototype.absorbLastFewBits = function(bits) {
+    this.state[~~(this.count / 4)] ^= bits << 8 * (this.count % 4);
+    if ((bits & 0x80) !== 0 && this.count === this.blockSize - 1) $avhw2.p1600(this.state);
+    this.state[~~((this.blockSize - 1) / 4)] ^= 0x80 << 8 * ((this.blockSize - 1) % 4);
+    $avhw2.p1600(this.state);
+    this.count = 0;
+    this.squeezing = true;
+};
+$266953d1151965c2$var$Keccak.prototype.squeeze = function(length) {
+    if (!this.squeezing) this.absorbLastFewBits(0x01);
+    const output = $266953d1151965c2$require$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) {
+            $avhw2.p1600(this.state);
+            this.count = 0;
+        }
+    }
+    return output;
+};
+$266953d1151965c2$var$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;
+};
+module.exports = $266953d1151965c2$var$Keccak;
+
+});
+parcelRequire.register("avhw2", function(module, exports) {
+
+$parcel$export(module.exports, "p1600", function () { return $7a5a62e98371297f$export$471358fe9e8379c0; }, function (v) { return $7a5a62e98371297f$export$471358fe9e8379c0 = v; });
+var $7a5a62e98371297f$export$471358fe9e8379c0;
+const $7a5a62e98371297f$var$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
+];
+$7a5a62e98371297f$export$471358fe9e8379c0 = 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] ^= $7a5a62e98371297f$var$P1600_ROUND_CONSTANTS[round * 2];
+        s[1] ^= $7a5a62e98371297f$var$P1600_ROUND_CONSTANTS[round * 2 + 1];
+    }
+};
+
+});
+
+
+// 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 $7a07e400cb853a78$var$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
+    };
+};
+var $7a07e400cb853a78$export$2e2bcd8739ae039 = $7a07e400cb853a78$var$base;
+
+
+const $535f3d7412ddf980$var$base32 = "abcdefghijklmnopqrstuvwxyz234567";
+const $535f3d7412ddf980$var$base32Hex = "0123456789abcdefghijklmnopqrstuv";
+const $535f3d7412ddf980$var$decode = (uint8Array, hex = false)=>{
+    const decoder = hex ? (0, $7a07e400cb853a78$export$2e2bcd8739ae039)($535f3d7412ddf980$var$base32Hex) : (0, $7a07e400cb853a78$export$2e2bcd8739ae039)($535f3d7412ddf980$var$base32);
+    return decoder.decode(uint8Array);
+};
+var $535f3d7412ddf980$export$2e2bcd8739ae039 = {
+    encode: (uint8Array, hex = false)=>{
+        const encoder = hex ? (0, $7a07e400cb853a78$export$2e2bcd8739ae039)($535f3d7412ddf980$var$base32Hex) : (0, $7a07e400cb853a78$export$2e2bcd8739ae039)($535f3d7412ddf980$var$base32);
+        return encoder.encode(uint8Array);
+    },
+    decode: $535f3d7412ddf980$var$decode,
+    isBase32: (uint8Array, hex = false)=>{
+        try {
+            $535f3d7412ddf980$var$decode(uint8Array, hex);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+};
+
+
+
+const $6aa4c72dbe4d8ebf$var$base58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const $6aa4c72dbe4d8ebf$var$decode = (uint8Array)=>(0, $7a07e400cb853a78$export$2e2bcd8739ae039)($6aa4c72dbe4d8ebf$var$base58).decode(uint8Array);
+var $6aa4c72dbe4d8ebf$export$2e2bcd8739ae039 = {
+    encode: (uint8Array)=>(0, $7a07e400cb853a78$export$2e2bcd8739ae039)($6aa4c72dbe4d8ebf$var$base58).encode(uint8Array),
+    decode: $6aa4c72dbe4d8ebf$var$decode,
+    isBase58: (uint8Array)=>{
+        try {
+            $6aa4c72dbe4d8ebf$var$decode(uint8Array);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+};
+
+
+var $31d5120d2ce127ae$export$2e2bcd8739ae039 = (string)=>/^[A-F0-9]+$/i.test(string);
+
+
+
+var $af6c45bdc918b0b2$require$Buffer = $gHtSl$Buffer;
+class $af6c45bdc918b0b2$export$2e2bcd8739ae039 {
+    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 (0, $31d5120d2ce127ae$export$2e2bcd8739ae039)(string);
+    }
+    isBase32(string) {
+        return (0, $535f3d7412ddf980$export$2e2bcd8739ae039).isBase32(string);
+    }
+    isBase58(string) {
+        return (0, $6aa4c72dbe4d8ebf$export$2e2bcd8739ae039).isBase58(string);
+    }
+    /**
+   * @param {String} encoded
+   */ fromBs32(encoded) {
+        this.encoded = (0, $535f3d7412ddf980$export$2e2bcd8739ae039).decode(encoded);
+        return this.handleDecode();
+    }
+    /**
+   * @param {String} encoded
+   */ fromBs58(encoded) {
+        this.encoded = (0, $6aa4c72dbe4d8ebf$export$2e2bcd8739ae039).decode(encoded);
+        return this.handleDecode();
+    }
+    async toArray() {
+        const array = [];
+        for await (const value1 of this.encoded.values())array.push(value1);
+        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 = $af6c45bdc918b0b2$require$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 (0, $535f3d7412ddf980$export$2e2bcd8739ae039).encode(this.encoded);
+    }
+    /**
+   * @return {String} encoded
+   */ async toBs58() {
+        if (!this.encoded) await this.handleEncode();
+        return (0, $6aa4c72dbe4d8ebf$export$2e2bcd8739ae039).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 $61722dc45b139836$exports = {};
+
+
+
+$61722dc45b139836$exports = {
+    encode: (parcelRequire("O0X0N")),
+    decode: (parcelRequire("c0YY7")),
+    encodingLength: (parcelRequire("1H9q1"))
+};
+
+
+var $73779ceb9ad23576$export$2e2bcd8739ae039 = {
+    // just a hash
+    "disco-hash": {
+        codec: parseInt("30", 16),
+        hashAlg: "dbl-keccak-256"
+    },
+    "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"
+    },
+    "leofcoin-tx": {
+        codec: parseInt("6c74", 16),
+        hashAlg: "dbl-keccak-512"
+    },
+    // itx
+    "leofcoin-itx": {
+        codec: parseInt("6c69", 16),
+        hashAlg: "keccak-512"
+    },
+    // peer reputation
+    "leofcoin-pr": {
+        codec: parseInt("6c70", 16),
+        hashAlg: "keccak-256"
+    },
+    // 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 $9ca3109881fa7a7a$export$2e2bcd8739ae039 extends (0, $af6c45bdc918b0b2$export$2e2bcd8739ae039) {
+    get codecs() {
+        return {
+            ...globalThis.peernet.codecs,
+            ...(0, $73779ceb9ad23576$export$2e2bcd8739ae039)
+        };
+    }
+    fromEncoded(encoded) {
+        const codec = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).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 = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).encode(codec);
+    }
+    fromName(name) {
+        const codec = this.getCodec(name);
+        this.name = name;
+        this.codec = codec;
+        this.hashAlg = this.getHashAlg(name);
+        this.codecBuffer = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).encode(codec);
+    }
+    decode() {
+        const codec = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).decode(this.encoded);
+        this.fromCodec(codec);
+    }
+    encode() {
+        const codec = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).encode(this.decoded);
+        this.encoded = codec;
+        return this.encoded;
+    }
+    constructor(buffer){
+        super();
+        if (buffer) {
+            if (buffer instanceof Uint8Array) {
+                const codec = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).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);
+            }
+        }
+    }
+}
+
+
+var $65534db4b3124287$exports = {};
+
+
+$65534db4b3124287$exports = (parcelRequire("4n0nt"))((parcelRequire("3isIp")));
+
+
+
+
+
+
+var $479b6579a0da0716$require$Buffer = $gHtSl$Buffer;
+class $479b6579a0da0716$export$2e2bcd8739ae039 extends (0, $af6c45bdc918b0b2$export$2e2bcd8739ae039) {
+    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 (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).encode(this.size);
+    }
+    get buffer() {
+        return this.encoded;
+    }
+    get hash() {
+        return this.encoded;
+    }
+    fromJSON(json) {
+        return this.encode($479b6579a0da0716$require$Buffer.from(JSON.stringify(json)));
+    }
+    encode(buffer, name) {
+        if (!this.name && name) this.name = name;
+        if (!buffer) buffer = this.buffer;
+        this.discoCodec = new (0, $9ca3109881fa7a7a$export$2e2bcd8739ae039)(this.name, this.codecs);
+        this.discoCodec.fromName(this.name);
+        let hashAlg = this.discoCodec.hashAlg;
+        if (hashAlg.includes("dbl")) {
+            hashAlg = hashAlg.replace("dbl-", "");
+            buffer = (0, (/*@__PURE__*/$parcel$interopDefault($65534db4b3124287$exports)))(hashAlg.replace("-", "")).update(buffer).digest();
+        }
+        this.digest = (0, (/*@__PURE__*/$parcel$interopDefault($65534db4b3124287$exports)))(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 ($479b6579a0da0716$require$Buffer.isBuffer(buffer)) {
+            const codec = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).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 = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).decode(buffer);
+        this.discoCodec = new (0, $9ca3109881fa7a7a$export$2e2bcd8739ae039)(codec, this.codecs);
+        // TODO: validate codec
+        buffer = buffer.slice((0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).decode.bytes);
+        this.size = (0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).decode(buffer);
+        this.digest = buffer.slice((0, (/*@__PURE__*/$parcel$interopDefault($61722dc45b139836$exports))).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
+        };
+    }
+    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 (0, $9ca3109881fa7a7a$export$2e2bcd8739ae039)(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);
+        }
+    }
+}
+
+
+class $20c7f34bf5b0b473$export$2e2bcd8739ae039 extends (0, $af6c45bdc918b0b2$export$2e2bcd8739ae039) {
+    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;
+    }
+    /**
+   * @return {PeernetHash}
+   */ get peernetHash() {
+        return new (0, $479b6579a0da0716$export$2e2bcd8739ae039)(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 (0, $9ca3109881fa7a7a$export$2e2bcd8739ae039)(this.encoded);
+        encoded = encoded.slice(discoCodec.codecBuffer.length);
+        this.name = discoCodec.name;
+        this.decoded = await this.protoDecode(encoded);
+        try {
+            this.decoded = JSON.parse(this.decoded);
+        } catch  {}
+        return this.decoded;
+    }
+    /**
+   * @return {Buffer}
+   */ async encode(decoded) {
+        if (!decoded) decoded = this.decoded;
+        const codec = new (0, $9ca3109881fa7a7a$export$2e2bcd8739ae039)(this.name);
+        const encoded = await this.protoEncode(typeof decoded === "object" ? JSON.stringify(decoded) : decoded);
+        const uint8Array = new Uint8Array(encoded.length + codec.codecBuffer.length);
+        uint8Array.set(codec.codecBuffer);
+        uint8Array.set(encoded, codec.codecBuffer.length);
+        this.encoded = uint8Array;
+        return this.encoded;
+    }
+    hasCodec() {
+        if (!this.encoded) return false;
+        const codec = new (0, $9ca3109881fa7a7a$export$2e2bcd8739ae039)(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)));
+    }
+    /**
+   * @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);
+    }
+}
+
+
+
+
+
+const $428095396ca04bce$export$1b7dbb60aef3044 = (0, $af6c45bdc918b0b2$export$2e2bcd8739ae039);
+const $428095396ca04bce$export$a3360ca1fc583f9e = (0, $20c7f34bf5b0b473$export$2e2bcd8739ae039);
+const $428095396ca04bce$export$ea841ad44f0598a2 = (0, $479b6579a0da0716$export$2e2bcd8739ae039);
+const $428095396ca04bce$export$a111e9ced3f1d2d0 = (0, $9ca3109881fa7a7a$export$2e2bcd8739ae039);
+const $428095396ca04bce$export$1c4d583cbe1d2b10 = (0, $73779ceb9ad23576$export$2e2bcd8739ae039);
+
+
+export {$428095396ca04bce$export$1b7dbb60aef3044 as BasicInterface, $428095396ca04bce$export$a3360ca1fc583f9e as FormatInterface, $428095396ca04bce$export$ea841ad44f0598a2 as CodecHash, $428095396ca04bce$export$a111e9ced3f1d2d0 as Codec, $428095396ca04bce$export$1c4d583cbe1d2b10 as Codecs};
+//# sourceMappingURL=browser.js.map