lz4.js

/**
 * LZ4 based compression and decompression
 * Copyright (c) 2014 Pierre Curto
 * MIT Licensed
 */

var __exports__ = {};

require = (function e(t, n, r) {
  function s(o, u) {
    if (!n[o]) {
      if (!t[o]) {
        var a = typeof require == "function" && require;
        if (!u && a) return a(o, !0);
        if (i) return i(o, !0);
        var f = new Error("Cannot find module '" + o + "'");
        throw ((f.code = "MODULE_NOT_FOUND"), f);
      }
      var l = (n[o] = { exports: {} });
      t[o][0].call(
        l.exports,
        function (e) {
          var n = t[o][1][e];
          return s(n ? n : e);
        },
        l,
        l.exports,
        e,
        t,
        n,
        r,
      );
    }
    return n[o].exports;
  }
  var i = typeof require == "function" && require;
  for (var o = 0; o < r.length; o++) s(r[o]);
  return s;
})(
  {
    "./utils": [
      function (require, module, exports) {
        /**
         * Javascript emulated bindings
         */
        var XXH = require("xxhashjs");

        var CHECKSUM_SEED = 0;

        // Header checksum is second byte of xxhash using 0 as a seed
        exports.descriptorChecksum = function (d) {
          return (XXH(d, CHECKSUM_SEED).toNumber() >> 8) & 0xff;
        };

        exports.blockChecksum = function (d) {
          return XXH(d, CHECKSUM_SEED).toNumber();
        };

        exports.streamChecksum = function (d, c) {
          if (d === null) return c.digest().toNumber();

          if (c === null) c = XXH(CHECKSUM_SEED);

          return c.update(d);
        };

        // Provide simple readInt32LE as the Buffer ones from node and browserify are incompatible
        exports.readInt32LE = function (buffer, offset) {
          return (
            buffer[offset] |
            (buffer[offset + 1] << 8) |
            (buffer[offset + 2] << 16) |
            (buffer[offset + 3] << 24)
          );
        };

        exports.bindings = require("./binding");
      },
      { "./binding": 1, xxhashjs: 10 },
    ],
    1: [
      function (require, module, exports) {
        /**
	Javascript version of the key LZ4 C functions
 */
        var uint32 = require("cuint").UINT32;

        if (!Math.imul)
          Math.imul = function imul(a, b) {
            var ah = a >>> 16;
            var al = a & 0xffff;
            var bh = b >>> 16;
            var bl = b & 0xffff;
            return (al * bl + ((ah * bl + al * bh) << 16)) | 0;
          };

        /**
         * Decode a block. Assumptions: input contains all sequences of a
         * chunk, output is large enough to receive the decoded data.
         * If the output buffer is too small, an error will be thrown.
         * If the returned value is negative, an error occured at the returned offset.
         *
         * @param input {Buffer} input data
         * @param output {Buffer} output data
         * @return {Number} number of decoded bytes
         * @private
         */
        exports.uncompress = function (input, output, sIdx, eIdx) {
          sIdx = sIdx || 0;
          eIdx = eIdx || input.length - sIdx;
          // Process each sequence in the incoming data
          for (var i = sIdx, n = eIdx, j = 0; i < n; ) {
            var token = input[i++];

            // Literals
            var literals_length = token >> 4;
            if (literals_length > 0) {
              // length of literals
              var l = literals_length + 240;
              while (l === 255) {
                l = input[i++];
                literals_length += l;
              }

              // Copy the literals
              var end = i + literals_length;
              while (i < end) output[j++] = input[i++];

              // End of buffer?
              if (i === n) return j;
            }

            // Match copy
            // 2 bytes offset (little endian)
            var offset = input[i++] | (input[i++] << 8);

            // 0 is an invalid offset value
            if (offset === 0 || offset > j) return -(i - 2);

            // length of match copy
            var match_length = token & 0xf;
            var l = match_length + 240;
            while (l === 255) {
              l = input[i++];
              match_length += l;
            }

            // Copy the match
            var pos = j - offset; // position of the match copy in the current output
            var end = j + match_length + 4; // minmatch = 4
            while (j < end) output[j++] = output[pos++];
          }

          return j;
        };

        var maxInputSize = 0x7e000000,
          minMatch = 4,
          // uint32() optimization
          hashLog = 16,
          hashShift = minMatch * 8 - hashLog,
          hashSize = 1 << hashLog,
          copyLength = 8,
          lastLiterals = 5,
          mfLimit = copyLength + minMatch,
          skipStrength = 6,
          mlBits = 4,
          mlMask = (1 << mlBits) - 1,
          runBits = 8 - mlBits,
          runMask = (1 << runBits) - 1,
          hasher = 2654435761;

        // CompressBound returns the maximum length of a lz4 block, given it's uncompressed length
        exports.compressBound = function (isize) {
          return isize > maxInputSize ? 0 : (isize + isize / 255 + 16) | 0;
        };

        exports.compress = function (src, dst, sIdx, eIdx) {
          // V8 optimization: non sparse array with integers
          var hashTable = new Array(hashSize);
          for (var i = 0; i < hashSize; i++) {
            hashTable[i] = 0;
          }
          return compressBlock(
            src,
            dst,
            0,
            hashTable,
            sIdx || 0,
            eIdx || dst.length,
          );
        };

        exports.compressHC = exports.compress;

        exports.compressDependent = compressBlock;

        function compressBlock(src, dst, pos, hashTable, sIdx, eIdx) {
          var dpos = sIdx;
          var dlen = eIdx - sIdx;
          var anchor = 0;

          if (src.length >= maxInputSize) throw new Error("input too large");

          // Minimum of input bytes for compression (LZ4 specs)
          if (src.length > mfLimit) {
            var n = exports.compressBound(src.length);
            if (dlen < n) throw Error("output too small: " + dlen + " < " + n);

            var step = 1,
              findMatchAttempts = (1 << skipStrength) + 3,
              // Keep last few bytes incompressible (LZ4 specs):
              // last 5 bytes must be literals
              srcLength = src.length - mfLimit;

            while (pos + minMatch < srcLength) {
              // Find a match
              // min match of 4 bytes aka sequence
              var sequenceLowBits = (src[pos + 1] << 8) | src[pos];
              var sequenceHighBits = (src[pos + 3] << 8) | src[pos + 2];
              // compute hash for the current sequence
              var hash =
                Math.imul(
                  sequenceLowBits | (sequenceHighBits << 16),
                  hasher,
                ) >>> hashShift;
              // get the position of the sequence matching the hash
              // NB. since 2 different sequences may have the same hash
              // it is double-checked below
              // do -1 to distinguish between initialized and uninitialized values
              var ref = hashTable[hash] - 1;
              // save position of current sequence in hash table
              hashTable[hash] = pos + 1;

              // first reference or within 64k limit or current sequence !== hashed one: no match
              if (
                ref < 0 ||
                (pos - ref) >>> 16 > 0 ||
                ((src[ref + 3] << 8) | src[ref + 2]) != sequenceHighBits ||
                ((src[ref + 1] << 8) | src[ref]) != sequenceLowBits
              ) {
                // increase step if nothing found within limit
                step = findMatchAttempts++ >> skipStrength;
                pos += step;
                continue;
              }

              findMatchAttempts = (1 << skipStrength) + 3;

              // got a match
              var literals_length = pos - anchor;
              var offset = pos - ref;

              // minMatch already verified
              pos += minMatch;
              ref += minMatch;

              // move to the end of the match (>=minMatch)
              var match_length = pos;
              while (pos < srcLength && src[pos] == src[ref]) {
                pos++;
                ref++;
              }

              // match length
              match_length = pos - match_length;

              // token
              var token = match_length < mlMask ? match_length : mlMask;

              // encode literals length
              if (literals_length >= runMask) {
                // add match length to the token
                dst[dpos++] = (runMask << mlBits) + token;
                for (
                  var len = literals_length - runMask;
                  len > 254;
                  len -= 255
                ) {
                  dst[dpos++] = 255;
                }
                dst[dpos++] = len;
              } else {
                // add match length to the token
                dst[dpos++] = (literals_length << mlBits) + token;
              }

              // write literals
              for (var i = 0; i < literals_length; i++) {
                dst[dpos++] = src[anchor + i];
              }

              // encode offset
              dst[dpos++] = offset;
              dst[dpos++] = offset >> 8;

              // encode match length
              if (match_length >= mlMask) {
                match_length -= mlMask;
                while (match_length >= 255) {
                  match_length -= 255;
                  dst[dpos++] = 255;
                }

                dst[dpos++] = match_length;
              }

              anchor = pos;
            }
          }

          // cannot compress input
          if (anchor == 0) return 0;

          // Write last literals
          // encode literals length
          literals_length = src.length - anchor;
          if (literals_length >= runMask) {
            // add match length to the token
            dst[dpos++] = runMask << mlBits;
            for (var ln = literals_length - runMask; ln > 254; ln -= 255) {
              dst[dpos++] = 255;
            }
            dst[dpos++] = ln;
          } else {
            // add match length to the token
            dst[dpos++] = literals_length << mlBits;
          }

          // write literals
          pos = anchor;
          while (pos < src.length) {
            dst[dpos++] = src[pos++];
          }

          return dpos;
        }
      },
      { cuint: 7 },
    ],
    2: [
      function (require, module, exports) {
        (function (Buffer) {
          var Decoder = require("./decoder_stream");

          /**
	Decode an LZ4 stream
 */
          function LZ4_uncompress(input, options) {
            var output = [];
            var decoder = new Decoder(options);

            decoder.on("data", function (chunk) {
              output.push(chunk);
            });

            decoder.end(input);

            return Buffer.concat(output);
          }

          exports.LZ4_uncompress = LZ4_uncompress;
        }).call(this, require("buffer").Buffer);
      },
      { "./decoder_stream": 3, buffer: "buffer" },
    ],
    3: [
      function (require, module, exports) {
        (function (Buffer) {
          var Transform = require("stream").Transform;
          var inherits = require("util").inherits;

          var lz4_static = require("./static");
          var utils = lz4_static.utils;
          var lz4_binding = utils.bindings;
          var lz4_jsbinding = require("./binding");

          var STATES = lz4_static.STATES;
          var SIZES = lz4_static.SIZES;

          function Decoder(options) {
            if (!(this instanceof Decoder)) return new Decoder(options);

            Transform.call(this, options);
            // Options
            this.options = options || {};

            this.binding = this.options.useJS ? lz4_jsbinding : lz4_binding;

            // Encoded data being processed
            this.buffer = null;
            // Current position within the data
            this.pos = 0;
            this.descriptor = null;

            // Current state of the parsing
            this.state = STATES.MAGIC;

            this.notEnoughData = false;
            this.descriptorStart = 0;
            this.streamSize = null;
            this.dictId = null;
            this.currentStreamChecksum = null;
            this.dataBlockSize = 0;
            this.skippableSize = 0;
          }
          inherits(Decoder, Transform);

          Decoder.prototype._transform = function (data, encoding, done) {
            // Handle skippable data
            if (this.skippableSize > 0) {
              this.skippableSize -= data.length;
              if (this.skippableSize > 0) {
                // More to skip
                done();
                return;
              }

              data = data.slice(-this.skippableSize);
              this.skippableSize = 0;
              this.state = STATES.MAGIC;
            }
            // Buffer the incoming data
            this.buffer = this.buffer
              ? Buffer.concat(
                  [this.buffer, data],
                  this.buffer.length + data.length,
                )
              : data;

            this._main(done);
          };

          Decoder.prototype.emit_Error = function (msg) {
            this.emit("error", new Error(msg + " @" + this.pos));
          };

          Decoder.prototype.check_Size = function (n) {
            var delta = this.buffer.length - this.pos;
            if (delta <= 0 || delta < n) {
              if (this.notEnoughData)
                this.emit_Error("Unexpected end of LZ4 stream");
              return true;
            }

            this.pos += n;
            return false;
          };

          Decoder.prototype.read_MagicNumber = function () {
            var pos = this.pos;
            if (this.check_Size(SIZES.MAGIC)) return true;

            var magic = utils.readInt32LE(this.buffer, pos);

            // Skippable chunk
            if ((magic & 0xfffffff0) === lz4_static.MAGICNUMBER_SKIPPABLE) {
              this.state = STATES.SKIP_SIZE;
              return;
            }

            // LZ4 stream
            if (magic !== lz4_static.MAGICNUMBER) {
              this.pos = pos;
              this.emit_Error(
                "Invalid magic number: " + magic.toString(16).toUpperCase(),
              );
              return true;
            }

            this.state = STATES.DESCRIPTOR;
          };

          Decoder.prototype.read_SkippableSize = function () {
            var pos = this.pos;
            if (this.check_Size(SIZES.SKIP_SIZE)) return true;
            this.state = STATES.SKIP_DATA;
            this.skippableSize = utils.readInt32LE(this.buffer, pos);
          };

          Decoder.prototype.read_Descriptor = function () {
            // Flags
            var pos = this.pos;
            if (this.check_Size(SIZES.DESCRIPTOR)) return true;

            this.descriptorStart = pos;

            // version
            var descriptor_flg = this.buffer[pos];
            var version = descriptor_flg >> 6;
            if (version !== lz4_static.VERSION) {
              this.pos = pos;
              this.emit_Error(
                "Invalid version: " + version + " != " + lz4_static.VERSION,
              );
              return true;
            }

            // flags
            // reserved bit should not be set
            if ((descriptor_flg >> 1) & 0x1) {
              this.pos = pos;
              this.emit_Error("Reserved bit set");
              return true;
            }

            var blockMaxSizeIndex = (this.buffer[pos + 1] >> 4) & 0x7;
            var blockMaxSize = lz4_static.blockMaxSizes[blockMaxSizeIndex];
            if (blockMaxSize === null) {
              this.pos = pos;
              this.emit_Error("Invalid block max size: " + blockMaxSizeIndex);
              return true;
            }

            this.descriptor = {
              blockIndependence: Boolean((descriptor_flg >> 5) & 0x1),
              blockChecksum: Boolean((descriptor_flg >> 4) & 0x1),
              blockMaxSize: blockMaxSize,
              streamSize: Boolean((descriptor_flg >> 3) & 0x1),
              streamChecksum: Boolean((descriptor_flg >> 2) & 0x1),
              dict: Boolean(descriptor_flg & 0x1),
              dictId: 0,
            };

            this.state = STATES.SIZE;
          };

          Decoder.prototype.read_Size = function () {
            if (this.descriptor.streamSize) {
              var pos = this.pos;
              if (this.check_Size(SIZES.SIZE)) return true;
              //TODO max size is unsigned 64 bits
              this.streamSize = this.buffer.slice(pos, pos + 8);
            }

            this.state = STATES.DICTID;
          };

          Decoder.prototype.read_DictId = function () {
            if (this.descriptor.dictId) {
              var pos = this.pos;
              if (this.check_Size(SIZES.DICTID)) return true;
              this.dictId = utils.readInt32LE(this.buffer, pos);
            }

            this.state = STATES.DESCRIPTOR_CHECKSUM;
          };

          Decoder.prototype.read_DescriptorChecksum = function () {
            var pos = this.pos;
            if (this.check_Size(SIZES.DESCRIPTOR_CHECKSUM)) return true;

            var checksum = this.buffer[pos];
            var currentChecksum = utils.descriptorChecksum(
              this.buffer.slice(this.descriptorStart, pos),
            );
            if (currentChecksum !== checksum) {
              this.pos = pos;
              this.emit_Error("Invalid stream descriptor checksum");
              return true;
            }

            this.state = STATES.DATABLOCK_SIZE;
          };

          Decoder.prototype.read_DataBlockSize = function () {
            var pos = this.pos;
            if (this.check_Size(SIZES.DATABLOCK_SIZE)) return true;
            var datablock_size = utils.readInt32LE(this.buffer, pos);
            // Uncompressed
            if (datablock_size === lz4_static.EOS) {
              this.state = STATES.EOS;
              return;
            }

            // if (datablock_size > this.descriptor.blockMaxSize) {
            // 	this.emit_Error( 'ASSERTION: invalid datablock_size: ' + datablock_size.toString(16).toUpperCase() + ' > ' + this.descriptor.blockMaxSize.toString(16).toUpperCase() )
            // }
            this.dataBlockSize = datablock_size;

            this.state = STATES.DATABLOCK_DATA;
          };

          Decoder.prototype.read_DataBlockData = function () {
            var pos = this.pos;
            var datablock_size = this.dataBlockSize;
            if (datablock_size & 0x80000000) {
              // Uncompressed size
              datablock_size = datablock_size & 0x7fffffff;
            }
            if (this.check_Size(datablock_size)) return true;

            this.dataBlock = this.buffer.slice(pos, pos + datablock_size);

            this.state = STATES.DATABLOCK_CHECKSUM;
          };

          Decoder.prototype.read_DataBlockChecksum = function () {
            var pos = this.pos;
            if (this.descriptor.blockChecksum) {
              if (this.check_Size(SIZES.DATABLOCK_CHECKSUM)) return true;
              var checksum = utils.readInt32LE(this.buffer, this.pos - 4);
              var currentChecksum = utils.blockChecksum(this.dataBlock);
              if (currentChecksum !== checksum) {
                this.pos = pos;
                this.emit_Error("Invalid block checksum");
                return true;
              }
            }

            this.state = STATES.DATABLOCK_UNCOMPRESS;
          };

          Decoder.prototype.uncompress_DataBlock = function () {
            var uncompressed;
            // uncompressed?
            if (this.dataBlockSize & 0x80000000) {
              uncompressed = this.dataBlock;
            } else {
              uncompressed = new Buffer(this.descriptor.blockMaxSize);
              var decodedSize = this.binding.uncompress(
                this.dataBlock,
                uncompressed,
              );
              if (decodedSize < 0) {
                this.emit_Error("Invalid data block: " + -decodedSize);
                return true;
              }
              if (decodedSize < this.descriptor.blockMaxSize)
                uncompressed = uncompressed.slice(0, decodedSize);
            }
            this.dataBlock = null;
            this.push(uncompressed);

            // Stream checksum
            if (this.descriptor.streamChecksum) {
              this.currentStreamChecksum = utils.streamChecksum(
                uncompressed,
                this.currentStreamChecksum,
              );
            }

            this.state = STATES.DATABLOCK_SIZE;
          };

          Decoder.prototype.read_EOS = function () {
            if (this.descriptor.streamChecksum) {
              var pos = this.pos;
              if (this.check_Size(SIZES.EOS)) return true;
              var checksum = utils.readInt32LE(this.buffer, pos);
              if (
                checksum !==
                utils.streamChecksum(null, this.currentStreamChecksum)
              ) {
                this.pos = pos;
                this.emit_Error(
                  "Invalid stream checksum: " +
                    checksum.toString(16).toUpperCase(),
                );
                return true;
              }
            }

            this.state = STATES.MAGIC;
          };

          Decoder.prototype._flush = function (done) {
            // Error on missing data as no more will be coming
            this.notEnoughData = true;
            this._main(done);
          };

          Decoder.prototype._main = function (done) {
            var pos = this.pos;
            var notEnoughData;

            while (!notEnoughData && this.pos < this.buffer.length) {
              if (this.state === STATES.MAGIC)
                notEnoughData = this.read_MagicNumber();

              if (this.state === STATES.SKIP_SIZE)
                notEnoughData = this.read_SkippableSize();

              if (this.state === STATES.DESCRIPTOR)
                notEnoughData = this.read_Descriptor();

              if (this.state === STATES.SIZE) notEnoughData = this.read_Size();

              if (this.state === STATES.DICTID)
                notEnoughData = this.read_DictId();

              if (this.state === STATES.DESCRIPTOR_CHECKSUM)
                notEnoughData = this.read_DescriptorChecksum();

              if (this.state === STATES.DATABLOCK_SIZE)
                notEnoughData = this.read_DataBlockSize();

              if (this.state === STATES.DATABLOCK_DATA)
                notEnoughData = this.read_DataBlockData();

              if (this.state === STATES.DATABLOCK_CHECKSUM)
                notEnoughData = this.read_DataBlockChecksum();

              if (this.state === STATES.DATABLOCK_UNCOMPRESS)
                notEnoughData = this.uncompress_DataBlock();

              if (this.state === STATES.EOS) notEnoughData = this.read_EOS();
            }

            if (this.pos > pos) {
              this.buffer = this.buffer.slice(this.pos);
              this.pos = 0;
            }

            done();
          };

          module.exports = Decoder;
        }).call(this, require("buffer").Buffer);
      },
      { "./binding": 1, "./static": 6, buffer: "buffer", stream: 33, util: 36 },
    ],
    4: [
      function (require, module, exports) {
        (function (Buffer) {
          var Encoder = require("./encoder_stream");

          /**
	Encode an LZ4 stream
 */
          function LZ4_compress(input, options) {
            var output = [];
            var encoder = new Encoder(options);

            encoder.on("data", function (chunk) {
              output.push(chunk);
            });

            encoder.end(input);

            return Buffer.concat(output);
          }

          exports.LZ4_compress = LZ4_compress;
        }).call(this, require("buffer").Buffer);
      },
      { "./encoder_stream": 5, buffer: "buffer" },
    ],
    5: [
      function (require, module, exports) {
        (function (Buffer) {
          var Transform = require("stream").Transform;
          var inherits = require("util").inherits;

          var lz4_static = require("./static");
          var utils = lz4_static.utils;
          var lz4_binding = utils.bindings;
          var lz4_jsbinding = require("./binding");

          var STATES = lz4_static.STATES;
          var SIZES = lz4_static.SIZES;

          var defaultOptions = {
            blockIndependence: true,
            blockChecksum: false,
            blockMaxSize: 4 << 20,
            streamSize: false,
            streamChecksum: true,
            dict: false,
            dictId: 0,
            highCompression: false,
          };

          function Encoder(options) {
            if (!(this instanceof Encoder)) return new Encoder(options);

            Transform.call(this, options);

            // Set the options
            var o = options || defaultOptions;
            if (o !== defaultOptions)
              Object.keys(defaultOptions).forEach(function (p) {
                if (!o.hasOwnProperty(p)) o[p] = defaultOptions[p];
              });

            this.options = o;

            this.binding = this.options.useJS ? lz4_jsbinding : lz4_binding;
            this.compress = o.highCompression
              ? this.binding.compressHC
              : this.binding.compress;

            // Build the stream descriptor from the options
            // flags
            var descriptor_flg = 0;
            descriptor_flg = descriptor_flg | (lz4_static.VERSION << 6); // Version
            descriptor_flg = descriptor_flg | ((o.blockIndependence & 1) << 5); // Block independence
            descriptor_flg = descriptor_flg | ((o.blockChecksum & 1) << 4); // Block checksum
            descriptor_flg = descriptor_flg | ((o.streamSize & 1) << 3); // Stream size
            descriptor_flg = descriptor_flg | ((o.streamChecksum & 1) << 2); // Stream checksum
            // Reserved bit
            descriptor_flg = descriptor_flg | (o.dict & 1); // Preset dictionary

            // block maximum size
            var descriptor_bd = lz4_static.blockMaxSizes.indexOf(
              o.blockMaxSize,
            );
            if (descriptor_bd < 0)
              throw new Error("Invalid blockMaxSize: " + o.blockMaxSize);

            this.descriptor = {
              flg: descriptor_flg,
              bd: (descriptor_bd & 0x7) << 4,
            };

            // Data being processed
            this.buffer = [];
            this.length = 0;

            this.first = true;
            this.checksum = null;
          }
          inherits(Encoder, Transform);

          // Header = magic number + stream descriptor
          Encoder.prototype.headerSize = function () {
            var streamSizeSize = this.options.streamSize ? SIZES.DESCRIPTOR : 0;
            var dictSize = this.options.dict ? SIZES.DICTID : 0;

            return SIZES.MAGIC + 1 + 1 + streamSizeSize + dictSize + 1;
          };

          Encoder.prototype.header = function () {
            var headerSize = this.headerSize();
            var output = new Buffer(headerSize);

            this.state = STATES.MAGIC;
            output.writeInt32LE(lz4_static.MAGICNUMBER, 0, true);

            this.state = STATES.DESCRIPTOR;
            var descriptor = output.slice(SIZES.MAGIC, output.length - 1);

            // Update the stream descriptor
            descriptor.writeUInt8(this.descriptor.flg, 0, true);
            descriptor.writeUInt8(this.descriptor.bd, 1, true);

            var pos = 2;
            this.state = STATES.SIZE;
            if (this.options.streamSize) {
              //TODO only 32bits size supported
              descriptor.writeInt32LE(0, pos, true);
              descriptor.writeInt32LE(this.size, pos + 4, true);
              pos += SIZES.SIZE;
            }
            this.state = STATES.DICTID;
            if (this.options.dict) {
              descriptor.writeInt32LE(this.dictId, pos, true);
              pos += SIZES.DICTID;
            }

            this.state = STATES.DESCRIPTOR_CHECKSUM;
            output.writeUInt8(
              utils.descriptorChecksum(descriptor),
              SIZES.MAGIC + pos,
              false,
            );

            return output;
          };

          Encoder.prototype.update_Checksum = function (data) {
            // Calculate the stream checksum
            this.state = STATES.CHECKSUM_UPDATE;
            if (this.options.streamChecksum) {
              this.checksum = utils.streamChecksum(data, this.checksum);
            }
          };

          Encoder.prototype.compress_DataBlock = function (data) {
            this.state = STATES.DATABLOCK_COMPRESS;
            var dbChecksumSize = this.options.blockChecksum
              ? SIZES.DATABLOCK_CHECKSUM
              : 0;
            var maxBufSize = this.binding.compressBound(data.length);
            var buf = new Buffer(
              SIZES.DATABLOCK_SIZE + maxBufSize + dbChecksumSize,
            );
            var compressed = buf.slice(
              SIZES.DATABLOCK_SIZE,
              SIZES.DATABLOCK_SIZE + maxBufSize,
            );
            var compressedSize = this.compress(data, compressed);

            // Set the block size
            this.state = STATES.DATABLOCK_SIZE;
            // Block size shall never be larger than blockMaxSize
            // console.log("blockMaxSize", this.options.blockMaxSize, "compressedSize", compressedSize)
            if (
              compressedSize > 0 &&
              compressedSize <= this.options.blockMaxSize
            ) {
              // highest bit is 0 (compressed data)
              buf.writeUInt32LE(compressedSize, 0, true);
              buf = buf.slice(
                0,
                SIZES.DATABLOCK_SIZE + compressedSize + dbChecksumSize,
              );
            } else {
              // Cannot compress the data, leave it as is
              // highest bit is 1 (uncompressed data)
              buf.writeInt32LE(0x80000000 | data.length, 0, true);
              buf = buf.slice(
                0,
                SIZES.DATABLOCK_SIZE + data.length + dbChecksumSize,
              );
              data.copy(buf, SIZES.DATABLOCK_SIZE);
            }

            // Set the block checksum
            this.state = STATES.DATABLOCK_CHECKSUM;
            if (this.options.blockChecksum) {
              // xxHash checksum on undecoded data with a seed of 0
              var checksum = buf.slice(-dbChecksumSize);
              checksum.writeInt32LE(utils.blockChecksum(compressed), 0, true);
            }

            // Update the stream checksum
            this.update_Checksum(data);

            this.size += data.length;

            return buf;
          };

          Encoder.prototype._transform = function (data, encoding, done) {
            if (data) {
              // Buffer the incoming data
              this.buffer.push(data);
              this.length += data.length;
            }

            // Stream header
            if (this.first) {
              this.push(this.header());
              this.first = false;
            }

            var blockMaxSize = this.options.blockMaxSize;
            // Not enough data for a block
            if (this.length < blockMaxSize) return done();

            // Build the data to be compressed
            var buf = Buffer.concat(this.buffer, this.length);

            for (
              var j = 0, i = buf.length;
              i >= blockMaxSize;
              i -= blockMaxSize, j += blockMaxSize
            ) {
              // Compress the block
              this.push(
                this.compress_DataBlock(buf.slice(j, j + blockMaxSize)),
              );
            }

            // Set the remaining data
            if (i > 0) {
              this.buffer = [buf.slice(j)];
              this.length = this.buffer[0].length;
            } else {
              this.buffer = [];
              this.length = 0;
            }

            done();
          };

          Encoder.prototype._flush = function (done) {
            if (this.first) {
              this.push(this.header());
              this.first = false;
            }

            if (this.length > 0) {
              var buf = Buffer.concat(this.buffer, this.length);
              this.buffer = [];
              this.length = 0;
              var cc = this.compress_DataBlock(buf);
              this.push(cc);
            }

            if (this.options.streamChecksum) {
              this.state = STATES.CHECKSUM;
              var eos = new Buffer(SIZES.EOS + SIZES.CHECKSUM);
              eos.writeInt32LE(
                utils.streamChecksum(null, this.checksum),
                SIZES.EOS,
                true,
              );
            } else {
              var eos = new Buffer(SIZES.EOS);
            }

            this.state = STATES.EOS;
            eos.writeInt32LE(lz4_static.EOS, 0, true);
            this.push(eos);

            done();
          };

          module.exports = Encoder;
        }).call(this, require("buffer").Buffer);
      },
      { "./binding": 1, "./static": 6, buffer: "buffer", stream: 33, util: 36 },
    ],
    6: [
      function (require, module, exports) {
        (function (Buffer) {
          /**
           * LZ4 based compression and decompression
           * Copyright (c) 2014 Pierre Curto
           * MIT Licensed
           */

          // LZ4 stream constants
          exports.MAGICNUMBER = 0x184d2204;
          exports.MAGICNUMBER_BUFFER = new Buffer(4);
          exports.MAGICNUMBER_BUFFER.writeUInt32LE(
            exports.MAGICNUMBER,
            0,
            false,
          );

          exports.EOS = 0;
          exports.EOS_BUFFER = new Buffer(4);
          exports.EOS_BUFFER.writeUInt32LE(exports.EOS, 0, false);

          exports.VERSION = 1;

          exports.MAGICNUMBER_SKIPPABLE = 0x184d2a50;

          // n/a, n/a, n/a, n/a, 64KB, 256KB, 1MB, 4MB
          exports.blockMaxSizes = [
            null,
            null,
            null,
            null,
            64 << 10,
            256 << 10,
            1 << 20,
            4 << 20,
          ];

          // Compressed file extension
          exports.extension = ".lz4";

          // Internal stream states
          exports.STATES = {
            // Compressed stream
            MAGIC: 0,
            DESCRIPTOR: 1,
            SIZE: 2,
            DICTID: 3,
            DESCRIPTOR_CHECKSUM: 4,
            DATABLOCK_SIZE: 5,
            DATABLOCK_DATA: 6,
            DATABLOCK_CHECKSUM: 7,
            DATABLOCK_UNCOMPRESS: 8,
            DATABLOCK_COMPRESS: 9,
            CHECKSUM: 10,
            CHECKSUM_UPDATE: 11,
            EOS: 90,
            // Skippable chunk
            SKIP_SIZE: 101,
            SKIP_DATA: 102,
          };

          exports.SIZES = {
            MAGIC: 4,
            DESCRIPTOR: 2,
            SIZE: 8,
            DICTID: 4,
            DESCRIPTOR_CHECKSUM: 1,
            DATABLOCK_SIZE: 4,
            DATABLOCK_CHECKSUM: 4,
            CHECKSUM: 4,
            EOS: 4,
            SKIP_SIZE: 4,
          };

          exports.utils = require("./utils");
        }).call(this, require("buffer").Buffer);
      },
      { "./utils": "./utils", buffer: "buffer" },
    ],
    7: [
      function (require, module, exports) {
        exports.UINT32 = require("./lib/uint32");
        exports.UINT64 = require("./lib/uint64");
      },
      { "./lib/uint32": 8, "./lib/uint64": 9 },
    ],
    8: [
      function (require, module, exports) {
        /**
	C-like unsigned 32 bits integers in Javascript
	Copyright (C) 2013, Pierre Curto
	MIT license
 */
        (function (root) {
          // Local cache for typical radices
          var radixPowerCache = {
            36: UINT32(Math.pow(36, 5)),
            16: UINT32(Math.pow(16, 7)),
            10: UINT32(Math.pow(10, 9)),
            2: UINT32(Math.pow(2, 30)),
          };
          var radixCache = {
            36: UINT32(36),
            16: UINT32(16),
            10: UINT32(10),
            2: UINT32(2),
          };

          /**
           *	Represents an unsigned 32 bits integer
           * @constructor
           * @param {Number|String|Number} low bits     | integer as a string 		 | integer as a number
           * @param {Number|Number|Undefined} high bits | radix (optional, default=10)
           * @return
           */
          function UINT32(l, h) {
            if (!(this instanceof UINT32)) return new UINT32(l, h);

            this._low = 0;
            this._high = 0;
            this.remainder = null;
            if (typeof h == "undefined") return fromNumber.call(this, l);

            if (typeof l == "string") return fromString.call(this, l, h);

            fromBits.call(this, l, h);
          }

          /**
           * Set the current _UINT32_ object with its low and high bits
           * @method fromBits
           * @param {Number} low bits
           * @param {Number} high bits
           * @return ThisExpression
           */
          function fromBits(l, h) {
            this._low = l | 0;
            this._high = h | 0;

            return this;
          }
          UINT32.prototype.fromBits = fromBits;

          /**
           * Set the current _UINT32_ object from a number
           * @method fromNumber
           * @param {Number} number
           * @return ThisExpression
           */
          function fromNumber(value) {
            this._low = value & 0xffff;
            this._high = value >>> 16;

            return this;
          }
          UINT32.prototype.fromNumber = fromNumber;

          /**
           * Set the current _UINT32_ object from a string
           * @method fromString
           * @param {String} integer as a string
           * @param {Number} radix (optional, default=10)
           * @return ThisExpression
           */
          function fromString(s, radix) {
            var value = parseInt(s, radix || 10);

            this._low = value & 0xffff;
            this._high = value >>> 16;

            return this;
          }
          UINT32.prototype.fromString = fromString;

          /**
           * Convert this _UINT32_ to a number
           * @method toNumber
           * @return {Number} the converted UINT32
           */
          UINT32.prototype.toNumber = function () {
            return (this._high << 16) | this._low;
          };

          /**
           * Convert this _UINT32_ to a string
           * @method toString
           * @param {Number} radix (optional, default=10)
           * @return {String} the converted UINT32
           */
          UINT32.prototype.toString = function (radix) {
            radix = radix || 10;
            var radixUint = radixCache[radix] || new UINT32(radix);

            if (!this.gt(radixUint)) return this.toNumber().toString(radix);

            var self = this.clone();
            var res = new Array(32);
            for (var i = 31; i >= 0; i--) {
              self.div(radixUint);
              res[i] = self.remainder.toNumber().toString(radix);
              if (!self.gt(radixUint)) break;
            }
            res[i - 1] = self.toNumber().toString(radix);

            return res.join("");
          };

          /**
           * Add two _UINT32_. The current _UINT32_ stores the result
           * @method add
           * @param {Object} other UINT32
           * @return ThisExpression
           */
          UINT32.prototype.add = function (other) {
            var a00 = this._low + other._low;
            var a16 = a00 >>> 16;

            a16 += this._high + other._high;

            this._low = a00 & 0xffff;
            this._high = a16 & 0xffff;

            return this;
          };

          /**
           * Subtract two _UINT32_. The current _UINT32_ stores the result
           * @method subtract
           * @param {Object} other UINT32
           * @return ThisExpression
           */
          UINT32.prototype.subtract = function (other) {
            //TODO inline
            return this.add(other.clone().negate());
          };

          /**
           * Multiply two _UINT32_. The current _UINT32_ stores the result
           * @method multiply
           * @param {Object} other UINT32
           * @return ThisExpression
           */
          UINT32.prototype.multiply = function (other) {
            /*
			a = a00 + a16
			b = b00 + b16
			a*b = (a00 + a16)(b00 + b16)
				= a00b00 + a00b16 + a16b00 + a16b16

			a16b16 overflows the 32bits
		 */
            var a16 = this._high;
            var a00 = this._low;
            var b16 = other._high;
            var b00 = other._low;

            /* Removed to increase speed under normal circumstances (i.e. not multiplying by 0 or 1)
		// this == 0 or other == 1: nothing to do
		if ((a00 == 0 && a16 == 0) || (b00 == 1 && b16 == 0)) return this

		// other == 0 or this == 1: this = other
		if ((b00 == 0 && b16 == 0) || (a00 == 1 && a16 == 0)) {
			this._low = other._low
			this._high = other._high
			return this
		}
*/

            var c16, c00;
            c00 = a00 * b00;
            c16 = c00 >>> 16;

            c16 += a16 * b00;
            c16 &= 0xffff; // Not required but improves performance
            c16 += a00 * b16;

            this._low = c00 & 0xffff;
            this._high = c16 & 0xffff;

            return this;
          };

          /**
           * Divide two _UINT32_. The current _UINT32_ stores the result.
           * The remainder is made available as the _remainder_ property on
           * the _UINT32_ object. It can be null, meaning there are no remainder.
           * @method div
           * @param {Object} other UINT32
           * @return ThisExpression
           */
          UINT32.prototype.div = function (other) {
            if (other._low == 0 && other._high == 0)
              throw Error("division by zero");

            // other == 1
            if (other._high == 0 && other._low == 1) {
              this.remainder = new UINT32(0);
              return this;
            }

            // other > this: 0
            if (other.gt(this)) {
              this.remainder = new UINT32(0);
              this._low = 0;
              this._high = 0;
              return this;
            }
            // other == this: 1
            if (this.eq(other)) {
              this.remainder = new UINT32(0);
              this._low = 1;
              this._high = 0;
              return this;
            }

            // Shift the divisor left until it is higher than the dividend
            var _other = other.clone();
            var i = -1;
            while (!this.lt(_other)) {
              // High bit can overflow the default 16bits
              // Its ok since we right shift after this loop
              // The overflown bit must be kept though
              _other.shiftLeft(1, true);
              i++;
            }

            // Set the remainder
            this.remainder = this.clone();
            // Initialize the current result to 0
            this._low = 0;
            this._high = 0;
            for (; i >= 0; i--) {
              _other.shiftRight(1);
              // If shifted divisor is smaller than the dividend
              // then subtract it from the dividend
              if (!this.remainder.lt(_other)) {
                this.remainder.subtract(_other);
                // Update the current result
                if (i >= 16) {
                  this._high |= 1 << (i - 16);
                } else {
                  this._low |= 1 << i;
                }
              }
            }

            return this;
          };

          /**
           * Negate the current _UINT32_
           * @method negate
           * @return ThisExpression
           */
          UINT32.prototype.negate = function () {
            var v = (~this._low & 0xffff) + 1;
            this._low = v & 0xffff;
            this._high = (~this._high + (v >>> 16)) & 0xffff;

            return this;
          };

          /**
           * Equals
           * @method eq
           * @param {Object} other UINT32
           * @return {Boolean}
           */
          UINT32.prototype.equals = UINT32.prototype.eq = function (other) {
            return this._low == other._low && this._high == other._high;
          };

          /**
           * Greater than (strict)
           * @method gt
           * @param {Object} other UINT32
           * @return {Boolean}
           */
          UINT32.prototype.greaterThan = UINT32.prototype.gt = function (
            other,
          ) {
            if (this._high > other._high) return true;
            if (this._high < other._high) return false;
            return this._low > other._low;
          };

          /**
           * Less than (strict)
           * @method lt
           * @param {Object} other UINT32
           * @return {Boolean}
           */
          UINT32.prototype.lessThan = UINT32.prototype.lt = function (other) {
            if (this._high < other._high) return true;
            if (this._high > other._high) return false;
            return this._low < other._low;
          };

          /**
           * Bitwise OR
           * @method or
           * @param {Object} other UINT32
           * @return ThisExpression
           */
          UINT32.prototype.or = function (other) {
            this._low |= other._low;
            this._high |= other._high;

            return this;
          };

          /**
           * Bitwise AND
           * @method and
           * @param {Object} other UINT32
           * @return ThisExpression
           */
          UINT32.prototype.and = function (other) {
            this._low &= other._low;
            this._high &= other._high;

            return this;
          };

          /**
           * Bitwise NOT
           * @method not
           * @return ThisExpression
           */
          UINT32.prototype.not = function () {
            this._low = ~this._low & 0xffff;
            this._high = ~this._high & 0xffff;

            return this;
          };

          /**
           * Bitwise XOR
           * @method xor
           * @param {Object} other UINT32
           * @return ThisExpression
           */
          UINT32.prototype.xor = function (other) {
            this._low ^= other._low;
            this._high ^= other._high;

            return this;
          };

          /**
           * Bitwise shift right
           * @method shiftRight
           * @param {Number} number of bits to shift
           * @return ThisExpression
           */
          UINT32.prototype.shiftRight = UINT32.prototype.shiftr = function (n) {
            if (n > 16) {
              this._low = this._high >> (n - 16);
              this._high = 0;
            } else if (n == 16) {
              this._low = this._high;
              this._high = 0;
            } else {
              this._low =
                (this._low >> n) | ((this._high << (16 - n)) & 0xffff);
              this._high >>= n;
            }

            return this;
          };

          /**
           * Bitwise shift left
           * @method shiftLeft
           * @param {Number} number of bits to shift
           * @param {Boolean} allow overflow
           * @return ThisExpression
           */
          UINT32.prototype.shiftLeft = UINT32.prototype.shiftl = function (
            n,
            allowOverflow,
          ) {
            if (n > 16) {
              this._high = this._low << (n - 16);
              this._low = 0;
              if (!allowOverflow) {
                this._high &= 0xffff;
              }
            } else if (n == 16) {
              this._high = this._low;
              this._low = 0;
            } else {
              this._high = (this._high << n) | (this._low >> (16 - n));
              this._low = (this._low << n) & 0xffff;
              if (!allowOverflow) {
                // Overflow only allowed on the high bits...
                this._high &= 0xffff;
              }
            }

            return this;
          };

          /**
           * Bitwise rotate left
           * @method rotl
           * @param {Number} number of bits to rotate
           * @return ThisExpression
           */
          UINT32.prototype.rotateLeft = UINT32.prototype.rotl = function (n) {
            var v = (this._high << 16) | this._low;
            v = (v << n) | (v >>> (32 - n));
            this._low = v & 0xffff;
            this._high = v >>> 16;

            return this;
          };

          /**
           * Bitwise rotate right
           * @method rotr
           * @param {Number} number of bits to rotate
           * @return ThisExpression
           */
          UINT32.prototype.rotateRight = UINT32.prototype.rotr = function (n) {
            var v = (this._high << 16) | this._low;
            v = (v >>> n) | (v << (32 - n));
            this._low = v & 0xffff;
            this._high = v >>> 16;

            return this;
          };

          /**
           * Clone the current _UINT32_
           * @method clone
           * @return {Object} cloned UINT32
           */
          UINT32.prototype.clone = function () {
            return new UINT32(this._low, this._high);
          };

          if (typeof define != "undefined" && define.amd) {
            // AMD / RequireJS
            define([], function () {
              return UINT32;
            });
          } else if (typeof module != "undefined" && module.exports) {
            // Node.js
            module.exports = UINT32;
          } else {
            // Browser
            root["UINT32"] = UINT32;
          }
        })(this);
      },
      {},
    ],
    9: [
      function (require, module, exports) {
        /**
	C-like unsigned 64 bits integers in Javascript
	Copyright (C) 2013, Pierre Curto
	MIT license
 */
        (function (root) {
          // Local cache for typical radices
          var radixPowerCache = {
            16: UINT64(Math.pow(16, 5)),
            10: UINT64(Math.pow(10, 5)),
            2: UINT64(Math.pow(2, 5)),
          };
          var radixCache = {
            16: UINT64(16),
            10: UINT64(10),
            2: UINT64(2),
          };

          /**
           *	Represents an unsigned 64 bits integer
           * @constructor
           * @param {Number} first low bits (8)
           * @param {Number} second low bits (8)
           * @param {Number} first high bits (8)
           * @param {Number} second high bits (8)
           * or
           * @param {Number} low bits (32)
           * @param {Number} high bits (32)
           * or
           * @param {String|Number} integer as a string 		 | integer as a number
           * @param {Number|Undefined} radix (optional, default=10)
           * @return
           */
          function UINT64(a00, a16, a32, a48) {
            if (!(this instanceof UINT64))
              return new UINT64(a00, a16, a32, a48);

            this.remainder = null;
            if (typeof a00 == "string") return fromString.call(this, a00, a16);

            if (typeof a16 == "undefined") return fromNumber.call(this, a00);

            fromBits.apply(this, arguments);
          }

          /**
           * Set the current _UINT64_ object with its low and high bits
           * @method fromBits
           * @param {Number} first low bits (8)
           * @param {Number} second low bits (8)
           * @param {Number} first high bits (8)
           * @param {Number} second high bits (8)
           * or
           * @param {Number} low bits (32)
           * @param {Number} high bits (32)
           * @return ThisExpression
           */
          function fromBits(a00, a16, a32, a48) {
            if (typeof a32 == "undefined") {
              this._a00 = a00 & 0xffff;
              this._a16 = a00 >>> 16;
              this._a32 = a16 & 0xffff;
              this._a48 = a16 >>> 16;
              return this;
            }

            this._a00 = a00 | 0;
            this._a16 = a16 | 0;
            this._a32 = a32 | 0;
            this._a48 = a48 | 0;

            return this;
          }
          UINT64.prototype.fromBits = fromBits;

          /**
           * Set the current _UINT64_ object from a number
           * @method fromNumber
           * @param {Number} number
           * @return ThisExpression
           */
          function fromNumber(value) {
            this._a00 = value & 0xffff;
            this._a16 = value >>> 16;
            this._a32 = 0;
            this._a48 = 0;

            return this;
          }
          UINT64.prototype.fromNumber = fromNumber;

          /**
           * Set the current _UINT64_ object from a string
           * @method fromString
           * @param {String} integer as a string
           * @param {Number} radix (optional, default=10)
           * @return ThisExpression
           */
          function fromString(s, radix) {
            radix = radix || 10;

            this._a00 = 0;
            this._a16 = 0;
            this._a32 = 0;
            this._a48 = 0;

            /*
			In Javascript, bitwise operators only operate on the first 32 bits
			of a number, even though parseInt() encodes numbers with a 53 bits
			mantissa.
			Therefore UINT64(<Number>) can only work on 32 bits.
			The radix maximum value is 36 (as per ECMA specs) (26 letters + 10 digits)
			maximum input value is m = 32bits as 1 = 2^32 - 1
			So the maximum substring length n is:
			36^(n+1) - 1 = 2^32 - 1
			36^(n+1) = 2^32
			(n+1)ln(36) = 32ln(2)
			n = 32ln(2)/ln(36) - 1
			n = 5.189644915687692
			n = 5
		 */
            var radixUint =
              radixPowerCache[radix] || new UINT64(Math.pow(radix, 5));

            for (var i = 0, len = s.length; i < len; i += 5) {
              var size = Math.min(5, len - i);
              var value = parseInt(s.slice(i, i + size), radix);
              this.multiply(
                size < 5 ? new UINT64(Math.pow(radix, size)) : radixUint,
              ).add(new UINT64(value));
            }

            return this;
          }
          UINT64.prototype.fromString = fromString;

          /**
           * Convert this _UINT64_ to a number (last 32 bits are dropped)
           * @method toNumber
           * @return {Number} the converted UINT64
           */
          UINT64.prototype.toNumber = function () {
            return (this._a16 << 16) | this._a00;
          };

          /**
           * Convert this _UINT64_ to a string
           * @method toString
           * @param {Number} radix (optional, default=10)
           * @return {String} the converted UINT64
           */
          UINT64.prototype.toString = function (radix) {
            radix = radix || 10;
            var radixUint = radixCache[radix] || new UINT64(radix);

            if (!this.gt(radixUint)) return this.toNumber().toString(radix);

            var self = this.clone();
            var res = new Array(64);
            for (var i = 63; i >= 0; i--) {
              self.div(radixUint);
              res[i] = self.remainder.toNumber().toString(radix);
              if (!self.gt(radixUint)) break;
            }
            res[i - 1] = self.toNumber().toString(radix);

            return res.join("");
          };

          /**
           * Add two _UINT64_. The current _UINT64_ stores the result
           * @method add
           * @param {Object} other UINT64
           * @return ThisExpression
           */
          UINT64.prototype.add = function (other) {
            var a00 = this._a00 + other._a00;

            var a16 = a00 >>> 16;
            a16 += this._a16 + other._a16;

            var a32 = a16 >>> 16;
            a32 += this._a32 + other._a32;

            var a48 = a32 >>> 16;
            a48 += this._a48 + other._a48;

            this._a00 = a00 & 0xffff;
            this._a16 = a16 & 0xffff;
            this._a32 = a32 & 0xffff;
            this._a48 = a48 & 0xffff;

            return this;
          };

          /**
           * Subtract two _UINT64_. The current _UINT64_ stores the result
           * @method subtract
           * @param {Object} other UINT64
           * @return ThisExpression
           */
          UINT64.prototype.subtract = function (other) {
            return this.add(other.clone().negate());
          };

          /**
           * Multiply two _UINT64_. The current _UINT64_ stores the result
           * @method multiply
           * @param {Object} other UINT64
           * @return ThisExpression
           */
          UINT64.prototype.multiply = function (other) {
            /*
			a = a00 + a16 + a32 + a48
			b = b00 + b16 + b32 + b48
			a*b = (a00 + a16 + a32 + a48)(b00 + b16 + b32 + b48)
				= a00b00 + a00b16 + a00b32 + a00b48
				+ a16b00 + a16b16 + a16b32 + a16b48
				+ a32b00 + a32b16 + a32b32 + a32b48
				+ a48b00 + a48b16 + a48b32 + a48b48

			a16b48, a32b32, a48b16, a48b32 and a48b48 overflow the 64 bits
			so it comes down to:
			a*b	= a00b00 + a00b16 + a00b32 + a00b48
				+ a16b00 + a16b16 + a16b32
				+ a32b00 + a32b16
				+ a48b00
				= a00b00
				+ a00b16 + a16b00
				+ a00b32 + a16b16 + a32b00
				+ a00b48 + a16b32 + a32b16 + a48b00
		 */
            var a00 = this._a00;
            var a16 = this._a16;
            var a32 = this._a32;
            var a48 = this._a48;
            var b00 = other._a00;
            var b16 = other._a16;
            var b32 = other._a32;
            var b48 = other._a48;

            var c00 = a00 * b00;

            var c16 = c00 >>> 16;
            c16 += a00 * b16;
            var c32 = c16 >>> 16;
            c16 &= 0xffff;
            c16 += a16 * b00;

            c32 += c16 >>> 16;
            c32 += a00 * b32;
            var c48 = c32 >>> 16;
            c32 &= 0xffff;
            c32 += a16 * b16;
            c48 += c32 >>> 16;
            c32 &= 0xffff;
            c32 += a32 * b00;

            c48 += c32 >>> 16;
            c48 += a00 * b48;
            c48 &= 0xffff;
            c48 += a16 * b32;
            c48 &= 0xffff;
            c48 += a32 * b16;
            c48 &= 0xffff;
            c48 += a48 * b00;

            this._a00 = c00 & 0xffff;
            this._a16 = c16 & 0xffff;
            this._a32 = c32 & 0xffff;
            this._a48 = c48 & 0xffff;

            return this;
          };

          /**
           * Divide two _UINT64_. The current _UINT64_ stores the result.
           * The remainder is made available as the _remainder_ property on
           * the _UINT64_ object. It can be null, meaning there are no remainder.
           * @method div
           * @param {Object} other UINT64
           * @return ThisExpression
           */
          UINT64.prototype.div = function (other) {
            if (other._a16 == 0 && other._a32 == 0 && other._a48 == 0) {
              if (other._a00 == 0) throw Error("division by zero");

              // other == 1: this
              if (other._a00 == 1) {
                this.remainder = new UINT64(0);
                return this;
              }
            }

            // other > this: 0
            if (other.gt(this)) {
              this.remainder = new UINT64(0);
              this._a00 = 0;
              this._a16 = 0;
              this._a32 = 0;
              this._a48 = 0;
              return this;
            }
            // other == this: 1
            if (this.eq(other)) {
              this.remainder = new UINT64(0);
              this._a00 = 1;
              this._a16 = 0;
              this._a32 = 0;
              this._a48 = 0;
              return this;
            }

            // Shift the divisor left until it is higher than the dividend
            var _other = other.clone();
            var i = -1;
            while (!this.lt(_other)) {
              // High bit can overflow the default 16bits
              // Its ok since we right shift after this loop
              // The overflown bit must be kept though
              _other.shiftLeft(1, true);
              i++;
            }

            // Set the remainder
            this.remainder = this.clone();
            // Initialize the current result to 0
            this._a00 = 0;
            this._a16 = 0;
            this._a32 = 0;
            this._a48 = 0;
            for (; i >= 0; i--) {
              _other.shiftRight(1);
              // If shifted divisor is smaller than the dividend
              // then subtract it from the dividend
              if (!this.remainder.lt(_other)) {
                this.remainder.subtract(_other);
                // Update the current result
                if (i >= 48) {
                  this._a48 |= 1 << (i - 48);
                } else if (i >= 32) {
                  this._a32 |= 1 << (i - 32);
                } else if (i >= 16) {
                  this._a16 |= 1 << (i - 16);
                } else {
                  this._a00 |= 1 << i;
                }
              }
            }

            return this;
          };

          /**
           * Negate the current _UINT64_
           * @method negate
           * @return ThisExpression
           */
          UINT64.prototype.negate = function () {
            var v = (~this._a00 & 0xffff) + 1;
            this._a00 = v & 0xffff;
            v = (~this._a16 & 0xffff) + (v >>> 16);
            this._a16 = v & 0xffff;
            v = (~this._a32 & 0xffff) + (v >>> 16);
            this._a32 = v & 0xffff;
            this._a48 = (~this._a48 + (v >>> 16)) & 0xffff;

            return this;
          };

          /**

	 * @method eq
	 * @param {Object} other UINT64
	 * @return {Boolean}
	 */
          UINT64.prototype.equals = UINT64.prototype.eq = function (other) {
            return (
              this._a48 == other._a48 &&
              this._a00 == other._a00 &&
              this._a32 == other._a32 &&
              this._a16 == other._a16
            );
          };

          /**
           * Greater than (strict)
           * @method gt
           * @param {Object} other UINT64
           * @return {Boolean}
           */
          UINT64.prototype.greaterThan = UINT64.prototype.gt = function (
            other,
          ) {
            if (this._a48 > other._a48) return true;
            if (this._a48 < other._a48) return false;
            if (this._a32 > other._a32) return true;
            if (this._a32 < other._a32) return false;
            if (this._a16 > other._a16) return true;
            if (this._a16 < other._a16) return false;
            return this._a00 > other._a00;
          };

          /**
           * Less than (strict)
           * @method lt
           * @param {Object} other UINT64
           * @return {Boolean}
           */
          UINT64.prototype.lessThan = UINT64.prototype.lt = function (other) {
            if (this._a48 < other._a48) return true;
            if (this._a48 > other._a48) return false;
            if (this._a32 < other._a32) return true;
            if (this._a32 > other._a32) return false;
            if (this._a16 < other._a16) return true;
            if (this._a16 > other._a16) return false;
            return this._a00 < other._a00;
          };

          /**
           * Bitwise OR
           * @method or
           * @param {Object} other UINT64
           * @return ThisExpression
           */
          UINT64.prototype.or = function (other) {
            this._a00 |= other._a00;
            this._a16 |= other._a16;
            this._a32 |= other._a32;
            this._a48 |= other._a48;

            return this;
          };

          /**
           * Bitwise AND
           * @method and
           * @param {Object} other UINT64
           * @return ThisExpression
           */
          UINT64.prototype.and = function (other) {
            this._a00 &= other._a00;
            this._a16 &= other._a16;
            this._a32 &= other._a32;
            this._a48 &= other._a48;

            return this;
          };

          /**
           * Bitwise XOR
           * @method xor
           * @param {Object} other UINT64
           * @return ThisExpression
           */
          UINT64.prototype.xor = function (other) {
            this._a00 ^= other._a00;
            this._a16 ^= other._a16;
            this._a32 ^= other._a32;
            this._a48 ^= other._a48;

            return this;
          };

          /**
           * Bitwise NOT
           * @method not
           * @return ThisExpression
           */
          UINT64.prototype.not = function () {
            this._a00 = ~this._a00 & 0xffff;
            this._a16 = ~this._a16 & 0xffff;
            this._a32 = ~this._a32 & 0xffff;
            this._a48 = ~this._a48 & 0xffff;

            return this;
          };

          /**
           * Bitwise shift right
           * @method shiftRight
           * @param {Number} number of bits to shift
           * @return ThisExpression
           */
          UINT64.prototype.shiftRight = UINT64.prototype.shiftr = function (n) {
            n %= 64;
            if (n >= 48) {
              this._a00 = this._a48 >> (n - 48);
              this._a16 = 0;
              this._a32 = 0;
              this._a48 = 0;
            } else if (n >= 32) {
              n -= 32;
              this._a00 = ((this._a32 >> n) | (this._a48 << (16 - n))) & 0xffff;
              this._a16 = (this._a48 >> n) & 0xffff;
              this._a32 = 0;
              this._a48 = 0;
            } else if (n >= 16) {
              n -= 16;
              this._a00 = ((this._a16 >> n) | (this._a32 << (16 - n))) & 0xffff;
              this._a16 = ((this._a32 >> n) | (this._a48 << (16 - n))) & 0xffff;
              this._a32 = (this._a48 >> n) & 0xffff;
              this._a48 = 0;
            } else {
              this._a00 = ((this._a00 >> n) | (this._a16 << (16 - n))) & 0xffff;
              this._a16 = ((this._a16 >> n) | (this._a32 << (16 - n))) & 0xffff;
              this._a32 = ((this._a32 >> n) | (this._a48 << (16 - n))) & 0xffff;
              this._a48 = (this._a48 >> n) & 0xffff;
            }

            return this;
          };

          /**
           * Bitwise shift left
           * @method shiftLeft
           * @param {Number} number of bits to shift
           * @param {Boolean} allow overflow
           * @return ThisExpression
           */
          UINT64.prototype.shiftLeft = UINT64.prototype.shiftl = function (
            n,
            allowOverflow,
          ) {
            n %= 64;
            if (n >= 48) {
              this._a48 = this._a00 << (n - 48);
              this._a32 = 0;
              this._a16 = 0;
              this._a00 = 0;
            } else if (n >= 32) {
              n -= 32;
              this._a48 = (this._a16 << n) | (this._a00 >> (16 - n));
              this._a32 = (this._a00 << n) & 0xffff;
              this._a16 = 0;
              this._a00 = 0;
            } else if (n >= 16) {
              n -= 16;
              this._a48 = (this._a32 << n) | (this._a16 >> (16 - n));
              this._a32 = ((this._a16 << n) | (this._a00 >> (16 - n))) & 0xffff;
              this._a16 = (this._a00 << n) & 0xffff;
              this._a00 = 0;
            } else {
              this._a48 = (this._a48 << n) | (this._a32 >> (16 - n));
              this._a32 = ((this._a32 << n) | (this._a16 >> (16 - n))) & 0xffff;
              this._a16 = ((this._a16 << n) | (this._a00 >> (16 - n))) & 0xffff;
              this._a00 = (this._a00 << n) & 0xffff;
            }
            if (!allowOverflow) {
              this._a48 &= 0xffff;
            }

            return this;
          };

          /**
           * Bitwise rotate left
           * @method rotl
           * @param {Number} number of bits to rotate
           * @return ThisExpression
           */
          UINT64.prototype.rotateLeft = UINT64.prototype.rotl = function (n) {
            n %= 64;
            if (n == 0) return this;
            if (n >= 32) {
              // A.B.C.D
              // B.C.D.A rotl(16)
              // C.D.A.B rotl(32)
              var v = this._a00;
              this._a00 = this._a32;
              this._a32 = v;
              v = this._a48;
              this._a48 = this._a16;
              this._a16 = v;
              if (n == 32) return this;
              n -= 32;
            }

            var high = (this._a48 << 16) | this._a32;
            var low = (this._a16 << 16) | this._a00;

            var _high = (high << n) | (low >>> (32 - n));
            var _low = (low << n) | (high >>> (32 - n));

            this._a00 = _low & 0xffff;
            this._a16 = _low >>> 16;
            this._a32 = _high & 0xffff;
            this._a48 = _high >>> 16;

            return this;
          };

          /**
           * Bitwise rotate right
           * @method rotr
           * @param {Number} number of bits to rotate
           * @return ThisExpression
           */
          UINT64.prototype.rotateRight = UINT64.prototype.rotr = function (n) {
            n %= 64;
            if (n == 0) return this;
            if (n >= 32) {
              // A.B.C.D
              // D.A.B.C rotr(16)
              // C.D.A.B rotr(32)
              var v = this._a00;
              this._a00 = this._a32;
              this._a32 = v;
              v = this._a48;
              this._a48 = this._a16;
              this._a16 = v;
              if (n == 32) return this;
              n -= 32;
            }

            var high = (this._a48 << 16) | this._a32;
            var low = (this._a16 << 16) | this._a00;

            var _high = (high >>> n) | (low << (32 - n));
            var _low = (low >>> n) | (high << (32 - n));

            this._a00 = _low & 0xffff;
            this._a16 = _low >>> 16;
            this._a32 = _high & 0xffff;
            this._a48 = _high >>> 16;

            return this;
          };

          /**
           * Clone the current _UINT64_
           * @method clone
           * @return {Object} cloned UINT64
           */
          UINT64.prototype.clone = function () {
            return new UINT64(this._a00, this._a16, this._a32, this._a48);
          };

          if (typeof define != "undefined" && define.amd) {
            // AMD / RequireJS
            define([], function () {
              return UINT64;
            });
          } else if (typeof module != "undefined" && module.exports) {
            // Node.js
            module.exports = UINT64;
          } else {
            // Browser
            root["UINT64"] = UINT64;
          }
        })(this);
      },
      {},
    ],
    10: [
      function (require, module, exports) {
        (function (Buffer) {
          /**
	xxHash implementation in pure Javascript

	Copyright (C) 2013, Pierre Curto
	MIT license
 */
          (function (root) {
            var UINT32 = require("cuint").UINT32;

            /*
		Merged this sequence of method calls as it speeds up
		the calculations by a factor of 2
	 */
            // this.v1.add( other.multiply(PRIME32_2) ).rotl(13).multiply(PRIME32_1);
            UINT32.prototype.xxh_update = function (low, high) {
              var b00 = PRIME32_2._low;
              var b16 = PRIME32_2._high;

              var c16, c00;
              c00 = low * b00;
              c16 = c00 >>> 16;

              c16 += high * b00;
              c16 &= 0xffff; // Not required but improves performance
              c16 += low * b16;

              var a00 = this._low + (c00 & 0xffff);
              var a16 = a00 >>> 16;

              a16 += this._high + (c16 & 0xffff);

              var v = (a16 << 16) | (a00 & 0xffff);
              v = (v << 13) | (v >>> 19);

              a00 = v & 0xffff;
              a16 = v >>> 16;

              b00 = PRIME32_1._low;
              b16 = PRIME32_1._high;

              c00 = a00 * b00;
              c16 = c00 >>> 16;

              c16 += a16 * b00;
              c16 &= 0xffff; // Not required but improves performance
              c16 += a00 * b16;

              this._low = c00 & 0xffff;
              this._high = c16 & 0xffff;
            };

            /*
             * Constants
             */
            var PRIME32_1 = UINT32("2654435761");
            var PRIME32_2 = UINT32("2246822519");
            var PRIME32_3 = UINT32("3266489917");
            var PRIME32_4 = UINT32("668265263");
            var PRIME32_5 = UINT32("374761393");

            var PRIME32_1plus2 = PRIME32_1.clone().add(PRIME32_2);

            /**
             * Convert string to proper UTF-8 array
             * @param str Input string
             * @returns {Uint8Array} UTF8 array is returned as uint8 array
             */
            function toUTF8Array(str) {
              var utf8 = [];
              for (var i = 0, n = str.length; i < n; i++) {
                var charcode = str.charCodeAt(i);
                if (charcode < 0x80) utf8.push(charcode);
                else if (charcode < 0x800) {
                  utf8.push(0xc0 | (charcode >> 6), 0x80 | (charcode & 0x3f));
                } else if (charcode < 0xd800 || charcode >= 0xe000) {
                  utf8.push(
                    0xe0 | (charcode >> 12),
                    0x80 | ((charcode >> 6) & 0x3f),
                    0x80 | (charcode & 0x3f),
                  );
                }
                // surrogate pair
                else {
                  i++;
                  // UTF-16 encodes 0x10000-0x10FFFF by
                  // subtracting 0x10000 and splitting the
                  // 20 bits of 0x0-0xFFFFF into two halves
                  charcode =
                    0x10000 +
                    (((charcode & 0x3ff) << 10) | (str.charCodeAt(i) & 0x3ff));
                  utf8.push(
                    0xf0 | (charcode >> 18),
                    0x80 | ((charcode >> 12) & 0x3f),
                    0x80 | ((charcode >> 6) & 0x3f),
                    0x80 | (charcode & 0x3f),
                  );
                }
              }

              return new Uint8Array(utf8);
            }

            /**
             * XXH object used as a constructor or a function
             * @constructor
             * or
             * @param {Object|String} input data
             * @param {Number|UINT32} seed
             * @return ThisExpression
             * or
             * @return {UINT32} xxHash
             */
            function XXH() {
              if (arguments.length == 2)
                return new XXH(arguments[1]).update(arguments[0]).digest();

              if (!(this instanceof XXH)) return new XXH(arguments[0]);

              init.call(this, arguments[0]);
            }

            /**
             * Initialize the XXH instance with the given seed
             * @method init
             * @param {Number|Object} seed as a number or an unsigned 32 bits integer
             * @return ThisExpression
             */
            function init(seed) {
              this.seed = seed instanceof UINT32 ? seed.clone() : UINT32(seed);
              this.v1 = this.seed.clone().add(PRIME32_1plus2);
              this.v2 = this.seed.clone().add(PRIME32_2);
              this.v3 = this.seed.clone();
              this.v4 = this.seed.clone().subtract(PRIME32_1);
              this.total_len = 0;
              this.memsize = 0;
              this.memory = null;

              return this;
            }
            XXH.prototype.init = init;

            /**
             * Add data to be computed for the XXH hash
             * @method update
             * @param {String|Buffer|ArrayBuffer} input as a string or nodejs Buffer or ArrayBuffer
             * @return ThisExpression
             */
            XXH.prototype.update = function (input) {
              var isString = typeof input == "string";
              var isArrayBuffer;

              // Convert all strings to utf-8 first (issue #5)
              if (isString) {
                input = toUTF8Array(input);
                isString = false;
                isArrayBuffer = true;
              }

              if (
                typeof ArrayBuffer !== "undefined" &&
                input instanceof ArrayBuffer
              ) {
                isArrayBuffer = true;
                input = new Uint8Array(input);
              }

              var p = 0;
              var len = input.length;
              var bEnd = p + len;

              if (len == 0) return this;

              this.total_len += len;

              if (this.memsize == 0) {
                if (isString) {
                  this.memory = "";
                } else if (isArrayBuffer) {
                  this.memory = new Uint8Array(16);
                } else {
                  this.memory = new Buffer(16);
                }
              }

              if (this.memsize + len < 16) {
                // fill in tmp buffer
                // XXH_memcpy(this.memory + this.memsize, input, len)
                if (isString) {
                  this.memory += input;
                } else if (isArrayBuffer) {
                  this.memory.set(input.subarray(0, len), this.memsize);
                } else {
                  input.copy(this.memory, this.memsize, 0, len);
                }

                this.memsize += len;
                return this;
              }

              if (this.memsize > 0) {
                // some data left from previous update
                // XXH_memcpy(this.memory + this.memsize, input, 16-this.memsize);
                if (isString) {
                  this.memory += input.slice(0, 16 - this.memsize);
                } else if (isArrayBuffer) {
                  this.memory.set(
                    input.subarray(0, 16 - this.memsize),
                    this.memsize,
                  );
                } else {
                  input.copy(this.memory, this.memsize, 0, 16 - this.memsize);
                }

                var p32 = 0;
                if (isString) {
                  this.v1.xxh_update(
                    (this.memory.charCodeAt(p32 + 1) << 8) |
                      this.memory.charCodeAt(p32),
                    (this.memory.charCodeAt(p32 + 3) << 8) |
                      this.memory.charCodeAt(p32 + 2),
                  );
                  p32 += 4;
                  this.v2.xxh_update(
                    (this.memory.charCodeAt(p32 + 1) << 8) |
                      this.memory.charCodeAt(p32),
                    (this.memory.charCodeAt(p32 + 3) << 8) |
                      this.memory.charCodeAt(p32 + 2),
                  );
                  p32 += 4;
                  this.v3.xxh_update(
                    (this.memory.charCodeAt(p32 + 1) << 8) |
                      this.memory.charCodeAt(p32),
                    (this.memory.charCodeAt(p32 + 3) << 8) |
                      this.memory.charCodeAt(p32 + 2),
                  );
                  p32 += 4;
                  this.v4.xxh_update(
                    (this.memory.charCodeAt(p32 + 1) << 8) |
                      this.memory.charCodeAt(p32),
                    (this.memory.charCodeAt(p32 + 3) << 8) |
                      this.memory.charCodeAt(p32 + 2),
                  );
                } else {
                  this.v1.xxh_update(
                    (this.memory[p32 + 1] << 8) | this.memory[p32],
                    (this.memory[p32 + 3] << 8) | this.memory[p32 + 2],
                  );
                  p32 += 4;
                  this.v2.xxh_update(
                    (this.memory[p32 + 1] << 8) | this.memory[p32],
                    (this.memory[p32 + 3] << 8) | this.memory[p32 + 2],
                  );
                  p32 += 4;
                  this.v3.xxh_update(
                    (this.memory[p32 + 1] << 8) | this.memory[p32],
                    (this.memory[p32 + 3] << 8) | this.memory[p32 + 2],
                  );
                  p32 += 4;
                  this.v4.xxh_update(
                    (this.memory[p32 + 1] << 8) | this.memory[p32],
                    (this.memory[p32 + 3] << 8) | this.memory[p32 + 2],
                  );
                }

                p += 16 - this.memsize;
                this.memsize = 0;
                if (isString) this.memory = "";
              }

              if (p <= bEnd - 16) {
                var limit = bEnd - 16;

                do {
                  if (isString) {
                    this.v1.xxh_update(
                      (input.charCodeAt(p + 1) << 8) | input.charCodeAt(p),
                      (input.charCodeAt(p + 3) << 8) | input.charCodeAt(p + 2),
                    );
                    p += 4;
                    this.v2.xxh_update(
                      (input.charCodeAt(p + 1) << 8) | input.charCodeAt(p),
                      (input.charCodeAt(p + 3) << 8) | input.charCodeAt(p + 2),
                    );
                    p += 4;
                    this.v3.xxh_update(
                      (input.charCodeAt(p + 1) << 8) | input.charCodeAt(p),
                      (input.charCodeAt(p + 3) << 8) | input.charCodeAt(p + 2),
                    );
                    p += 4;
                    this.v4.xxh_update(
                      (input.charCodeAt(p + 1) << 8) | input.charCodeAt(p),
                      (input.charCodeAt(p + 3) << 8) | input.charCodeAt(p + 2),
                    );
                  } else {
                    this.v1.xxh_update(
                      (input[p + 1] << 8) | input[p],
                      (input[p + 3] << 8) | input[p + 2],
                    );
                    p += 4;
                    this.v2.xxh_update(
                      (input[p + 1] << 8) | input[p],
                      (input[p + 3] << 8) | input[p + 2],
                    );
                    p += 4;
                    this.v3.xxh_update(
                      (input[p + 1] << 8) | input[p],
                      (input[p + 3] << 8) | input[p + 2],
                    );
                    p += 4;
                    this.v4.xxh_update(
                      (input[p + 1] << 8) | input[p],
                      (input[p + 3] << 8) | input[p + 2],
                    );
                  }
                  p += 4;
                } while (p <= limit);
              }

              if (p < bEnd) {
                // XXH_memcpy(this.memory, p, bEnd-p);
                if (isString) {
                  this.memory += input.slice(p);
                } else if (isArrayBuffer) {
                  this.memory.set(input.subarray(p, bEnd), this.memsize);
                } else {
                  input.copy(this.memory, this.memsize, p, bEnd);
                }

                this.memsize = bEnd - p;
              }

              return this;
            };

            /**
             * Finalize the XXH computation. The XXH instance is ready for reuse for the given seed
             * @method digest
             * @return {UINT32} xxHash
             */
            XXH.prototype.digest = function () {
              var input = this.memory;
              var isString = typeof input == "string";
              var p = 0;
              var bEnd = this.memsize;
              var h32, h;
              var u = new UINT32();

              if (this.total_len >= 16) {
                h32 = this.v1
                  .rotl(1)
                  .add(
                    this.v2.rotl(7).add(this.v3.rotl(12).add(this.v4.rotl(18))),
                  );
              } else {
                h32 = this.seed.add(PRIME32_5);
              }

              h32.add(u.fromNumber(this.total_len));

              while (p <= bEnd - 4) {
                if (isString) {
                  u.fromBits(
                    (input.charCodeAt(p + 1) << 8) | input.charCodeAt(p),
                    (input.charCodeAt(p + 3) << 8) | input.charCodeAt(p + 2),
                  );
                } else {
                  u.fromBits(
                    (input[p + 1] << 8) | input[p],
                    (input[p + 3] << 8) | input[p + 2],
                  );
                }
                h32.add(u.multiply(PRIME32_3)).rotl(17).multiply(PRIME32_4);
                p += 4;
              }

              while (p < bEnd) {
                u.fromBits(isString ? input.charCodeAt(p++) : input[p++], 0);
                h32.add(u.multiply(PRIME32_5)).rotl(11).multiply(PRIME32_1);
              }

              h = h32.clone().shiftRight(15);
              h32.xor(h).multiply(PRIME32_2);

              h = h32.clone().shiftRight(13);
              h32.xor(h).multiply(PRIME32_3);

              h = h32.clone().shiftRight(16);
              h32.xor(h);

              // Reset the state
              this.init(this.seed);

              return h32;
            };

            if (typeof define != "undefined" && define.amd) {
              // AMD / RequireJS
              define([], function () {
                return XXH;
              });
            } else if (typeof module != "undefined" && module.exports) {
              // Node.js
              module.exports = XXH;
            } else {
              // Browser
              root["XXH"] = XXH;
            }
          })(this);
        }).call(this, require("buffer").Buffer);
      },
      { buffer: "buffer", cuint: 7 },
    ],
    11: [function (require, module, exports) {}, {}],
    12: [
      function (require, module, exports) {
        var lookup =
          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

        (function (exports) {
          "use strict";

          var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;

          var PLUS = "+".charCodeAt(0);
          var SLASH = "/".charCodeAt(0);
          var NUMBER = "0".charCodeAt(0);
          var LOWER = "a".charCodeAt(0);
          var UPPER = "A".charCodeAt(0);
          var PLUS_URL_SAFE = "-".charCodeAt(0);
          var SLASH_URL_SAFE = "_".charCodeAt(0);

          function decode(elt) {
            var code = elt.charCodeAt(0);
            if (code === PLUS || code === PLUS_URL_SAFE) return 62; // '+'
            if (code === SLASH || code === SLASH_URL_SAFE) return 63; // '/'
            if (code < NUMBER) return -1; //no match
            if (code < NUMBER + 10) return code - NUMBER + 26 + 26;
            if (code < UPPER + 26) return code - UPPER;
            if (code < LOWER + 26) return code - LOWER + 26;
          }

          function b64ToByteArray(b64) {
            var i, j, l, tmp, placeHolders, arr;

            if (b64.length % 4 > 0) {
              throw new Error("Invalid string. Length must be a multiple of 4");
            }

            // the number of equal signs (place holders)
            // if there are two placeholders, than the two characters before it
            // represent one byte
            // if there is only one, then the three characters before it represent 2 bytes
            // this is just a cheap hack to not do indexOf twice
            var len = b64.length;
            placeHolders =
              "=" === b64.charAt(len - 2)
                ? 2
                : "=" === b64.charAt(len - 1)
                ? 1
                : 0;

            // base64 is 4/3 + up to two characters of the original data
            arr = new Arr((b64.length * 3) / 4 - placeHolders);

            // if there are placeholders, only get up to the last complete 4 chars
            l = placeHolders > 0 ? b64.length - 4 : b64.length;

            var L = 0;

            function push(v) {
              arr[L++] = v;
            }

            for (i = 0, j = 0; i < l; i += 4, j += 3) {
              tmp =
                (decode(b64.charAt(i)) << 18) |
                (decode(b64.charAt(i + 1)) << 12) |
                (decode(b64.charAt(i + 2)) << 6) |
                decode(b64.charAt(i + 3));
              push((tmp & 0xff0000) >> 16);
              push((tmp & 0xff00) >> 8);
              push(tmp & 0xff);
            }

            if (placeHolders === 2) {
              tmp =
                (decode(b64.charAt(i)) << 2) | (decode(b64.charAt(i + 1)) >> 4);
              push(tmp & 0xff);
            } else if (placeHolders === 1) {
              tmp =
                (decode(b64.charAt(i)) << 10) |
                (decode(b64.charAt(i + 1)) << 4) |
                (decode(b64.charAt(i + 2)) >> 2);
              push((tmp >> 8) & 0xff);
              push(tmp & 0xff);
            }

            return arr;
          }

          function uint8ToBase64(uint8) {
            var i,
              extraBytes = uint8.length % 3, // if we have 1 byte left, pad 2 bytes
              output = "",
              temp,
              length;

            function encode(num) {
              return lookup.charAt(num);
            }

            function tripletToBase64(num) {
              return (
                encode((num >> 18) & 0x3f) +
                encode((num >> 12) & 0x3f) +
                encode((num >> 6) & 0x3f) +
                encode(num & 0x3f)
              );
            }

            // go through the array every three bytes, we'll deal with trailing stuff later
            for (
              i = 0, length = uint8.length - extraBytes;
              i < length;
              i += 3
            ) {
              temp = (uint8[i] << 16) + (uint8[i + 1] << 8) + uint8[i + 2];
              output += tripletToBase64(temp);
            }

            // pad the end with zeros, but make sure to not forget the extra bytes
            switch (extraBytes) {
              case 1:
                temp = uint8[uint8.length - 1];
                output += encode(temp >> 2);
                output += encode((temp << 4) & 0x3f);
                output += "==";
                break;
              case 2:
                temp = (uint8[uint8.length - 2] << 8) + uint8[uint8.length - 1];
                output += encode(temp >> 10);
                output += encode((temp >> 4) & 0x3f);
                output += encode((temp << 2) & 0x3f);
                output += "=";
                break;
            }

            return output;
          }

          exports.toByteArray = b64ToByteArray;
          exports.fromByteArray = uint8ToBase64;
        })(typeof exports === "undefined" ? (this.base64js = {}) : exports);
      },
      {},
    ],
    13: [
      function (require, module, exports) {
        exports.read = function (buffer, offset, isLE, mLen, nBytes) {
          var e, m;
          var eLen = nBytes * 8 - mLen - 1;
          var eMax = (1 << eLen) - 1;
          var eBias = eMax >> 1;
          var nBits = -7;
          var i = isLE ? nBytes - 1 : 0;
          var d = isLE ? -1 : 1;
          var s = buffer[offset + i];

          i += d;

          e = s & ((1 << -nBits) - 1);
          s >>= -nBits;
          nBits += eLen;
          for (
            ;
            nBits > 0;
            e = e * 256 + buffer[offset + i], i += d, nBits -= 8
          ) {}

          m = e & ((1 << -nBits) - 1);
          e >>= -nBits;
          nBits += mLen;
          for (
            ;
            nBits > 0;
            m = m * 256 + buffer[offset + i], i += d, nBits -= 8
          ) {}

          if (e === 0) {
            e = 1 - eBias;
          } else if (e === eMax) {
            return m ? NaN : (s ? -1 : 1) * Infinity;
          } else {
            m = m + Math.pow(2, mLen);
            e = e - eBias;
          }
          return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
        };

        exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
          var e, m, c;
          var eLen = nBytes * 8 - mLen - 1;
          var eMax = (1 << eLen) - 1;
          var eBias = eMax >> 1;
          var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
          var i = isLE ? 0 : nBytes - 1;
          var d = isLE ? 1 : -1;
          var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;

          value = Math.abs(value);

          if (isNaN(value) || value === Infinity) {
            m = isNaN(value) ? 1 : 0;
            e = eMax;
          } else {
            e = Math.floor(Math.log(value) / Math.LN2);
            if (value * (c = Math.pow(2, -e)) < 1) {
              e--;
              c *= 2;
            }
            if (e + eBias >= 1) {
              value += rt / c;
            } else {
              value += rt * Math.pow(2, 1 - eBias);
            }
            if (value * c >= 2) {
              e++;
              c /= 2;
            }

            if (e + eBias >= eMax) {
              m = 0;
              e = eMax;
            } else if (e + eBias >= 1) {
              m = (value * c - 1) * Math.pow(2, mLen);
              e = e + eBias;
            } else {
              m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
              e = 0;
            }
          }

          for (
            ;
            mLen >= 8;
            buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8
          ) {}

          e = (e << mLen) | m;
          eLen += mLen;
          for (
            ;
            eLen > 0;
            buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8
          ) {}

          buffer[offset + i - d] |= s * 128;
        };
      },
      {},
    ],
    14: [
      function (require, module, exports) {
        /**
         * isArray
         */

        var isArray = Array.isArray;

        /**
         * toString
         */

        var str = Object.prototype.toString;

        /**
         * Whether or not the given `val`
         * is an array.
         *
         * example:
         *
         *        isArray([]);
         *        // > true
         *        isArray(arguments);
         *        // > false
         *        isArray('');
         *        // > false
         *
         * @param {mixed} val
         * @return {bool}
         */

        module.exports =
          isArray ||
          function (val) {
            return !!val && "[object Array]" == str.call(val);
          };
      },
      {},
    ],
    15: [
      function (require, 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.

        function EventEmitter() {
          this._events = this._events || {};
          this._maxListeners = this._maxListeners || undefined;
        }
        module.exports = EventEmitter;

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

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

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

        // Obviously not all Emitters should be limited to 10. This function allows
        // that to be increased. Set to zero for unlimited.
        EventEmitter.prototype.setMaxListeners = function (n) {
          if (!isNumber(n) || n < 0 || isNaN(n))
            throw TypeError("n must be a positive number");
          this._maxListeners = n;
          return this;
        };

        EventEmitter.prototype.emit = function (type) {
          var er, handler, len, args, i, listeners;

          if (!this._events) this._events = {};

          // If there is no 'error' event listener then throw.
          if (type === "error") {
            if (
              !this._events.error ||
              (isObject(this._events.error) && !this._events.error.length)
            ) {
              er = arguments[1];
              if (er instanceof Error) {
                throw er; // Unhandled 'error' event
              }
              throw TypeError('Uncaught, unspecified "error" event.');
            }
          }

          handler = this._events[type];

          if (isUndefined(handler)) return false;

          if (isFunction(handler)) {
            switch (arguments.length) {
              // fast cases
              case 1:
                handler.call(this);
                break;
              case 2:
                handler.call(this, arguments[1]);
                break;
              case 3:
                handler.call(this, arguments[1], arguments[2]);
                break;
              // slower
              default:
                args = Array.prototype.slice.call(arguments, 1);
                handler.apply(this, args);
            }
          } else if (isObject(handler)) {
            args = Array.prototype.slice.call(arguments, 1);
            listeners = handler.slice();
            len = listeners.length;
            for (i = 0; i < len; i++) listeners[i].apply(this, args);
          }

          return true;
        };

        EventEmitter.prototype.addListener = function (type, listener) {
          var m;

          if (!isFunction(listener))
            throw TypeError("listener must be a function");

          if (!this._events) this._events = {};

          // To avoid recursion in the case that type === "newListener"! Before
          // adding it to the listeners, first emit "newListener".
          if (this._events.newListener)
            this.emit(
              "newListener",
              type,
              isFunction(listener.listener) ? listener.listener : listener,
            );

          if (!this._events[type])
            // Optimize the case of one listener. Don't need the extra array object.
            this._events[type] = listener;
          else if (isObject(this._events[type]))
            // If we've already got an array, just append.
            this._events[type].push(listener);
          // Adding the second element, need to change to array.
          else this._events[type] = [this._events[type], listener];

          // Check for listener leak
          if (isObject(this._events[type]) && !this._events[type].warned) {
            if (!isUndefined(this._maxListeners)) {
              m = this._maxListeners;
            } else {
              m = EventEmitter.defaultMaxListeners;
            }

            if (m && m > 0 && this._events[type].length > m) {
              this._events[type].warned = true;
              console.error(
                "(node) warning: possible EventEmitter memory " +
                  "leak detected. %d listeners added. " +
                  "Use emitter.setMaxListeners() to increase limit.",
                this._events[type].length,
              );
              if (typeof console.trace === "function") {
                // not supported in IE 10
                console.trace();
              }
            }
          }

          return this;
        };

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

        EventEmitter.prototype.once = function (type, listener) {
          if (!isFunction(listener))
            throw TypeError("listener must be a function");

          var fired = false;

          function g() {
            this.removeListener(type, g);

            if (!fired) {
              fired = true;
              listener.apply(this, arguments);
            }
          }

          g.listener = listener;
          this.on(type, g);

          return this;
        };

        // emits a 'removeListener' event iff the listener was removed
        EventEmitter.prototype.removeListener = function (type, listener) {
          var list, position, length, i;

          if (!isFunction(listener))
            throw TypeError("listener must be a function");

          if (!this._events || !this._events[type]) return this;

          list = this._events[type];
          length = list.length;
          position = -1;

          if (
            list === listener ||
            (isFunction(list.listener) && list.listener === listener)
          ) {
            delete this._events[type];
            if (this._events.removeListener)
              this.emit("removeListener", type, listener);
          } else if (isObject(list)) {
            for (i = length; i-- > 0; ) {
              if (
                list[i] === listener ||
                (list[i].listener && list[i].listener === listener)
              ) {
                position = i;
                break;
              }
            }

            if (position < 0) return this;

            if (list.length === 1) {
              list.length = 0;
              delete this._events[type];
            } else {
              list.splice(position, 1);
            }

            if (this._events.removeListener)
              this.emit("removeListener", type, listener);
          }

          return this;
        };

        EventEmitter.prototype.removeAllListeners = function (type) {
          var key, listeners;

          if (!this._events) return this;

          // not listening for removeListener, no need to emit
          if (!this._events.removeListener) {
            if (arguments.length === 0) this._events = {};
            else if (this._events[type]) delete this._events[type];
            return this;
          }

          // emit removeListener for all listeners on all events
          if (arguments.length === 0) {
            for (key in this._events) {
              if (key === "removeListener") continue;
              this.removeAllListeners(key);
            }
            this.removeAllListeners("removeListener");
            this._events = {};
            return this;
          }

          listeners = this._events[type];

          if (isFunction(listeners)) {
            this.removeListener(type, listeners);
          } else if (listeners) {
            // LIFO order
            while (listeners.length)
              this.removeListener(type, listeners[listeners.length - 1]);
          }
          delete this._events[type];

          return this;
        };

        EventEmitter.prototype.listeners = function (type) {
          var ret;
          if (!this._events || !this._events[type]) ret = [];
          else if (isFunction(this._events[type])) ret = [this._events[type]];
          else ret = this._events[type].slice();
          return ret;
        };

        EventEmitter.prototype.listenerCount = function (type) {
          if (this._events) {
            var evlistener = this._events[type];

            if (isFunction(evlistener)) return 1;
            else if (evlistener) return evlistener.length;
          }
          return 0;
        };

        EventEmitter.listenerCount = function (emitter, type) {
          return emitter.listenerCount(type);
        };

        function isFunction(arg) {
          return typeof arg === "function";
        }

        function isNumber(arg) {
          return typeof arg === "number";
        }

        function isObject(arg) {
          return typeof arg === "object" && arg !== null;
        }

        function isUndefined(arg) {
          return arg === void 0;
        }
      },
      {},
    ],
    16: [
      function (require, module, exports) {
        if (typeof Object.create === "function") {
          // implementation from standard node.js 'util' module
          module.exports = function inherits(ctor, superCtor) {
            ctor.super_ = superCtor;
            ctor.prototype = Object.create(superCtor.prototype, {
              constructor: {
                value: ctor,
                enumerable: false,
                writable: true,
                configurable: true,
              },
            });
          };
        } else {
          // old school shim for old browsers
          module.exports = function inherits(ctor, superCtor) {
            ctor.super_ = superCtor;
            var TempCtor = function () {};
            TempCtor.prototype = superCtor.prototype;
            ctor.prototype = new TempCtor();
            ctor.prototype.constructor = ctor;
          };
        }
      },
      {},
    ],
    17: [
      function (require, module, exports) {
        /**
         * Determine if an object is Buffer
         *
         * Author:   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
         * License:  MIT
         *
         * `npm install is-buffer`
         */

        module.exports = function (obj) {
          return !!(
            obj != null &&
            (obj._isBuffer || // For Safari 5-7 (missing Object.prototype.constructor)
              (obj.constructor &&
                typeof obj.constructor.isBuffer === "function" &&
                obj.constructor.isBuffer(obj)))
          );
        };
      },
      {},
    ],
    18: [
      function (require, module, exports) {
        module.exports =
          Array.isArray ||
          function (arr) {
            return Object.prototype.toString.call(arr) == "[object Array]";
          };
      },
      {},
    ],
    19: [
      function (require, module, exports) {
        // shim for using process in browser

        var process = (module.exports = {});
        var queue = [];
        var draining = false;
        var currentQueue;
        var queueIndex = -1;

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

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

          var len = queue.length;
          while (len) {
            currentQueue = queue;
            queue = [];
            while (++queueIndex < len) {
              if (currentQueue) {
                currentQueue[queueIndex].run();
              }
            }
            queueIndex = -1;
            len = queue.length;
          }
          currentQueue = null;
          draining = false;
          clearTimeout(timeout);
        }

        process.nextTick = function (fun) {
          var args = new Array(arguments.length - 1);
          if (arguments.length > 1) {
            for (var i = 1; i < arguments.length; i++) {
              args[i - 1] = arguments[i];
            }
          }
          queue.push(new Item(fun, args));
          if (queue.length === 1 && !draining) {
            setTimeout(drainQueue, 0);
          }
        };

        // v8 likes predictible objects
        function Item(fun, array) {
          this.fun = fun;
          this.array = array;
        }
        Item.prototype.run = function () {
          this.fun.apply(null, this.array);
        };
        process.title = "browser";
        process.browser = true;
        process.env = {};
        process.argv = [];
        process.version = ""; // empty string to avoid regexp issues
        process.versions = {};

        function noop() {}

        process.on = noop;
        process.addListener = noop;
        process.once = noop;
        process.off = noop;
        process.removeListener = noop;
        process.removeAllListeners = noop;
        process.emit = noop;

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

        process.cwd = function () {
          return "/";
        };
        process.chdir = function (dir) {
          throw new Error("process.chdir is not supported");
        };
        process.umask = function () {
          return 0;
        };
      },
      {},
    ],
    20: [
      function (require, module, exports) {
        module.exports = require("./lib/_stream_duplex.js");
      },
      { "./lib/_stream_duplex.js": 21 },
    ],
    21: [
      function (require, module, exports) {
        // 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 objectKeys =
          Object.keys ||
          function (obj) {
            var keys = [];
            for (var key in obj) keys.push(key);
            return keys;
          };
        /*</replacement>*/

        module.exports = Duplex;

        /*<replacement>*/
        var processNextTick = require("process-nextick-args");
        /*</replacement>*/

        /*<replacement>*/
        var util = require("core-util-is");
        util.inherits = require("inherits");
        /*</replacement>*/

        var Readable = require("./_stream_readable");
        var Writable = require("./_stream_writable");

        util.inherits(Duplex, Readable);

        var keys = objectKeys(Writable.prototype);
        for (var v = 0; v < keys.length; v++) {
          var method = keys[v];
          if (!Duplex.prototype[method])
            Duplex.prototype[method] = Writable.prototype[method];
        }

        function Duplex(options) {
          if (!(this instanceof Duplex)) return new Duplex(options);

          Readable.call(this, options);
          Writable.call(this, options);

          if (options && options.readable === false) this.readable = false;

          if (options && options.writable === false) this.writable = false;

          this.allowHalfOpen = true;
          if (options && options.allowHalfOpen === false)
            this.allowHalfOpen = false;

          this.once("end", onend);
        }

        // the no-half-open enforcer
        function onend() {
          // if we allow half-open state, or if the writable side ended,
          // then we're ok.
          if (this.allowHalfOpen || this._writableState.ended) return;

          // no more data can be written.
          // But allow more writes to happen in this tick.
          processNextTick(onEndNT, this);
        }

        function onEndNT(self) {
          self.end();
        }

        function forEach(xs, f) {
          for (var i = 0, l = xs.length; i < l; i++) {
            f(xs[i], i);
          }
        }
      },
      {
        "./_stream_readable": 23,
        "./_stream_writable": 25,
        "core-util-is": 26,
        inherits: 16,
        "process-nextick-args": 27,
      },
    ],
    22: [
      function (require, module, exports) {
        // a passthrough stream.
        // basically just the most minimal sort of Transform stream.
        // Every written chunk gets output as-is.

        "use strict";

        module.exports = PassThrough;

        var Transform = require("./_stream_transform");

        /*<replacement>*/
        var util = require("core-util-is");
        util.inherits = require("inherits");
        /*</replacement>*/

        util.inherits(PassThrough, Transform);

        function PassThrough(options) {
          if (!(this instanceof PassThrough)) return new PassThrough(options);

          Transform.call(this, options);
        }

        PassThrough.prototype._transform = function (chunk, encoding, cb) {
          cb(null, chunk);
        };
      },
      { "./_stream_transform": 24, "core-util-is": 26, inherits: 16 },
    ],
    23: [
      function (require, module, exports) {
        (function (process) {
          "use strict";

          module.exports = Readable;

          /*<replacement>*/
          var processNextTick = require("process-nextick-args");
          /*</replacement>*/

          /*<replacement>*/
          var isArray = require("isarray");
          /*</replacement>*/

          /*<replacement>*/
          var Buffer = require("buffer").Buffer;
          /*</replacement>*/

          Readable.ReadableState = ReadableState;

          var EE = require("events");

          /*<replacement>*/
          var EElistenerCount = function (emitter, type) {
            return emitter.listeners(type).length;
          };
          /*</replacement>*/

          /*<replacement>*/
          var Stream;
          (function () {
            try {
              Stream = require("st" + "ream");
            } catch (_) {
            } finally {
              if (!Stream) Stream = require("events").EventEmitter;
            }
          })();
          /*</replacement>*/

          var Buffer = require("buffer").Buffer;

          /*<replacement>*/
          var util = require("core-util-is");
          util.inherits = require("inherits");
          /*</replacement>*/

          /*<replacement>*/
          var debugUtil = require("util");
          var debug;
          if (debugUtil && debugUtil.debuglog) {
            debug = debugUtil.debuglog("stream");
          } else {
            debug = function () {};
          }
          /*</replacement>*/

          var StringDecoder;

          util.inherits(Readable, Stream);

          function ReadableState(options, stream) {
            var Duplex = require("./_stream_duplex");

            options = options || {};

            // 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 (stream instanceof Duplex)
              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"
            var hwm = options.highWaterMark;
            var defaultHwm = this.objectMode ? 16 : 16 * 1024;
            this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;

            // cast to ints.
            this.highWaterMark = ~~this.highWaterMark;

            this.buffer = [];
            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 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;

            // 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;

            // 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";

            // when piping, we only care about 'readable' events that happen
            // after read()ing all the bytes and not getting any pushback.
            this.ranOut = false;

            // the number of writers that are awaiting a drain event in .pipe()s
            this.awaitDrain = 0;

            // if true, a maybeReadMore has been scheduled
            this.readingMore = false;

            this.decoder = null;
            this.encoding = null;
            if (options.encoding) {
              if (!StringDecoder)
                StringDecoder = require("string_decoder/").StringDecoder;
              this.decoder = new StringDecoder(options.encoding);
              this.encoding = options.encoding;
            }
          }

          function Readable(options) {
            var Duplex = require("./_stream_duplex");

            if (!(this instanceof Readable)) return new Readable(options);

            this._readableState = new ReadableState(options, this);

            // legacy
            this.readable = true;

            if (options && typeof options.read === "function")
              this._read = options.read;

            Stream.call(this);
          }

          // Manually shove something into the read() buffer.
          // This returns true if the highWaterMark has not been hit yet,
          // similar to how Writable.write() returns true if you should
          // write() some more.
          Readable.prototype.push = function (chunk, encoding) {
            var state = this._readableState;

            if (!state.objectMode && typeof chunk === "string") {
              encoding = encoding || state.defaultEncoding;
              if (encoding !== state.encoding) {
                chunk = new Buffer(chunk, encoding);
                encoding = "";
              }
            }

            return readableAddChunk(this, state, chunk, encoding, false);
          };

          // Unshift should *always* be something directly out of read()
          Readable.prototype.unshift = function (chunk) {
            var state = this._readableState;
            return readableAddChunk(this, state, chunk, "", true);
          };

          Readable.prototype.isPaused = function () {
            return this._readableState.flowing === false;
          };

          function readableAddChunk(
            stream,
            state,
            chunk,
            encoding,
            addToFront,
          ) {
            var er = chunkInvalid(state, chunk);
            if (er) {
              stream.emit("error", er);
            } else if (chunk === null) {
              state.reading = false;
              onEofChunk(stream, state);
            } else if (state.objectMode || (chunk && chunk.length > 0)) {
              if (state.ended && !addToFront) {
                var e = new Error("stream.push() after EOF");
                stream.emit("error", e);
              } else if (state.endEmitted && addToFront) {
                var e = new Error("stream.unshift() after end event");
                stream.emit("error", e);
              } else {
                if (state.decoder && !addToFront && !encoding)
                  chunk = state.decoder.write(chunk);

                if (!addToFront) state.reading = false;

                // if we want the data now, just emit it.
                if (state.flowing && state.length === 0 && !state.sync) {
                  stream.emit("data", chunk);
                  stream.read(0);
                } else {
                  // update the buffer info.
                  state.length += state.objectMode ? 1 : chunk.length;
                  if (addToFront) state.buffer.unshift(chunk);
                  else state.buffer.push(chunk);

                  if (state.needReadable) emitReadable(stream);
                }

                maybeReadMore(stream, state);
              }
            } else if (!addToFront) {
              state.reading = false;
            }

            return needMoreData(state);
          }

          // if it's past the high water mark, we can push in some more.
          // 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.  Also, if the push() triggered a
          // readable event, and the user called read(largeNumber) such that
          // needReadable was set, then we ought to push more, so that another
          // 'readable' event will be triggered.
          function needMoreData(state) {
            return (
              !state.ended &&
              (state.needReadable ||
                state.length < state.highWaterMark ||
                state.length === 0)
            );
          }

          // backwards compatibility.
          Readable.prototype.setEncoding = function (enc) {
            if (!StringDecoder)
              StringDecoder = require("string_decoder/").StringDecoder;
            this._readableState.decoder = new StringDecoder(enc);
            this._readableState.encoding = enc;
            return this;
          };

          // Don't raise the hwm > 8MB
          var MAX_HWM = 0x800000;
          function computeNewHighWaterMark(n) {
            if (n >= MAX_HWM) {
              n = MAX_HWM;
            } else {
              // Get the next highest power of 2
              n--;
              n |= n >>> 1;
              n |= n >>> 2;
              n |= n >>> 4;
              n |= n >>> 8;
              n |= n >>> 16;
              n++;
            }
            return n;
          }

          function howMuchToRead(n, state) {
            if (state.length === 0 && state.ended) return 0;

            if (state.objectMode) return n === 0 ? 0 : 1;

            if (n === null || isNaN(n)) {
              // only flow one buffer at a time
              if (state.flowing && state.buffer.length)
                return state.buffer[0].length;
              else return state.length;
            }

            if (n <= 0) return 0;

            // If we're asking for more than the target buffer level,
            // then raise the water mark.  Bump up to the next highest
            // power of 2, to prevent increasing it excessively in tiny
            // amounts.
            if (n > state.highWaterMark)
              state.highWaterMark = computeNewHighWaterMark(n);

            // don't have that much.  return null, unless we've ended.
            if (n > state.length) {
              if (!state.ended) {
                state.needReadable = true;
                return 0;
              } else {
                return state.length;
              }
            }

            return n;
          }

          // you can override either this method, or the async _read(n) below.
          Readable.prototype.read = function (n) {
            debug("read", n);
            var state = this._readableState;
            var nOrig = n;

            if (typeof n !== "number" || 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.length >= state.highWaterMark || state.ended)
            ) {
              debug("read: emitReadable", state.length, state.ended);
              if (state.length === 0 && state.ended) endReadable(this);
              else emitReadable(this);
              return null;
            }

            n = howMuchToRead(n, state);

            // if we've ended, and we're now clear, then finish it up.
            if (n === 0 && state.ended) {
              if (state.length === 0) endReadable(this);
              return null;
            }

            // All the actual chunk generation logic needs to be
            // *below* the call to _read.  The reason is that in certain
            // synthetic stream cases, such as passthrough streams, _read
            // may be a completely synchronous operation which may change
            // the state of the read buffer, providing enough data when
            // before there was *not* enough.
            //
            // So, the steps are:
            // 1. Figure out what the state of things will be after we do
            // a read from the buffer.
            //
            // 2. If that resulting state will trigger a _read, then call _read.
            // Note that this may be asynchronous, or synchronous.  Yes, it is
            // deeply ugly to write APIs this way, but that still doesn't mean
            // that the Readable class should behave improperly, as streams are
            // designed to be sync/async agnostic.
            // Take note if the _read call is sync or async (ie, if the read call
            // has returned yet), so that we know whether or not it's safe to emit
            // 'readable' etc.
            //
            // 3. Actually pull the requested chunks out of the buffer and return.

            // if we need a readable event, then we need to do some reading.
            var doRead = state.needReadable;
            debug("need readable", doRead);

            // if we currently have less than the highWaterMark, then also read some
            if (state.length === 0 || state.length - n < state.highWaterMark) {
              doRead = true;
              debug("length less than watermark", doRead);
            }

            // however, if we've ended, then there's no point, and if we're already
            // reading, then it's unnecessary.
            if (state.ended || state.reading) {
              doRead = false;
              debug("reading or ended", doRead);
            }

            if (doRead) {
              debug("do read");
              state.reading = true;
              state.sync = true;
              // if the length is currently zero, then we *need* a readable event.
              if (state.length === 0) state.needReadable = true;
              // call internal read method
              this._read(state.highWaterMark);
              state.sync = false;
            }

            // If _read pushed data synchronously, then `reading` will be false,
            // and we need to re-evaluate how much data we can return to the user.
            if (doRead && !state.reading) n = howMuchToRead(nOrig, state);

            var ret;
            if (n > 0) ret = fromList(n, state);
            else ret = null;

            if (ret === null) {
              state.needReadable = true;
              n = 0;
            }

            state.length -= n;

            // If we have nothing in the buffer, then we want to know
            // as soon as we *do* get something into the buffer.
            if (state.length === 0 && !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 && state.length === 0)
              endReadable(this);

            if (ret !== null) this.emit("data", ret);

            return ret;
          };

          function chunkInvalid(state, chunk) {
            var er = null;
            if (
              !Buffer.isBuffer(chunk) &&
              typeof chunk !== "string" &&
              chunk !== null &&
              chunk !== undefined &&
              !state.objectMode
            ) {
              er = new TypeError("Invalid non-string/buffer chunk");
            }
            return er;
          }

          function onEofChunk(stream, state) {
            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;

            // emit 'readable' now to make sure it gets picked up.
            emitReadable(stream);
          }

          // Don't emit readable right away in sync mode, because this can trigger
          // another read() call => stack overflow.  This way, it might trigger
          // a nextTick recursion warning, but that's not so bad.
          function emitReadable(stream) {
            var state = stream._readableState;
            state.needReadable = false;
            if (!state.emittedReadable) {
              debug("emitReadable", state.flowing);
              state.emittedReadable = true;
              if (state.sync) processNextTick(emitReadable_, stream);
              else emitReadable_(stream);
            }
          }

          function emitReadable_(stream) {
            debug("emit readable");
            stream.emit("readable");
            flow(stream);
          }

          // at this point, the user has presumably seen the 'readable' event,
          // and called read() to consume some data.  that may have triggered
          // in turn another _read(n) call, in which case reading = true if
          // it's in progress.
          // However, if we're not ended, or reading, and the length < hwm,
          // then go ahead and try to read some more preemptively.
          function maybeReadMore(stream, state) {
            if (!state.readingMore) {
              state.readingMore = true;
              processNextTick(maybeReadMore_, stream, state);
            }
          }

          function maybeReadMore_(stream, state) {
            var len = state.length;
            while (
              !state.reading &&
              !state.flowing &&
              !state.ended &&
              state.length < state.highWaterMark
            ) {
              debug("maybeReadMore read 0");
              stream.read(0);
              if (len === state.length)
                // didn't get any data, stop spinning.
                break;
              else len = state.length;
            }
            state.readingMore = false;
          }

          // abstract method.  to be overridden in specific implementation classes.
          // call cb(er, data) where data is <= n in length.
          // for virtual (non-string, non-buffer) streams, "length" is somewhat
          // arbitrary, and perhaps not very meaningful.
          Readable.prototype._read = function (n) {
            this.emit("error", new Error("not implemented"));
          };

          Readable.prototype.pipe = function (dest, pipeOpts) {
            var src = this;
            var state = this._readableState;

            switch (state.pipesCount) {
              case 0:
                state.pipes = dest;
                break;
              case 1:
                state.pipes = [state.pipes, dest];
                break;
              default:
                state.pipes.push(dest);
                break;
            }
            state.pipesCount += 1;
            debug("pipe count=%d opts=%j", state.pipesCount, pipeOpts);

            var doEnd =
              (!pipeOpts || pipeOpts.end !== false) &&
              dest !== process.stdout &&
              dest !== process.stderr;

            var endFn = doEnd ? onend : cleanup;
            if (state.endEmitted) processNextTick(endFn);
            else src.once("end", endFn);

            dest.on("unpipe", onunpipe);
            function onunpipe(readable) {
              debug("onunpipe");
              if (readable === src) {
                cleanup();
              }
            }

            function onend() {
              debug("onend");
              dest.end();
            }

            // when the dest drains, it reduces the awaitDrain counter
            // on the source.  This would be more elegant with a .once()
            // handler in flow(), but adding and removing repeatedly is
            // too slow.
            var ondrain = pipeOnDrain(src);
            dest.on("drain", ondrain);

            var cleanedUp = false;
            function cleanup() {
              debug("cleanup");
              // cleanup event handlers once the pipe is broken
              dest.removeListener("close", onclose);
              dest.removeListener("finish", onfinish);
              dest.removeListener("drain", ondrain);
              dest.removeListener("error", onerror);
              dest.removeListener("unpipe", onunpipe);
              src.removeListener("end", onend);
              src.removeListener("end", cleanup);
              src.removeListener("data", ondata);

              cleanedUp = true;

              // if the reader is waiting for a drain event from this
              // specific writer, then it would cause it to never start
              // flowing again.
              // So, if this is awaiting a drain, then we just call it now.
              // If we don't know, then assume that we are waiting for one.
              if (
                state.awaitDrain &&
                (!dest._writableState || dest._writableState.needDrain)
              )
                ondrain();
            }

            src.on("data", ondata);
            function ondata(chunk) {
              debug("ondata");
              var ret = dest.write(chunk);
              if (false === ret) {
                // If the user unpiped during `dest.write()`, it is possible
                // to get stuck in a permanently paused state if that write
                // also returned false.
                if (
                  state.pipesCount === 1 &&
                  state.pipes[0] === dest &&
                  src.listenerCount("data") === 1 &&
                  !cleanedUp
                ) {
                  debug(
                    "false write response, pause",
                    src._readableState.awaitDrain,
                  );
                  src._readableState.awaitDrain++;
                }
                src.pause();
              }
            }

            // if the dest has an error, then stop piping into it.
            // however, don't suppress the throwing behavior for this.
            function onerror(er) {
              debug("onerror", er);
              unpipe();
              dest.removeListener("error", onerror);
              if (EElistenerCount(dest, "error") === 0) dest.emit("error", er);
            }
            // This is a brutally ugly hack to make sure that our error handler
            // is attached before any userland ones.  NEVER DO THIS.
            if (!dest._events || !dest._events.error) dest.on("error", onerror);
            else if (isArray(dest._events.error))
              dest._events.error.unshift(onerror);
            else dest._events.error = [onerror, dest._events.error];

            // Both close and finish should trigger unpipe, but only once.
            function onclose() {
              dest.removeListener("finish", onfinish);
              unpipe();
            }
            dest.once("close", onclose);
            function onfinish() {
              debug("onfinish");
              dest.removeListener("close", onclose);
              unpipe();
            }
            dest.once("finish", onfinish);

            function unpipe() {
              debug("unpipe");
              src.unpipe(dest);
            }

            // tell the dest that it's being piped to
            dest.emit("pipe", src);

            // start the flow if it hasn't been started already.
            if (!state.flowing) {
              debug("pipe resume");
              src.resume();
            }

            return dest;
          };

          function pipeOnDrain(src) {
            return function () {
              var state = src._readableState;
              debug("pipeOnDrain", state.awaitDrain);
              if (state.awaitDrain) state.awaitDrain--;
              if (state.awaitDrain === 0 && EElistenerCount(src, "data")) {
                state.flowing = true;
                flow(src);
              }
            };
          }

          Readable.prototype.unpipe = function (dest) {
            var state = this._readableState;

            // 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);
              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);
              return this;
            }

            // try to find the right one.
            var i = indexOf(state.pipes, dest);
            if (i === -1) return this;

            state.pipes.splice(i, 1);
            state.pipesCount -= 1;
            if (state.pipesCount === 1) state.pipes = state.pipes[0];

            dest.emit("unpipe", this);

            return this;
          };

          // set up data events if they are asked for
          // Ensure readable listeners eventually get something
          Readable.prototype.on = function (ev, fn) {
            var res = Stream.prototype.on.call(this, ev, fn);

            // If listening to data, and it has not explicitly been paused,
            // then call resume to start the flow of data on the next tick.
            if (ev === "data" && false !== this._readableState.flowing) {
              this.resume();
            }

            if (ev === "readable" && this.readable) {
              var state = this._readableState;
              if (!state.readableListening) {
                state.readableListening = true;
                state.emittedReadable = false;
                state.needReadable = true;
                if (!state.reading) {
                  processNextTick(nReadingNextTick, this);
                } else if (state.length) {
                  emitReadable(this, state);
                }
              }
            }

            return res;
          };
          Readable.prototype.addListener = Readable.prototype.on;

          function nReadingNextTick(self) {
            debug("readable nexttick read 0");
            self.read(0);
          }

          // pause() and resume() are remnants of the legacy readable stream API
          // If the user uses them, then switch into old mode.
          Readable.prototype.resume = function () {
            var state = this._readableState;
            if (!state.flowing) {
              debug("resume");
              state.flowing = true;
              resume(this, state);
            }
            return this;
          };

          function resume(stream, state) {
            if (!state.resumeScheduled) {
              state.resumeScheduled = true;
              processNextTick(resume_, stream, state);
            }
          }

          function resume_(stream, state) {
            if (!state.reading) {
              debug("resume read 0");
              stream.read(0);
            }

            state.resumeScheduled = false;
            stream.emit("resume");
            flow(stream);
            if (state.flowing && !state.reading) stream.read(0);
          }

          Readable.prototype.pause = function () {
            debug("call pause flowing=%j", this._readableState.flowing);
            if (false !== this._readableState.flowing) {
              debug("pause");
              this._readableState.flowing = false;
              this.emit("pause");
            }
            return this;
          };

          function flow(stream) {
            var state = stream._readableState;
            debug("flow", state.flowing);
            if (state.flowing) {
              do {
                var chunk = stream.read();
              } while (null !== chunk && state.flowing);
            }
          }

          // wrap an old-style stream as the async data source.
          // This is *not* part of the readable stream interface.
          // It is an ugly unfortunate mess of history.
          Readable.prototype.wrap = function (stream) {
            var state = this._readableState;
            var paused = false;

            var self = this;
            stream.on("end", function () {
              debug("wrapped end");
              if (state.decoder && !state.ended) {
                var chunk = state.decoder.end();
                if (chunk && chunk.length) self.push(chunk);
              }

              self.push(null);
            });

            stream.on("data", function (chunk) {
              debug("wrapped data");
              if (state.decoder) chunk = state.decoder.write(chunk);

              // don't skip over falsy values in objectMode
              if (state.objectMode && (chunk === null || chunk === undefined))
                return;
              else if (!state.objectMode && (!chunk || !chunk.length)) return;

              var ret = self.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 (method) {
                  return function () {
                    return stream[method].apply(stream, arguments);
                  };
                })(i);
              }
            }

            // proxy certain important events.
            var events = ["error", "close", "destroy", "pause", "resume"];
            forEach(events, function (ev) {
              stream.on(ev, self.emit.bind(self, ev));
            });

            // when we try to consume some more bytes, simply unpause the
            // underlying stream.
            self._read = function (n) {
              debug("wrapped _read", n);
              if (paused) {
                paused = false;
                stream.resume();
              }
            };

            return self;
          };

          // exposed for testing purposes only.
          Readable._fromList = fromList;

          // Pluck off n bytes from an array of buffers.
          // Length is the combined lengths of all the buffers in the list.
          function fromList(n, state) {
            var list = state.buffer;
            var length = state.length;
            var stringMode = !!state.decoder;
            var objectMode = !!state.objectMode;
            var ret;

            // nothing in the list, definitely empty.
            if (list.length === 0) return null;

            if (length === 0) ret = null;
            else if (objectMode) ret = list.shift();
            else if (!n || n >= length) {
              // read it all, truncate the array.
              if (stringMode) ret = list.join("");
              else if (list.length === 1) ret = list[0];
              else ret = Buffer.concat(list, length);
              list.length = 0;
            } else {
              // read just some of it.
              if (n < list[0].length) {
                // just take a part of the first list item.
                // slice is the same for buffers and strings.
                var buf = list[0];
                ret = buf.slice(0, n);
                list[0] = buf.slice(n);
              } else if (n === list[0].length) {
                // first list is a perfect match
                ret = list.shift();
              } else {
                // complex case.
                // we have enough to cover it, but it spans past the first buffer.
                if (stringMode) ret = "";
                else ret = new Buffer(n);

                var c = 0;
                for (var i = 0, l = list.length; i < l && c < n; i++) {
                  var buf = list[0];
                  var cpy = Math.min(n - c, buf.length);

                  if (stringMode) ret += buf.slice(0, cpy);
                  else buf.copy(ret, c, 0, cpy);

                  if (cpy < buf.length) list[0] = buf.slice(cpy);
                  else list.shift();

                  c += cpy;
                }
              }
            }

            return ret;
          }

          function endReadable(stream) {
            var state = stream._readableState;

            // If we get here before consuming all the bytes, then that is a
            // bug in node.  Should never happen.
            if (state.length > 0)
              throw new Error("endReadable called on non-empty stream");

            if (!state.endEmitted) {
              state.ended = true;
              processNextTick(endReadableNT, state, stream);
            }
          }

          function endReadableNT(state, stream) {
            // Check that we didn't get one last unshift.
            if (!state.endEmitted && state.length === 0) {
              state.endEmitted = true;
              stream.readable = false;
              stream.emit("end");
            }
          }

          function forEach(xs, f) {
            for (var i = 0, l = xs.length; i < l; i++) {
              f(xs[i], i);
            }
          }

          function indexOf(xs, x) {
            for (var i = 0, l = xs.length; i < l; i++) {
              if (xs[i] === x) return i;
            }
            return -1;
          }
        }).call(this, require("_process"));
      },
      {
        "./_stream_duplex": 21,
        _process: 19,
        buffer: "buffer",
        "core-util-is": 26,
        events: 15,
        inherits: 16,
        isarray: 18,
        "process-nextick-args": 27,
        "string_decoder/": 34,
        util: 11,
      },
    ],
    24: [
      function (require, module, exports) {
        // 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 = Transform;

        var Duplex = require("./_stream_duplex");

        /*<replacement>*/
        var util = require("core-util-is");
        util.inherits = require("inherits");
        /*</replacement>*/

        util.inherits(Transform, Duplex);

        function TransformState(stream) {
          this.afterTransform = function (er, data) {
            return afterTransform(stream, er, data);
          };

          this.needTransform = false;
          this.transforming = false;
          this.writecb = null;
          this.writechunk = null;
        }

        function afterTransform(stream, er, data) {
          var ts = stream._transformState;
          ts.transforming = false;

          var cb = ts.writecb;

          if (!cb)
            return stream.emit(
              "error",
              new Error("no writecb in Transform class"),
            );

          ts.writechunk = null;
          ts.writecb = null;

          if (data !== null && data !== undefined) stream.push(data);

          if (cb) cb(er);

          var rs = stream._readableState;
          rs.reading = false;
          if (rs.needReadable || rs.length < rs.highWaterMark) {
            stream._read(rs.highWaterMark);
          }
        }

        function Transform(options) {
          if (!(this instanceof Transform)) return new Transform(options);

          Duplex.call(this, options);

          this._transformState = new TransformState(this);

          // when the writable side finishes, then flush out anything remaining.
          var stream = this;

          // 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;
          }

          this.once("prefinish", function () {
            if (typeof this._flush === "function")
              this._flush(function (er) {
                done(stream, er);
              });
            else done(stream);
          });
        }

        Transform.prototype.push = function (chunk, encoding) {
          this._transformState.needTransform = false;
          return Duplex.prototype.push.call(this, chunk, encoding);
        };

        // This is the part where you do stuff!
        // override this function in implementation classes.
        // 'chunk' is an input chunk.
        //
        // Call `push(newChunk)` to pass along transformed output
        // to the readable side.  You may call 'push' zero or more times.
        //
        // Call `cb(err)` when you are done with this chunk.  If you pass
        // an error, then that'll put the hurt on the whole operation.  If you
        // never call cb(), then you'll never get another chunk.
        Transform.prototype._transform = function (chunk, encoding, cb) {
          throw new Error("not implemented");
        };

        Transform.prototype._write = function (chunk, encoding, cb) {
          var ts = this._transformState;
          ts.writecb = cb;
          ts.writechunk = chunk;
          ts.writeencoding = encoding;
          if (!ts.transforming) {
            var rs = this._readableState;
            if (
              ts.needTransform ||
              rs.needReadable ||
              rs.length < rs.highWaterMark
            )
              this._read(rs.highWaterMark);
          }
        };

        // Doesn't matter what the args are here.
        // _transform does all the work.
        // That we got here means that the readable side wants more data.
        Transform.prototype._read = function (n) {
          var ts = this._transformState;

          if (ts.writechunk !== null && ts.writecb && !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;
          }
        };

        function done(stream, er) {
          if (er) return stream.emit("error", er);

          // if there's nothing in the write buffer, then that means
          // that nothing more will ever be provided
          var ws = stream._writableState;
          var ts = stream._transformState;

          if (ws.length)
            throw new Error("calling transform done when ws.length != 0");

          if (ts.transforming)
            throw new Error("calling transform done when still transforming");

          return stream.push(null);
        }
      },
      { "./_stream_duplex": 21, "core-util-is": 26, inherits: 16 },
    ],
    25: [
      function (require, module, exports) {
        // 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 = Writable;

        /*<replacement>*/
        var processNextTick = require("process-nextick-args");
        /*</replacement>*/

        /*<replacement>*/
        var Buffer = require("buffer").Buffer;
        /*</replacement>*/

        Writable.WritableState = WritableState;

        /*<replacement>*/
        var util = require("core-util-is");
        util.inherits = require("inherits");
        /*</replacement>*/

        /*<replacement>*/
        var internalUtil = {
          deprecate: require("util-deprecate"),
        };
        /*</replacement>*/

        /*<replacement>*/
        var Stream;
        (function () {
          try {
            Stream = require("st" + "ream");
          } catch (_) {
          } finally {
            if (!Stream) Stream = require("events").EventEmitter;
          }
        })();
        /*</replacement>*/

        var Buffer = require("buffer").Buffer;

        util.inherits(Writable, Stream);

        function nop() {}

        function WriteReq(chunk, encoding, cb) {
          this.chunk = chunk;
          this.encoding = encoding;
          this.callback = cb;
          this.next = null;
        }

        function WritableState(options, stream) {
          var Duplex = require("./_stream_duplex");

          options = options || {};

          // object stream flag to indicate whether or not this stream
          // contains buffers or objects.
          this.objectMode = !!options.objectMode;

          if (stream instanceof Duplex)
            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()
          var hwm = options.highWaterMark;
          var defaultHwm = this.objectMode ? 16 : 16 * 1024;
          this.highWaterMark = hwm || hwm === 0 ? hwm : defaultHwm;

          // cast to ints.
          this.highWaterMark = ~~this.highWaterMark;

          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;

          // should we decode strings into buffers before passing to _write?
          // this is here so that some node-core streams can optimize string
          // handling at a lower level.
          var noDecode = options.decodeStrings === false;
          this.decodeStrings = !noDecode;

          // Crypto is kind of old and crusty.  Historically, its default string
          // encoding is 'binary' so we have to make this configurable.
          // Everything else in the universe uses 'utf8', though.
          this.defaultEncoding = options.defaultEncoding || "utf8";

          // not an actual buffer we keep track of, but a measurement
          // of how much we're waiting to get pushed to some underlying
          // socket or file.
          this.length = 0;

          // a flag to see when we're in the middle of a write.
          this.writing = false;

          // when true all writes will be buffered until .uncork() call
          this.corked = 0;

          // a flag to be able to tell if the onwrite cb is called immediately,
          // or on a later tick.  We set this to true at first, because any
          // actions that shouldn't happen until "later" should generally also
          // not happen before the first write call.
          this.sync = true;

          // a flag to know if we're processing previously buffered items, which
          // may call the _write() callback in the same tick, so that we don't
          // end up in an overlapped onwrite situation.
          this.bufferProcessing = false;

          // the callback that's passed to _write(chunk,cb)
          this.onwrite = function (er) {
            onwrite(stream, er);
          };

          // the callback that the user supplies to write(chunk,encoding,cb)
          this.writecb = null;

          // the amount that is being written when _write is called.
          this.writelen = 0;

          this.bufferedRequest = null;
          this.lastBufferedRequest = null;

          // number of pending user-supplied write callbacks
          // this must be 0 before 'finish' can be emitted
          this.pendingcb = 0;

          // emit prefinish if the only thing we're waiting for is _write cbs
          // This is relevant for synchronous Transform streams
          this.prefinished = false;

          // True if the error was already emitted and should not be thrown again
          this.errorEmitted = false;
        }

        WritableState.prototype.getBuffer = function writableStateGetBuffer() {
          var current = this.bufferedRequest;
          var out = [];
          while (current) {
            out.push(current);
            current = current.next;
          }
          return out;
        };

        (function () {
          try {
            Object.defineProperty(WritableState.prototype, "buffer", {
              get: internalUtil.deprecate(function () {
                return this.getBuffer();
              }, "_writableState.buffer is deprecated. Use _writableState.getBuffer " + "instead."),
            });
          } catch (_) {}
        })();

        function Writable(options) {
          var Duplex = require("./_stream_duplex");

          // Writable ctor is applied to Duplexes, though they're not
          // instanceof Writable, they're instanceof Readable.
          if (!(this instanceof Writable) && !(this instanceof Duplex))
            return new Writable(options);

          this._writableState = new WritableState(options, this);

          // legacy.
          this.writable = true;

          if (options) {
            if (typeof options.write === "function")
              this._write = options.write;

            if (typeof options.writev === "function")
              this._writev = options.writev;
          }

          Stream.call(this);
        }

        // Otherwise people can pipe Writable streams, which is just wrong.
        Writable.prototype.pipe = function () {
          this.emit("error", new Error("Cannot pipe. Not readable."));
        };

        function writeAfterEnd(stream, cb) {
          var er = new Error("write after end");
          // TODO: defer error events consistently everywhere, not just the cb
          stream.emit("error", er);
          processNextTick(cb, er);
        }

        // If we get something that is not a buffer, string, null, or undefined,
        // and we're not in objectMode, then that's an error.
        // Otherwise stream chunks are all considered to be of length=1, and the
        // watermarks determine how many objects to keep in the buffer, rather than
        // how many bytes or characters.
        function validChunk(stream, state, chunk, cb) {
          var valid = true;

          if (
            !Buffer.isBuffer(chunk) &&
            typeof chunk !== "string" &&
            chunk !== null &&
            chunk !== undefined &&
            !state.objectMode
          ) {
            var er = new TypeError("Invalid non-string/buffer chunk");
            stream.emit("error", er);
            processNextTick(cb, er);
            valid = false;
          }
          return valid;
        }

        Writable.prototype.write = function (chunk, encoding, cb) {
          var state = this._writableState;
          var ret = false;

          if (typeof encoding === "function") {
            cb = encoding;
            encoding = null;
          }

          if (Buffer.isBuffer(chunk)) encoding = "buffer";
          else if (!encoding) encoding = state.defaultEncoding;

          if (typeof cb !== "function") cb = nop;

          if (state.ended) writeAfterEnd(this, cb);
          else if (validChunk(this, state, chunk, cb)) {
            state.pendingcb++;
            ret = writeOrBuffer(this, state, chunk, encoding, cb);
          }

          return ret;
        };

        Writable.prototype.cork = function () {
          var state = this._writableState;

          state.corked++;
        };

        Writable.prototype.uncork = function () {
          var state = this._writableState;

          if (state.corked) {
            state.corked--;

            if (
              !state.writing &&
              !state.corked &&
              !state.finished &&
              !state.bufferProcessing &&
              state.bufferedRequest
            )
              clearBuffer(this, state);
          }
        };

        Writable.prototype.setDefaultEncoding = function setDefaultEncoding(
          encoding,
        ) {
          // node::ParseEncoding() requires lower case.
          if (typeof encoding === "string") encoding = encoding.toLowerCase();
          if (
            !(
              [
                "hex",
                "utf8",
                "utf-8",
                "ascii",
                "binary",
                "base64",
                "ucs2",
                "ucs-2",
                "utf16le",
                "utf-16le",
                "raw",
              ].indexOf((encoding + "").toLowerCase()) > -1
            )
          )
            throw new TypeError("Unknown encoding: " + encoding);
          this._writableState.defaultEncoding = encoding;
        };

        function decodeChunk(state, chunk, encoding) {
          if (
            !state.objectMode &&
            state.decodeStrings !== false &&
            typeof chunk === "string"
          ) {
            chunk = new Buffer(chunk, encoding);
          }
          return chunk;
        }

        // if we're already writing something, then just put this
        // in the queue, and wait our turn.  Otherwise, call _write
        // If we return false, then we need a drain event, so set that flag.
        function writeOrBuffer(stream, state, chunk, encoding, cb) {
          chunk = decodeChunk(state, chunk, encoding);

          if (Buffer.isBuffer(chunk)) encoding = "buffer";
          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 = new WriteReq(chunk, encoding, cb);
            if (last) {
              last.next = state.lastBufferedRequest;
            } else {
              state.bufferedRequest = state.lastBufferedRequest;
            }
          } else {
            doWrite(stream, state, false, len, chunk, encoding, cb);
          }

          return ret;
        }

        function doWrite(stream, state, writev, len, chunk, encoding, cb) {
          state.writelen = len;
          state.writecb = cb;
          state.writing = true;
          state.sync = true;
          if (writev) stream._writev(chunk, state.onwrite);
          else stream._write(chunk, encoding, state.onwrite);
          state.sync = false;
        }

        function onwriteError(stream, state, sync, er, cb) {
          --state.pendingcb;
          if (sync) processNextTick(cb, er);
          else cb(er);

          stream._writableState.errorEmitted = true;
          stream.emit("error", er);
        }

        function onwriteStateUpdate(state) {
          state.writing = false;
          state.writecb = null;
          state.length -= state.writelen;
          state.writelen = 0;
        }

        function onwrite(stream, er) {
          var state = stream._writableState;
          var sync = state.sync;
          var cb = state.writecb;

          onwriteStateUpdate(state);

          if (er) onwriteError(stream, state, sync, er, cb);
          else {
            // Check if we're actually ready to finish, but don't emit yet
            var finished = needFinish(state);

            if (
              !finished &&
              !state.corked &&
              !state.bufferProcessing &&
              state.bufferedRequest
            ) {
              clearBuffer(stream, state);
            }

            if (sync) {
              processNextTick(afterWrite, stream, state, finished, cb);
            } else {
              afterWrite(stream, state, finished, cb);
            }
          }
        }

        function afterWrite(stream, state, finished, cb) {
          if (!finished) onwriteDrain(stream, state);
          state.pendingcb--;
          cb();
          finishMaybe(stream, state);
        }

        // Must force callback to be called on nextTick, so that we don't
        // emit 'drain' before the write() consumer gets the 'false' return
        // value, and has a chance to attach a 'drain' listener.
        function onwriteDrain(stream, state) {
          if (state.length === 0 && state.needDrain) {
            state.needDrain = false;
            stream.emit("drain");
          }
        }

        // if there's something in the buffer waiting, then process it
        function clearBuffer(stream, state) {
          state.bufferProcessing = true;
          var entry = state.bufferedRequest;

          if (stream._writev && entry && entry.next) {
            // Fast case, write everything using _writev()
            var buffer = [];
            var cbs = [];
            while (entry) {
              cbs.push(entry.callback);
              buffer.push(entry);
              entry = entry.next;
            }

            // count the one we are adding, as well.
            // TODO(isaacs) clean this up
            state.pendingcb++;
            state.lastBufferedRequest = null;
            doWrite(
              stream,
              state,
              true,
              state.length,
              buffer,
              "",
              function (err) {
                for (var i = 0; i < cbs.length; i++) {
                  state.pendingcb--;
                  cbs[i](err);
                }
              },
            );

            // Clear buffer
          } else {
            // Slow case, write chunks one-by-one
            while (entry) {
              var chunk = entry.chunk;
              var encoding = entry.encoding;
              var cb = entry.callback;
              var len = state.objectMode ? 1 : chunk.length;

              doWrite(stream, state, false, len, chunk, encoding, cb);
              entry = entry.next;
              // if we didn't call the onwrite immediately, then
              // it means that we need to wait until it does.
              // also, that means that the chunk and cb are currently
              // being processed, so move the buffer counter past them.
              if (state.writing) {
                break;
              }
            }

            if (entry === null) state.lastBufferedRequest = null;
          }
          state.bufferedRequest = entry;
          state.bufferProcessing = false;
        }

        Writable.prototype._write = function (chunk, encoding, cb) {
          cb(new Error("not implemented"));
        };

        Writable.prototype._writev = null;

        Writable.prototype.end = function (chunk, encoding, cb) {
          var state = this._writableState;

          if (typeof chunk === "function") {
            cb = chunk;
            chunk = null;
            encoding = null;
          } else if (typeof encoding === "function") {
            cb = encoding;
            encoding = null;
          }

          if (chunk !== null && chunk !== undefined)
            this.write(chunk, encoding);

          // .end() fully uncorks
          if (state.corked) {
            state.corked = 1;
            this.uncork();
          }

          // ignore unnecessary end() calls.
          if (!state.ending && !state.finished) endWritable(this, state, cb);
        };

        function needFinish(state) {
          return (
            state.ending &&
            state.length === 0 &&
            state.bufferedRequest === null &&
            !state.finished &&
            !state.writing
          );
        }

        function prefinish(stream, state) {
          if (!state.prefinished) {
            state.prefinished = true;
            stream.emit("prefinish");
          }
        }

        function finishMaybe(stream, state) {
          var need = needFinish(state);
          if (need) {
            if (state.pendingcb === 0) {
              prefinish(stream, state);
              state.finished = true;
              stream.emit("finish");
            } else {
              prefinish(stream, state);
            }
          }
          return need;
        }

        function endWritable(stream, state, cb) {
          state.ending = true;
          finishMaybe(stream, state);
          if (cb) {
            if (state.finished) processNextTick(cb);
            else stream.once("finish", cb);
          }
          state.ended = true;
        }
      },
      {
        "./_stream_duplex": 21,
        buffer: "buffer",
        "core-util-is": 26,
        events: 15,
        inherits: 16,
        "process-nextick-args": 27,
        "util-deprecate": 28,
      },
    ],
    26: [
      function (require, module, exports) {
        (function (Buffer) {
          // 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

          function isBuffer(arg) {
            return Buffer.isBuffer(arg);
          }
          exports.isBuffer = isBuffer;

          function objectToString(o) {
            return Object.prototype.toString.call(o);
          }
        }).call(this, {
          isBuffer: require("../../../../insert-module-globals/node_modules/is-buffer/index.js"),
        });
      },
      {
        "../../../../insert-module-globals/node_modules/is-buffer/index.js": 17,
      },
    ],
    27: [
      function (require, module, exports) {
        (function (process) {
          "use strict";
          module.exports = nextTick;

          function nextTick(fn) {
            var args = new Array(arguments.length - 1);
            var i = 0;
            while (i < args.length) {
              args[i++] = arguments[i];
            }
            process.nextTick(function afterTick() {
              fn.apply(null, args);
            });
          }
        }).call(this, require("_process"));
      },
      { _process: 19 },
    ],
    28: [
      function (require, module, exports) {
        (function (global) {
          /**
           * Module exports.
           */

          module.exports = 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 deprecate(fn, msg) {
            if (config("noDeprecation")) {
              return fn;
            }

            var warned = false;
            function deprecated() {
              if (!warned) {
                if (config("throwDeprecation")) {
                  throw new Error(msg);
                } else if (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 config(name) {
            // accessing global.localStorage can trigger a DOMException in sandboxed iframes
            try {
              if (!global.localStorage) return false;
            } catch (_) {
              return false;
            }
            var val = global.localStorage[name];
            if (null == val) return false;
            return String(val).toLowerCase() === "true";
          }
        }).call(
          this,
          typeof global !== "undefined"
            ? global
            : typeof self !== "undefined"
            ? self
            : typeof window !== "undefined"
            ? window
            : {},
        );
      },
      {},
    ],
    29: [
      function (require, module, exports) {
        module.exports = require("./lib/_stream_passthrough.js");
      },
      { "./lib/_stream_passthrough.js": 22 },
    ],
    30: [
      function (require, module, exports) {
        var Stream = (function () {
          try {
            return require("st" + "ream"); // hack to fix a circular dependency issue when used with browserify
          } catch (_) {}
        })();
        exports = module.exports = require("./lib/_stream_readable.js");
        exports.Stream = Stream || exports;
        exports.Readable = exports;
        exports.Writable = require("./lib/_stream_writable.js");
        exports.Duplex = require("./lib/_stream_duplex.js");
        exports.Transform = require("./lib/_stream_transform.js");
        exports.PassThrough = require("./lib/_stream_passthrough.js");
      },
      {
        "./lib/_stream_duplex.js": 21,
        "./lib/_stream_passthrough.js": 22,
        "./lib/_stream_readable.js": 23,
        "./lib/_stream_transform.js": 24,
        "./lib/_stream_writable.js": 25,
      },
    ],
    31: [
      function (require, module, exports) {
        module.exports = require("./lib/_stream_transform.js");
      },
      { "./lib/_stream_transform.js": 24 },
    ],
    32: [
      function (require, module, exports) {
        module.exports = require("./lib/_stream_writable.js");
      },
      { "./lib/_stream_writable.js": 25 },
    ],
    33: [
      function (require, 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.

        module.exports = Stream;

        var EE = require("events").EventEmitter;
        var inherits = require("inherits");

        inherits(Stream, EE);
        Stream.Readable = require("readable-stream/readable.js");
        Stream.Writable = require("readable-stream/writable.js");
        Stream.Duplex = require("readable-stream/duplex.js");
        Stream.Transform = require("readable-stream/transform.js");
        Stream.PassThrough = require("readable-stream/passthrough.js");

        // Backwards-compat with node 0.4.x
        Stream.Stream = Stream;

        // old-style streams.  Note that the pipe method (the only relevant
        // part of this class) is overridden in the Readable class.

        function Stream() {
          EE.call(this);
        }

        Stream.prototype.pipe = function (dest, options) {
          var source = this;

          function ondata(chunk) {
            if (dest.writable) {
              if (false === dest.write(chunk) && source.pause) {
                source.pause();
              }
            }
          }

          source.on("data", ondata);

          function ondrain() {
            if (source.readable && source.resume) {
              source.resume();
            }
          }

          dest.on("drain", ondrain);

          // If the 'end' option is not supplied, dest.end() will be called when
          // source gets the 'end' or 'close' events.  Only dest.end() once.
          if (!dest._isStdio && (!options || options.end !== false)) {
            source.on("end", onend);
            source.on("close", onclose);
          }

          var didOnEnd = false;
          function onend() {
            if (didOnEnd) return;
            didOnEnd = true;

            dest.end();
          }

          function onclose() {
            if (didOnEnd) return;
            didOnEnd = true;

            if (typeof dest.destroy === "function") dest.destroy();
          }

          // don't leave dangling pipes when there are errors.
          function onerror(er) {
            cleanup();
            if (EE.listenerCount(this, "error") === 0) {
              throw er; // Unhandled stream error in pipe.
            }
          }

          source.on("error", onerror);
          dest.on("error", onerror);

          // remove all the event listeners that were added.
          function cleanup() {
            source.removeListener("data", ondata);
            dest.removeListener("drain", ondrain);

            source.removeListener("end", onend);
            source.removeListener("close", onclose);

            source.removeListener("error", onerror);
            dest.removeListener("error", onerror);

            source.removeListener("end", cleanup);
            source.removeListener("close", cleanup);

            dest.removeListener("close", cleanup);
          }

          source.on("end", cleanup);
          source.on("close", cleanup);

          dest.on("close", cleanup);

          dest.emit("pipe", source);

          // Allow for unix-like usage: A.pipe(B).pipe(C)
          return dest;
        };
      },
      {
        events: 15,
        inherits: 16,
        "readable-stream/duplex.js": 20,
        "readable-stream/passthrough.js": 29,
        "readable-stream/readable.js": 30,
        "readable-stream/transform.js": 31,
        "readable-stream/writable.js": 32,
      },
    ],
    34: [
      function (require, module, exports) {
        // Copyright Joyent, Inc. and other Node contributors.
        //
        // Permission is hereby granted, free of charge, to any person obtaining a
        // copy of this software and associated documentation files (the
        // "Software"), to deal in the Software without restriction, including
        // without limitation the rights to use, copy, modify, merge, publish,
        // distribute, sublicense, and/or sell copies of the Software, and to permit
        // persons to whom the Software is furnished to do so, subject to the
        // following conditions:
        //
        // The above copyright notice and this permission notice shall be included
        // in all copies or substantial portions of the Software.
        //
        // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
        // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
        // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
        // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
        // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
        // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
        // USE OR OTHER DEALINGS IN THE SOFTWARE.

        var Buffer = require("buffer").Buffer;

        var isBufferEncoding =
          Buffer.isEncoding ||
          function (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 assertEncoding(encoding) {
          if (encoding && !isBufferEncoding(encoding)) {
            throw new Error("Unknown encoding: " + encoding);
          }
        }

        // StringDecoder provides an interface for efficiently splitting a series of
        // buffers into a series of JS strings without breaking apart multi-byte
        // characters. CESU-8 is handled as part of the UTF-8 encoding.
        //
        // @TODO Handling all encodings inside a single object makes it very difficult
        // to reason about this code, so it should be split up in the future.
        // @TODO There should be a utf8-strict encoding that rejects invalid UTF-8 code
        // points as used by CESU-8.
        var StringDecoder = (exports.StringDecoder = function (encoding) {
          this.encoding = (encoding || "utf8")
            .toLowerCase()
            .replace(/[-_]/, "");
          assertEncoding(encoding);
          switch (this.encoding) {
            case "utf8":
              // CESU-8 represents each of Surrogate Pair by 3-bytes
              this.surrogateSize = 3;
              break;
            case "ucs2":
            case "utf16le":
              // UTF-16 represents each of Surrogate Pair by 2-bytes
              this.surrogateSize = 2;
              this.detectIncompleteChar = utf16DetectIncompleteChar;
              break;
            case "base64":
              // Base-64 stores 3 bytes in 4 chars, and pads the remainder.
              this.surrogateSize = 3;
              this.detectIncompleteChar = base64DetectIncompleteChar;
              break;
            default:
              this.write = passThroughWrite;
              return;
          }

          // Enough space to store all bytes of a single character. UTF-8 needs 4
          // bytes, but CESU-8 may require up to 6 (3 bytes per surrogate).
          this.charBuffer = new Buffer(6);
          // Number of bytes received for the current incomplete multi-byte character.
          this.charReceived = 0;
          // Number of bytes expected for the current incomplete multi-byte character.
          this.charLength = 0;
        });

        // write decodes the given buffer and returns it as JS string that is
        // guaranteed to not contain any partial multi-byte characters. Any partial
        // character found at the end of the buffer is buffered up, and will be
        // returned when calling write again with the remaining bytes.
        //
        // Note: Converting a Buffer containing an orphan surrogate to a String
        // currently works, but converting a String to a Buffer (via `new Buffer`, or
        // Buffer#write) will replace incomplete surrogates with the unicode
        // replacement character. See https://codereview.chromium.org/121173009/ .
        StringDecoder.prototype.write = function (buffer) {
          var charStr = "";
          // if our last write ended with an incomplete multibyte character
          while (this.charLength) {
            // determine how many remaining bytes this buffer has to offer for this char
            var available =
              buffer.length >= this.charLength - this.charReceived
                ? this.charLength - this.charReceived
                : buffer.length;

            // add the new bytes to the char buffer
            buffer.copy(this.charBuffer, this.charReceived, 0, available);
            this.charReceived += available;

            if (this.charReceived < this.charLength) {
              // still not enough chars in this buffer? wait for more ...
              return "";
            }

            // remove bytes belonging to the current character from the buffer
            buffer = buffer.slice(available, buffer.length);

            // get the character that was split
            charStr = this.charBuffer
              .slice(0, this.charLength)
              .toString(this.encoding);

            // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
            var charCode = charStr.charCodeAt(charStr.length - 1);
            if (charCode >= 0xd800 && charCode <= 0xdbff) {
              this.charLength += this.surrogateSize;
              charStr = "";
              continue;
            }
            this.charReceived = this.charLength = 0;

            // if there are no more bytes in this buffer, just emit our char
            if (buffer.length === 0) {
              return charStr;
            }
            break;
          }

          // determine and set charLength / charReceived
          this.detectIncompleteChar(buffer);

          var end = buffer.length;
          if (this.charLength) {
            // buffer the incomplete character bytes we got
            buffer.copy(
              this.charBuffer,
              0,
              buffer.length - this.charReceived,
              end,
            );
            end -= this.charReceived;
          }

          charStr += buffer.toString(this.encoding, 0, end);

          var end = charStr.length - 1;
          var charCode = charStr.charCodeAt(end);
          // CESU-8: lead surrogate (D800-DBFF) is also the incomplete character
          if (charCode >= 0xd800 && charCode <= 0xdbff) {
            var size = this.surrogateSize;
            this.charLength += size;
            this.charReceived += size;
            this.charBuffer.copy(this.charBuffer, size, 0, size);
            buffer.copy(this.charBuffer, 0, 0, size);
            return charStr.substring(0, end);
          }

          // or just emit the charStr
          return charStr;
        };

        // detectIncompleteChar determines if there is an incomplete UTF-8 character at
        // the end of the given buffer. If so, it sets this.charLength to the byte
        // length that character, and sets this.charReceived to the number of bytes
        // that are available for this character.
        StringDecoder.prototype.detectIncompleteChar = function (buffer) {
          // determine how many bytes we have to check at the end of this buffer
          var i = buffer.length >= 3 ? 3 : buffer.length;

          // Figure out if one of the last i bytes of our buffer announces an
          // incomplete char.
          for (; i > 0; i--) {
            var c = buffer[buffer.length - i];

            // See http://en.wikipedia.org/wiki/UTF-8#Description

            // 110XXXXX
            if (i == 1 && c >> 5 == 0x06) {
              this.charLength = 2;
              break;
            }

            // 1110XXXX
            if (i <= 2 && c >> 4 == 0x0e) {
              this.charLength = 3;
              break;
            }

            // 11110XXX
            if (i <= 3 && c >> 3 == 0x1e) {
              this.charLength = 4;
              break;
            }
          }
          this.charReceived = i;
        };

        StringDecoder.prototype.end = function (buffer) {
          var res = "";
          if (buffer && buffer.length) res = this.write(buffer);

          if (this.charReceived) {
            var cr = this.charReceived;
            var buf = this.charBuffer;
            var enc = this.encoding;
            res += buf.slice(0, cr).toString(enc);
          }

          return res;
        };

        function passThroughWrite(buffer) {
          return buffer.toString(this.encoding);
        }

        function utf16DetectIncompleteChar(buffer) {
          this.charReceived = buffer.length % 2;
          this.charLength = this.charReceived ? 2 : 0;
        }

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

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

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

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

            if (process.noDeprecation === true) {
              return fn;
            }

            var warned = false;
            function deprecated() {
              if (!warned) {
                if (process.throwDeprecation) {
                  throw new Error(msg);
                } else if (process.traceDeprecation) {
                  console.trace(msg);
                } else {
                  console.error(msg);
                }
                warned = true;
              }
              return fn.apply(this, arguments);
            }

            return deprecated;
          };

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

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

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

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

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

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

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

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

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

            return hash;
          }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

            ctx.seen.push(value);

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

            ctx.seen.pop();

            return reduceToSingleString(output, base, braces);
          }

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

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

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

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

            return name + ": " + str;
          }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

          exports.isBuffer = require("./support/isBuffer");

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

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

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

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

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

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

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

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

          function hasOwnProperty(obj, prop) {
            return Object.prototype.hasOwnProperty.call(obj, prop);
          }
        }).call(
          this,
          require("_process"),
          typeof global !== "undefined"
            ? global
            : typeof self !== "undefined"
            ? self
            : typeof window !== "undefined"
            ? window
            : {},
        );
      },
      { "./support/isBuffer": 35, _process: 19, inherits: 16 },
    ],
    buffer: [
      function (require, module, exports) {
        (function (global) {
          /*!
           * The buffer module from node.js, for the browser.
           *
           * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
           * @license  MIT
           */
          /* eslint-disable no-proto */

          var base64 = require("base64-js");
          var ieee754 = require("ieee754");
          var isArray = require("is-array");

          exports.Buffer = Buffer;
          exports.SlowBuffer = SlowBuffer;
          exports.INSPECT_MAX_BYTES = 50;
          Buffer.poolSize = 8192; // not used by this implementation

          var rootParent = {};

          /**
 * If `Buffer.TYPED_ARRAY_SUPPORT`:
 *   === true    Use Uint8Array implementation (fastest)
 *   === false   Use Object implementation (most compatible, even IE6)
 *
 * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
 * Opera 11.6+, iOS 4.2+.
 *
 * Due to various browser bugs, sometimes the Object implementation will be used even
 * when the browser supports typed arrays.
 *
 * Note:
 *
 *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
 *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
 *
 *   - Safari 5-7 lacks support for changing the `Object.prototype.constructor` property
 *     on objects.
 *
 *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
 *
 *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
 *     incorrect length in some situations.

 * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
 * get the Object implementation, which is slower but behaves correctly.
 */
          Buffer.TYPED_ARRAY_SUPPORT =
            global.TYPED_ARRAY_SUPPORT !== undefined
              ? global.TYPED_ARRAY_SUPPORT
              : typedArraySupport();

          function typedArraySupport() {
            function Bar() {}
            try {
              var arr = new Uint8Array(1);
              arr.foo = function () {
                return 42;
              };
              arr.constructor = Bar;
              return (
                arr.foo() === 42 && // typed array instances can be augmented
                arr.constructor === Bar && // constructor can be set
                typeof arr.subarray === "function" && // chrome 9-10 lack `subarray`
                arr.subarray(1, 1).byteLength === 0
              ); // ie10 has broken `subarray`
            } catch (e) {
              return false;
            }
          }

          function kMaxLength() {
            return Buffer.TYPED_ARRAY_SUPPORT ? 0x7fffffff : 0x3fffffff;
          }

          /**
           * Class: Buffer
           * =============
           *
           * The Buffer constructor returns instances of `Uint8Array` that are augmented
           * with function properties for all the node `Buffer` API functions. We use
           * `Uint8Array` so that square bracket notation works as expected -- it returns
           * a single octet.
           *
           * By augmenting the instances, we can avoid modifying the `Uint8Array`
           * prototype.
           */
          function Buffer(arg) {
            if (!(this instanceof Buffer)) {
              // Avoid going through an ArgumentsAdaptorTrampoline in the common case.
              if (arguments.length > 1) return new Buffer(arg, arguments[1]);
              return new Buffer(arg);
            }

            this.length = 0;
            this.parent = undefined;

            // Common case.
            if (typeof arg === "number") {
              return fromNumber(this, arg);
            }

            // Slightly less common case.
            if (typeof arg === "string") {
              return fromString(
                this,
                arg,
                arguments.length > 1 ? arguments[1] : "utf8",
              );
            }

            // Unusual.
            return fromObject(this, arg);
          }

          function fromNumber(that, length) {
            that = allocate(that, length < 0 ? 0 : checked(length) | 0);
            if (!Buffer.TYPED_ARRAY_SUPPORT) {
              for (var i = 0; i < length; i++) {
                that[i] = 0;
              }
            }
            return that;
          }

          function fromString(that, string, encoding) {
            if (typeof encoding !== "string" || encoding === "")
              encoding = "utf8";

            // Assumption: byteLength() return value is always < kMaxLength.
            var length = byteLength(string, encoding) | 0;
            that = allocate(that, length);

            that.write(string, encoding);
            return that;
          }

          function fromObject(that, object) {
            if (Buffer.isBuffer(object)) return fromBuffer(that, object);

            if (isArray(object)) return fromArray(that, object);

            if (object == null) {
              throw new TypeError(
                "must start with number, buffer, array or string",
              );
            }

            if (typeof ArrayBuffer !== "undefined") {
              if (object.buffer instanceof ArrayBuffer) {
                return fromTypedArray(that, object);
              }
              if (object instanceof ArrayBuffer) {
                return fromArrayBuffer(that, object);
              }
            }

            if (object.length) return fromArrayLike(that, object);

            return fromJsonObject(that, object);
          }

          function fromBuffer(that, buffer) {
            var length = checked(buffer.length) | 0;
            that = allocate(that, length);
            buffer.copy(that, 0, 0, length);
            return that;
          }

          function fromArray(that, array) {
            var length = checked(array.length) | 0;
            that = allocate(that, length);
            for (var i = 0; i < length; i += 1) {
              that[i] = array[i] & 255;
            }
            return that;
          }

          // Duplicate of fromArray() to keep fromArray() monomorphic.
          function fromTypedArray(that, array) {
            var length = checked(array.length) | 0;
            that = allocate(that, length);
            // Truncating the elements is probably not what people expect from typed
            // arrays with BYTES_PER_ELEMENT > 1 but it's compatible with the behavior
            // of the old Buffer constructor.
            for (var i = 0; i < length; i += 1) {
              that[i] = array[i] & 255;
            }
            return that;
          }

          function fromArrayBuffer(that, array) {
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              // Return an augmented `Uint8Array` instance, for best performance
              array.byteLength;
              that = Buffer._augment(new Uint8Array(array));
            } else {
              // Fallback: Return an object instance of the Buffer class
              that = fromTypedArray(that, new Uint8Array(array));
            }
            return that;
          }

          function fromArrayLike(that, array) {
            var length = checked(array.length) | 0;
            that = allocate(that, length);
            for (var i = 0; i < length; i += 1) {
              that[i] = array[i] & 255;
            }
            return that;
          }

          // Deserialize { type: 'Buffer', data: [1,2,3,...] } into a Buffer object.
          // Returns a zero-length buffer for inputs that don't conform to the spec.
          function fromJsonObject(that, object) {
            var array;
            var length = 0;

            if (object.type === "Buffer" && isArray(object.data)) {
              array = object.data;
              length = checked(array.length) | 0;
            }
            that = allocate(that, length);

            for (var i = 0; i < length; i += 1) {
              that[i] = array[i] & 255;
            }
            return that;
          }

          if (Buffer.TYPED_ARRAY_SUPPORT) {
            Buffer.prototype.__proto__ = Uint8Array.prototype;
            Buffer.__proto__ = Uint8Array;
          }

          function allocate(that, length) {
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              // Return an augmented `Uint8Array` instance, for best performance
              that = Buffer._augment(new Uint8Array(length));
              that.__proto__ = Buffer.prototype;
            } else {
              // Fallback: Return an object instance of the Buffer class
              that.length = length;
              that._isBuffer = true;
            }

            var fromPool = length !== 0 && length <= Buffer.poolSize >>> 1;
            if (fromPool) that.parent = rootParent;

            return that;
          }

          function checked(length) {
            // Note: cannot use `length < kMaxLength` here because that fails when
            // length is NaN (which is otherwise coerced to zero.)
            if (length >= kMaxLength()) {
              throw new RangeError(
                "Attempt to allocate Buffer larger than maximum " +
                  "size: 0x" +
                  kMaxLength().toString(16) +
                  " bytes",
              );
            }
            return length | 0;
          }

          function SlowBuffer(subject, encoding) {
            if (!(this instanceof SlowBuffer))
              return new SlowBuffer(subject, encoding);

            var buf = new Buffer(subject, encoding);
            delete buf.parent;
            return buf;
          }

          Buffer.isBuffer = function isBuffer(b) {
            return !!(b != null && b._isBuffer);
          };

          Buffer.compare = function compare(a, b) {
            if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
              throw new TypeError("Arguments must be Buffers");
            }

            if (a === b) return 0;

            var x = a.length;
            var y = b.length;

            var i = 0;
            var len = Math.min(x, y);
            while (i < len) {
              if (a[i] !== b[i]) break;

              ++i;
            }

            if (i !== len) {
              x = a[i];
              y = b[i];
            }

            if (x < y) return -1;
            if (y < x) return 1;
            return 0;
          };

          Buffer.isEncoding = function isEncoding(encoding) {
            switch (String(encoding).toLowerCase()) {
              case "hex":
              case "utf8":
              case "utf-8":
              case "ascii":
              case "binary":
              case "base64":
              case "raw":
              case "ucs2":
              case "ucs-2":
              case "utf16le":
              case "utf-16le":
                return true;
              default:
                return false;
            }
          };

          Buffer.concat = function concat(list, length) {
            if (!isArray(list))
              throw new TypeError("list argument must be an Array of Buffers.");

            if (list.length === 0) {
              return new Buffer(0);
            }

            var i;
            if (length === undefined) {
              length = 0;
              for (i = 0; i < list.length; i++) {
                length += list[i].length;
              }
            }

            var buf = new Buffer(length);
            var pos = 0;
            for (i = 0; i < list.length; i++) {
              var item = list[i];
              item.copy(buf, pos);
              pos += item.length;
            }
            return buf;
          };

          function byteLength(string, encoding) {
            if (typeof string !== "string") string = "" + string;

            var len = string.length;
            if (len === 0) return 0;

            // Use a for loop to avoid recursion
            var loweredCase = false;
            for (;;) {
              switch (encoding) {
                case "ascii":
                case "binary":
                // Deprecated
                case "raw":
                case "raws":
                  return len;
                case "utf8":
                case "utf-8":
                  return utf8ToBytes(string).length;
                case "ucs2":
                case "ucs-2":
                case "utf16le":
                case "utf-16le":
                  return len * 2;
                case "hex":
                  return len >>> 1;
                case "base64":
                  return base64ToBytes(string).length;
                default:
                  if (loweredCase) return utf8ToBytes(string).length; // assume utf8
                  encoding = ("" + encoding).toLowerCase();
                  loweredCase = true;
              }
            }
          }
          Buffer.byteLength = byteLength;

          // pre-set for values that may exist in the future
          Buffer.prototype.length = undefined;
          Buffer.prototype.parent = undefined;

          function slowToString(encoding, start, end) {
            var loweredCase = false;

            start = start | 0;
            end = end === undefined || end === Infinity ? this.length : end | 0;

            if (!encoding) encoding = "utf8";
            if (start < 0) start = 0;
            if (end > this.length) end = this.length;
            if (end <= start) return "";

            while (true) {
              switch (encoding) {
                case "hex":
                  return hexSlice(this, start, end);

                case "utf8":
                case "utf-8":
                  return utf8Slice(this, start, end);

                case "ascii":
                  return asciiSlice(this, start, end);

                case "binary":
                  return binarySlice(this, start, end);

                case "base64":
                  return base64Slice(this, start, end);

                case "ucs2":
                case "ucs-2":
                case "utf16le":
                case "utf-16le":
                  return utf16leSlice(this, start, end);

                default:
                  if (loweredCase)
                    throw new TypeError("Unknown encoding: " + encoding);
                  encoding = (encoding + "").toLowerCase();
                  loweredCase = true;
              }
            }
          }

          Buffer.prototype.toString = function toString() {
            var length = this.length | 0;
            if (length === 0) return "";
            if (arguments.length === 0) return utf8Slice(this, 0, length);
            return slowToString.apply(this, arguments);
          };

          Buffer.prototype.equals = function equals(b) {
            if (!Buffer.isBuffer(b))
              throw new TypeError("Argument must be a Buffer");
            if (this === b) return true;
            return Buffer.compare(this, b) === 0;
          };

          Buffer.prototype.inspect = function inspect() {
            var str = "";
            var max = exports.INSPECT_MAX_BYTES;
            if (this.length > 0) {
              str = this.toString("hex", 0, max).match(/.{2}/g).join(" ");
              if (this.length > max) str += " ... ";
            }
            return "<Buffer " + str + ">";
          };

          Buffer.prototype.compare = function compare(b) {
            if (!Buffer.isBuffer(b))
              throw new TypeError("Argument must be a Buffer");
            if (this === b) return 0;
            return Buffer.compare(this, b);
          };

          Buffer.prototype.indexOf = function indexOf(val, byteOffset) {
            if (byteOffset > 0x7fffffff) byteOffset = 0x7fffffff;
            else if (byteOffset < -0x80000000) byteOffset = -0x80000000;
            byteOffset >>= 0;

            if (this.length === 0) return -1;
            if (byteOffset >= this.length) return -1;

            // Negative offsets start from the end of the buffer
            if (byteOffset < 0)
              byteOffset = Math.max(this.length + byteOffset, 0);

            if (typeof val === "string") {
              if (val.length === 0) return -1; // special case: looking for empty string always fails
              return String.prototype.indexOf.call(this, val, byteOffset);
            }
            if (Buffer.isBuffer(val)) {
              return arrayIndexOf(this, val, byteOffset);
            }
            if (typeof val === "number") {
              if (
                Buffer.TYPED_ARRAY_SUPPORT &&
                Uint8Array.prototype.indexOf === "function"
              ) {
                return Uint8Array.prototype.indexOf.call(this, val, byteOffset);
              }
              return arrayIndexOf(this, [val], byteOffset);
            }

            function arrayIndexOf(arr, val, byteOffset) {
              var foundIndex = -1;
              for (var i = 0; byteOffset + i < arr.length; i++) {
                if (
                  arr[byteOffset + i] ===
                  val[foundIndex === -1 ? 0 : i - foundIndex]
                ) {
                  if (foundIndex === -1) foundIndex = i;
                  if (i - foundIndex + 1 === val.length)
                    return byteOffset + foundIndex;
                } else {
                  foundIndex = -1;
                }
              }
              return -1;
            }

            throw new TypeError("val must be string, number or Buffer");
          };

          // `get` is deprecated
          Buffer.prototype.get = function get(offset) {
            console.log(
              ".get() is deprecated. Access using array indexes instead.",
            );
            return this.readUInt8(offset);
          };

          // `set` is deprecated
          Buffer.prototype.set = function set(v, offset) {
            console.log(
              ".set() is deprecated. Access using array indexes instead.",
            );
            return this.writeUInt8(v, offset);
          };

          function hexWrite(buf, string, offset, length) {
            offset = Number(offset) || 0;
            var remaining = buf.length - offset;
            if (!length) {
              length = remaining;
            } else {
              length = Number(length);
              if (length > remaining) {
                length = remaining;
              }
            }

            // must be an even number of digits
            var strLen = string.length;
            if (strLen % 2 !== 0) throw new Error("Invalid hex string");

            if (length > strLen / 2) {
              length = strLen / 2;
            }
            for (var i = 0; i < length; i++) {
              var parsed = parseInt(string.substr(i * 2, 2), 16);
              if (isNaN(parsed)) throw new Error("Invalid hex string");
              buf[offset + i] = parsed;
            }
            return i;
          }

          function utf8Write(buf, string, offset, length) {
            return blitBuffer(
              utf8ToBytes(string, buf.length - offset),
              buf,
              offset,
              length,
            );
          }

          function asciiWrite(buf, string, offset, length) {
            return blitBuffer(asciiToBytes(string), buf, offset, length);
          }

          function binaryWrite(buf, string, offset, length) {
            return asciiWrite(buf, string, offset, length);
          }

          function base64Write(buf, string, offset, length) {
            return blitBuffer(base64ToBytes(string), buf, offset, length);
          }

          function ucs2Write(buf, string, offset, length) {
            return blitBuffer(
              utf16leToBytes(string, buf.length - offset),
              buf,
              offset,
              length,
            );
          }

          Buffer.prototype.write = function write(
            string,
            offset,
            length,
            encoding,
          ) {
            // Buffer#write(string)
            if (offset === undefined) {
              encoding = "utf8";
              length = this.length;
              offset = 0;
              // Buffer#write(string, encoding)
            } else if (length === undefined && typeof offset === "string") {
              encoding = offset;
              length = this.length;
              offset = 0;
              // Buffer#write(string, offset[, length][, encoding])
            } else if (isFinite(offset)) {
              offset = offset | 0;
              if (isFinite(length)) {
                length = length | 0;
                if (encoding === undefined) encoding = "utf8";
              } else {
                encoding = length;
                length = undefined;
              }
              // legacy write(string, encoding, offset, length) - remove in v0.13
            } else {
              var swap = encoding;
              encoding = offset;
              offset = length | 0;
              length = swap;
            }

            var remaining = this.length - offset;
            if (length === undefined || length > remaining) length = remaining;

            if (
              (string.length > 0 && (length < 0 || offset < 0)) ||
              offset > this.length
            ) {
              throw new RangeError("attempt to write outside buffer bounds");
            }

            if (!encoding) encoding = "utf8";

            var loweredCase = false;
            for (;;) {
              switch (encoding) {
                case "hex":
                  return hexWrite(this, string, offset, length);

                case "utf8":
                case "utf-8":
                  return utf8Write(this, string, offset, length);

                case "ascii":
                  return asciiWrite(this, string, offset, length);

                case "binary":
                  return binaryWrite(this, string, offset, length);

                case "base64":
                  // Warning: maxLength not taken into account in base64Write
                  return base64Write(this, string, offset, length);

                case "ucs2":
                case "ucs-2":
                case "utf16le":
                case "utf-16le":
                  return ucs2Write(this, string, offset, length);

                default:
                  if (loweredCase)
                    throw new TypeError("Unknown encoding: " + encoding);
                  encoding = ("" + encoding).toLowerCase();
                  loweredCase = true;
              }
            }
          };

          Buffer.prototype.toJSON = function toJSON() {
            return {
              type: "Buffer",
              data: Array.prototype.slice.call(this._arr || this, 0),
            };
          };

          function base64Slice(buf, start, end) {
            if (start === 0 && end === buf.length) {
              return base64.fromByteArray(buf);
            } else {
              return base64.fromByteArray(buf.slice(start, end));
            }
          }

          function utf8Slice(buf, start, end) {
            end = Math.min(buf.length, end);
            var res = [];

            var i = start;
            while (i < end) {
              var firstByte = buf[i];
              var codePoint = null;
              var bytesPerSequence =
                firstByte > 0xef
                  ? 4
                  : firstByte > 0xdf
                  ? 3
                  : firstByte > 0xbf
                  ? 2
                  : 1;

              if (i + bytesPerSequence <= end) {
                var secondByte, thirdByte, fourthByte, tempCodePoint;

                switch (bytesPerSequence) {
                  case 1:
                    if (firstByte < 0x80) {
                      codePoint = firstByte;
                    }
                    break;
                  case 2:
                    secondByte = buf[i + 1];
                    if ((secondByte & 0xc0) === 0x80) {
                      tempCodePoint =
                        ((firstByte & 0x1f) << 0x6) | (secondByte & 0x3f);
                      if (tempCodePoint > 0x7f) {
                        codePoint = tempCodePoint;
                      }
                    }
                    break;
                  case 3:
                    secondByte = buf[i + 1];
                    thirdByte = buf[i + 2];
                    if (
                      (secondByte & 0xc0) === 0x80 &&
                      (thirdByte & 0xc0) === 0x80
                    ) {
                      tempCodePoint =
                        ((firstByte & 0xf) << 0xc) |
                        ((secondByte & 0x3f) << 0x6) |
                        (thirdByte & 0x3f);
                      if (
                        tempCodePoint > 0x7ff &&
                        (tempCodePoint < 0xd800 || tempCodePoint > 0xdfff)
                      ) {
                        codePoint = tempCodePoint;
                      }
                    }
                    break;
                  case 4:
                    secondByte = buf[i + 1];
                    thirdByte = buf[i + 2];
                    fourthByte = buf[i + 3];
                    if (
                      (secondByte & 0xc0) === 0x80 &&
                      (thirdByte & 0xc0) === 0x80 &&
                      (fourthByte & 0xc0) === 0x80
                    ) {
                      tempCodePoint =
                        ((firstByte & 0xf) << 0x12) |
                        ((secondByte & 0x3f) << 0xc) |
                        ((thirdByte & 0x3f) << 0x6) |
                        (fourthByte & 0x3f);
                      if (tempCodePoint > 0xffff && tempCodePoint < 0x110000) {
                        codePoint = tempCodePoint;
                      }
                    }
                }
              }

              if (codePoint === null) {
                // we did not generate a valid codePoint so insert a
                // replacement char (U+FFFD) and advance only 1 byte
                codePoint = 0xfffd;
                bytesPerSequence = 1;
              } else if (codePoint > 0xffff) {
                // encode to utf16 (surrogate pair dance)
                codePoint -= 0x10000;
                res.push(((codePoint >>> 10) & 0x3ff) | 0xd800);
                codePoint = 0xdc00 | (codePoint & 0x3ff);
              }

              res.push(codePoint);
              i += bytesPerSequence;
            }

            return decodeCodePointsArray(res);
          }

          // Based on http://stackoverflow.com/a/22747272/680742, the browser with
          // the lowest limit is Chrome, with 0x10000 args.
          // We go 1 magnitude less, for safety
          var MAX_ARGUMENTS_LENGTH = 0x1000;

          function decodeCodePointsArray(codePoints) {
            var len = codePoints.length;
            if (len <= MAX_ARGUMENTS_LENGTH) {
              return String.fromCharCode.apply(String, codePoints); // avoid extra slice()
            }

            // Decode in chunks to avoid "call stack size exceeded".
            var res = "";
            var i = 0;
            while (i < len) {
              res += String.fromCharCode.apply(
                String,
                codePoints.slice(i, (i += MAX_ARGUMENTS_LENGTH)),
              );
            }
            return res;
          }

          function asciiSlice(buf, start, end) {
            var ret = "";
            end = Math.min(buf.length, end);

            for (var i = start; i < end; i++) {
              ret += String.fromCharCode(buf[i] & 0x7f);
            }
            return ret;
          }

          function binarySlice(buf, start, end) {
            var ret = "";
            end = Math.min(buf.length, end);

            for (var i = start; i < end; i++) {
              ret += String.fromCharCode(buf[i]);
            }
            return ret;
          }

          function hexSlice(buf, start, end) {
            var len = buf.length;

            if (!start || start < 0) start = 0;
            if (!end || end < 0 || end > len) end = len;

            var out = "";
            for (var i = start; i < end; i++) {
              out += toHex(buf[i]);
            }
            return out;
          }

          function utf16leSlice(buf, start, end) {
            var bytes = buf.slice(start, end);
            var res = "";
            for (var i = 0; i < bytes.length; i += 2) {
              res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
            }
            return res;
          }

          Buffer.prototype.slice = function slice(start, end) {
            var len = this.length;
            start = ~~start;
            end = end === undefined ? len : ~~end;

            if (start < 0) {
              start += len;
              if (start < 0) start = 0;
            } else if (start > len) {
              start = len;
            }

            if (end < 0) {
              end += len;
              if (end < 0) end = 0;
            } else if (end > len) {
              end = len;
            }

            if (end < start) end = start;

            var newBuf;
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              newBuf = Buffer._augment(this.subarray(start, end));
            } else {
              var sliceLen = end - start;
              newBuf = new Buffer(sliceLen, undefined);
              for (var i = 0; i < sliceLen; i++) {
                newBuf[i] = this[i + start];
              }
            }

            if (newBuf.length) newBuf.parent = this.parent || this;

            return newBuf;
          };

          /*
           * Need to make sure that buffer isn't trying to write out of bounds.
           */
          function checkOffset(offset, ext, length) {
            if (offset % 1 !== 0 || offset < 0)
              throw new RangeError("offset is not uint");
            if (offset + ext > length)
              throw new RangeError("Trying to access beyond buffer length");
          }

          Buffer.prototype.readUIntLE = function readUIntLE(
            offset,
            byteLength,
            noAssert,
          ) {
            offset = offset | 0;
            byteLength = byteLength | 0;
            if (!noAssert) checkOffset(offset, byteLength, this.length);

            var val = this[offset];
            var mul = 1;
            var i = 0;
            while (++i < byteLength && (mul *= 0x100)) {
              val += this[offset + i] * mul;
            }

            return val;
          };

          Buffer.prototype.readUIntBE = function readUIntBE(
            offset,
            byteLength,
            noAssert,
          ) {
            offset = offset | 0;
            byteLength = byteLength | 0;
            if (!noAssert) {
              checkOffset(offset, byteLength, this.length);
            }

            var val = this[offset + --byteLength];
            var mul = 1;
            while (byteLength > 0 && (mul *= 0x100)) {
              val += this[offset + --byteLength] * mul;
            }

            return val;
          };

          Buffer.prototype.readUInt8 = function readUInt8(offset, noAssert) {
            if (!noAssert) checkOffset(offset, 1, this.length);
            return this[offset];
          };

          Buffer.prototype.readUInt16LE = function readUInt16LE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 2, this.length);
            return this[offset] | (this[offset + 1] << 8);
          };

          Buffer.prototype.readUInt16BE = function readUInt16BE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 2, this.length);
            return (this[offset] << 8) | this[offset + 1];
          };

          Buffer.prototype.readUInt32LE = function readUInt32LE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 4, this.length);

            return (
              (this[offset] |
                (this[offset + 1] << 8) |
                (this[offset + 2] << 16)) +
              this[offset + 3] * 0x1000000
            );
          };

          Buffer.prototype.readUInt32BE = function readUInt32BE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 4, this.length);

            return (
              this[offset] * 0x1000000 +
              ((this[offset + 1] << 16) |
                (this[offset + 2] << 8) |
                this[offset + 3])
            );
          };

          Buffer.prototype.readIntLE = function readIntLE(
            offset,
            byteLength,
            noAssert,
          ) {
            offset = offset | 0;
            byteLength = byteLength | 0;
            if (!noAssert) checkOffset(offset, byteLength, this.length);

            var val = this[offset];
            var mul = 1;
            var i = 0;
            while (++i < byteLength && (mul *= 0x100)) {
              val += this[offset + i] * mul;
            }
            mul *= 0x80;

            if (val >= mul) val -= Math.pow(2, 8 * byteLength);

            return val;
          };

          Buffer.prototype.readIntBE = function readIntBE(
            offset,
            byteLength,
            noAssert,
          ) {
            offset = offset | 0;
            byteLength = byteLength | 0;
            if (!noAssert) checkOffset(offset, byteLength, this.length);

            var i = byteLength;
            var mul = 1;
            var val = this[offset + --i];
            while (i > 0 && (mul *= 0x100)) {
              val += this[offset + --i] * mul;
            }
            mul *= 0x80;

            if (val >= mul) val -= Math.pow(2, 8 * byteLength);

            return val;
          };

          Buffer.prototype.readInt8 = function readInt8(offset, noAssert) {
            if (!noAssert) checkOffset(offset, 1, this.length);
            if (!(this[offset] & 0x80)) return this[offset];
            return (0xff - this[offset] + 1) * -1;
          };

          Buffer.prototype.readInt16LE = function readInt16LE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 2, this.length);
            var val = this[offset] | (this[offset + 1] << 8);
            return val & 0x8000 ? val | 0xffff0000 : val;
          };

          Buffer.prototype.readInt16BE = function readInt16BE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 2, this.length);
            var val = this[offset + 1] | (this[offset] << 8);
            return val & 0x8000 ? val | 0xffff0000 : val;
          };

          Buffer.prototype.readInt32LE = function readInt32LE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 4, this.length);

            return (
              this[offset] |
              (this[offset + 1] << 8) |
              (this[offset + 2] << 16) |
              (this[offset + 3] << 24)
            );
          };

          Buffer.prototype.readInt32BE = function readInt32BE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 4, this.length);

            return (
              (this[offset] << 24) |
              (this[offset + 1] << 16) |
              (this[offset + 2] << 8) |
              this[offset + 3]
            );
          };

          Buffer.prototype.readFloatLE = function readFloatLE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 4, this.length);
            return ieee754.read(this, offset, true, 23, 4);
          };

          Buffer.prototype.readFloatBE = function readFloatBE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 4, this.length);
            return ieee754.read(this, offset, false, 23, 4);
          };

          Buffer.prototype.readDoubleLE = function readDoubleLE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 8, this.length);
            return ieee754.read(this, offset, true, 52, 8);
          };

          Buffer.prototype.readDoubleBE = function readDoubleBE(
            offset,
            noAssert,
          ) {
            if (!noAssert) checkOffset(offset, 8, this.length);
            return ieee754.read(this, offset, false, 52, 8);
          };

          function checkInt(buf, value, offset, ext, max, min) {
            if (!Buffer.isBuffer(buf))
              throw new TypeError("buffer must be a Buffer instance");
            if (value > max || value < min)
              throw new RangeError("value is out of bounds");
            if (offset + ext > buf.length)
              throw new RangeError("index out of range");
          }

          Buffer.prototype.writeUIntLE = function writeUIntLE(
            value,
            offset,
            byteLength,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            byteLength = byteLength | 0;
            if (!noAssert)
              checkInt(
                this,
                value,
                offset,
                byteLength,
                Math.pow(2, 8 * byteLength),
                0,
              );

            var mul = 1;
            var i = 0;
            this[offset] = value & 0xff;
            while (++i < byteLength && (mul *= 0x100)) {
              this[offset + i] = (value / mul) & 0xff;
            }

            return offset + byteLength;
          };

          Buffer.prototype.writeUIntBE = function writeUIntBE(
            value,
            offset,
            byteLength,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            byteLength = byteLength | 0;
            if (!noAssert)
              checkInt(
                this,
                value,
                offset,
                byteLength,
                Math.pow(2, 8 * byteLength),
                0,
              );

            var i = byteLength - 1;
            var mul = 1;
            this[offset + i] = value & 0xff;
            while (--i >= 0 && (mul *= 0x100)) {
              this[offset + i] = (value / mul) & 0xff;
            }

            return offset + byteLength;
          };

          Buffer.prototype.writeUInt8 = function writeUInt8(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
            if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
            this[offset] = value & 0xff;
            return offset + 1;
          };

          function objectWriteUInt16(buf, value, offset, littleEndian) {
            if (value < 0) value = 0xffff + value + 1;
            for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; i++) {
              buf[offset + i] =
                (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
                ((littleEndian ? i : 1 - i) * 8);
            }
          }

          Buffer.prototype.writeUInt16LE = function writeUInt16LE(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              this[offset] = value & 0xff;
              this[offset + 1] = value >>> 8;
            } else {
              objectWriteUInt16(this, value, offset, true);
            }
            return offset + 2;
          };

          Buffer.prototype.writeUInt16BE = function writeUInt16BE(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              this[offset] = value >>> 8;
              this[offset + 1] = value & 0xff;
            } else {
              objectWriteUInt16(this, value, offset, false);
            }
            return offset + 2;
          };

          function objectWriteUInt32(buf, value, offset, littleEndian) {
            if (value < 0) value = 0xffffffff + value + 1;
            for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; i++) {
              buf[offset + i] =
                (value >>> ((littleEndian ? i : 3 - i) * 8)) & 0xff;
            }
          }

          Buffer.prototype.writeUInt32LE = function writeUInt32LE(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              this[offset + 3] = value >>> 24;
              this[offset + 2] = value >>> 16;
              this[offset + 1] = value >>> 8;
              this[offset] = value & 0xff;
            } else {
              objectWriteUInt32(this, value, offset, true);
            }
            return offset + 4;
          };

          Buffer.prototype.writeUInt32BE = function writeUInt32BE(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              this[offset] = value >>> 24;
              this[offset + 1] = value >>> 16;
              this[offset + 2] = value >>> 8;
              this[offset + 3] = value & 0xff;
            } else {
              objectWriteUInt32(this, value, offset, false);
            }
            return offset + 4;
          };

          Buffer.prototype.writeIntLE = function writeIntLE(
            value,
            offset,
            byteLength,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) {
              var limit = Math.pow(2, 8 * byteLength - 1);

              checkInt(this, value, offset, byteLength, limit - 1, -limit);
            }

            var i = 0;
            var mul = 1;
            var sub = value < 0 ? 1 : 0;
            this[offset] = value & 0xff;
            while (++i < byteLength && (mul *= 0x100)) {
              this[offset + i] = (((value / mul) >> 0) - sub) & 0xff;
            }

            return offset + byteLength;
          };

          Buffer.prototype.writeIntBE = function writeIntBE(
            value,
            offset,
            byteLength,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) {
              var limit = Math.pow(2, 8 * byteLength - 1);

              checkInt(this, value, offset, byteLength, limit - 1, -limit);
            }

            var i = byteLength - 1;
            var mul = 1;
            var sub = value < 0 ? 1 : 0;
            this[offset + i] = value & 0xff;
            while (--i >= 0 && (mul *= 0x100)) {
              this[offset + i] = (((value / mul) >> 0) - sub) & 0xff;
            }

            return offset + byteLength;
          };

          Buffer.prototype.writeInt8 = function writeInt8(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
            if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
            if (value < 0) value = 0xff + value + 1;
            this[offset] = value & 0xff;
            return offset + 1;
          };

          Buffer.prototype.writeInt16LE = function writeInt16LE(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              this[offset] = value & 0xff;
              this[offset + 1] = value >>> 8;
            } else {
              objectWriteUInt16(this, value, offset, true);
            }
            return offset + 2;
          };

          Buffer.prototype.writeInt16BE = function writeInt16BE(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              this[offset] = value >>> 8;
              this[offset + 1] = value & 0xff;
            } else {
              objectWriteUInt16(this, value, offset, false);
            }
            return offset + 2;
          };

          Buffer.prototype.writeInt32LE = function writeInt32LE(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert)
              checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              this[offset] = value & 0xff;
              this[offset + 1] = value >>> 8;
              this[offset + 2] = value >>> 16;
              this[offset + 3] = value >>> 24;
            } else {
              objectWriteUInt32(this, value, offset, true);
            }
            return offset + 4;
          };

          Buffer.prototype.writeInt32BE = function writeInt32BE(
            value,
            offset,
            noAssert,
          ) {
            value = +value;
            offset = offset | 0;
            if (!noAssert)
              checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
            if (value < 0) value = 0xffffffff + value + 1;
            if (Buffer.TYPED_ARRAY_SUPPORT) {
              this[offset] = value >>> 24;
              this[offset + 1] = value >>> 16;
              this[offset + 2] = value >>> 8;
              this[offset + 3] = value & 0xff;
            } else {
              objectWriteUInt32(this, value, offset, false);
            }
            return offset + 4;
          };

          function checkIEEE754(buf, value, offset, ext, max, min) {
            if (value > max || value < min)
              throw new RangeError("value is out of bounds");
            if (offset + ext > buf.length)
              throw new RangeError("index out of range");
            if (offset < 0) throw new RangeError("index out of range");
          }

          function writeFloat(buf, value, offset, littleEndian, noAssert) {
            if (!noAssert) {
              checkIEEE754(
                buf,
                value,
                offset,
                4,
                3.4028234663852886e38,
                -3.4028234663852886e38,
              );
            }
            ieee754.write(buf, value, offset, littleEndian, 23, 4);
            return offset + 4;
          }

          Buffer.prototype.writeFloatLE = function writeFloatLE(
            value,
            offset,
            noAssert,
          ) {
            return writeFloat(this, value, offset, true, noAssert);
          };

          Buffer.prototype.writeFloatBE = function writeFloatBE(
            value,
            offset,
            noAssert,
          ) {
            return writeFloat(this, value, offset, false, noAssert);
          };

          function writeDouble(buf, value, offset, littleEndian, noAssert) {
            if (!noAssert) {
              checkIEEE754(
                buf,
                value,
                offset,
                8,
                1.7976931348623157e308,
                -1.7976931348623157e308,
              );
            }
            ieee754.write(buf, value, offset, littleEndian, 52, 8);
            return offset + 8;
          }

          Buffer.prototype.writeDoubleLE = function writeDoubleLE(
            value,
            offset,
            noAssert,
          ) {
            return writeDouble(this, value, offset, true, noAssert);
          };

          Buffer.prototype.writeDoubleBE = function writeDoubleBE(
            value,
            offset,
            noAssert,
          ) {
            return writeDouble(this, value, offset, false, noAssert);
          };

          // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
          Buffer.prototype.copy = function copy(
            target,
            targetStart,
            start,
            end,
          ) {
            if (!start) start = 0;
            if (!end && end !== 0) end = this.length;
            if (targetStart >= target.length) targetStart = target.length;
            if (!targetStart) targetStart = 0;
            if (end > 0 && end < start) end = start;

            // Copy 0 bytes; we're done
            if (end === start) return 0;
            if (target.length === 0 || this.length === 0) return 0;

            // Fatal error conditions
            if (targetStart < 0) {
              throw new RangeError("targetStart out of bounds");
            }
            if (start < 0 || start >= this.length)
              throw new RangeError("sourceStart out of bounds");
            if (end < 0) throw new RangeError("sourceEnd out of bounds");

            // Are we oob?
            if (end > this.length) end = this.length;
            if (target.length - targetStart < end - start) {
              end = target.length - targetStart + start;
            }

            var len = end - start;
            var i;

            if (this === target && start < targetStart && targetStart < end) {
              // descending copy from end
              for (i = len - 1; i >= 0; i--) {
                target[i + targetStart] = this[i + start];
              }
            } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
              // ascending copy from start
              for (i = 0; i < len; i++) {
                target[i + targetStart] = this[i + start];
              }
            } else {
              target._set(this.subarray(start, start + len), targetStart);
            }

            return len;
          };

          // fill(value, start=0, end=buffer.length)
          Buffer.prototype.fill = function fill(value, start, end) {
            if (!value) value = 0;
            if (!start) start = 0;
            if (!end) end = this.length;

            if (end < start) throw new RangeError("end < start");

            // Fill 0 bytes; we're done
            if (end === start) return;
            if (this.length === 0) return;

            if (start < 0 || start >= this.length)
              throw new RangeError("start out of bounds");
            if (end < 0 || end > this.length)
              throw new RangeError("end out of bounds");

            var i;
            if (typeof value === "number") {
              for (i = start; i < end; i++) {
                this[i] = value;
              }
            } else {
              var bytes = utf8ToBytes(value.toString());
              var len = bytes.length;
              for (i = start; i < end; i++) {
                this[i] = bytes[i % len];
              }
            }

            return this;
          };

          /**
           * Creates a new `ArrayBuffer` with the *copied* memory of the buffer instance.
           * Added in Node 0.12. Only available in browsers that support ArrayBuffer.
           */
          Buffer.prototype.toArrayBuffer = function toArrayBuffer() {
            if (typeof Uint8Array !== "undefined") {
              if (Buffer.TYPED_ARRAY_SUPPORT) {
                return new Buffer(this).buffer;
              } else {
                var buf = new Uint8Array(this.length);
                for (var i = 0, len = buf.length; i < len; i += 1) {
                  buf[i] = this[i];
                }
                return buf.buffer;
              }
            } else {
              throw new TypeError(
                "Buffer.toArrayBuffer not supported in this browser",
              );
            }
          };

          // HELPER FUNCTIONS
          // ================

          var BP = Buffer.prototype;

          /**
           * Augment a Uint8Array *instance* (not the Uint8Array class!) with Buffer methods
           */
          Buffer._augment = function _augment(arr) {
            arr.constructor = Buffer;
            arr._isBuffer = true;

            // save reference to original Uint8Array set method before overwriting
            arr._set = arr.set;

            // deprecated
            arr.get = BP.get;
            arr.set = BP.set;

            arr.write = BP.write;
            arr.toString = BP.toString;
            arr.toLocaleString = BP.toString;
            arr.toJSON = BP.toJSON;
            arr.equals = BP.equals;
            arr.compare = BP.compare;
            arr.indexOf = BP.indexOf;
            arr.copy = BP.copy;
            arr.slice = BP.slice;
            arr.readUIntLE = BP.readUIntLE;
            arr.readUIntBE = BP.readUIntBE;
            arr.readUInt8 = BP.readUInt8;
            arr.readUInt16LE = BP.readUInt16LE;
            arr.readUInt16BE = BP.readUInt16BE;
            arr.readUInt32LE = BP.readUInt32LE;
            arr.readUInt32BE = BP.readUInt32BE;
            arr.readIntLE = BP.readIntLE;
            arr.readIntBE = BP.readIntBE;
            arr.readInt8 = BP.readInt8;
            arr.readInt16LE = BP.readInt16LE;
            arr.readInt16BE = BP.readInt16BE;
            arr.readInt32LE = BP.readInt32LE;
            arr.readInt32BE = BP.readInt32BE;
            arr.readFloatLE = BP.readFloatLE;
            arr.readFloatBE = BP.readFloatBE;
            arr.readDoubleLE = BP.readDoubleLE;
            arr.readDoubleBE = BP.readDoubleBE;
            arr.writeUInt8 = BP.writeUInt8;
            arr.writeUIntLE = BP.writeUIntLE;
            arr.writeUIntBE = BP.writeUIntBE;
            arr.writeUInt16LE = BP.writeUInt16LE;
            arr.writeUInt16BE = BP.writeUInt16BE;
            arr.writeUInt32LE = BP.writeUInt32LE;
            arr.writeUInt32BE = BP.writeUInt32BE;
            arr.writeIntLE = BP.writeIntLE;
            arr.writeIntBE = BP.writeIntBE;
            arr.writeInt8 = BP.writeInt8;
            arr.writeInt16LE = BP.writeInt16LE;
            arr.writeInt16BE = BP.writeInt16BE;
            arr.writeInt32LE = BP.writeInt32LE;
            arr.writeInt32BE = BP.writeInt32BE;
            arr.writeFloatLE = BP.writeFloatLE;
            arr.writeFloatBE = BP.writeFloatBE;
            arr.writeDoubleLE = BP.writeDoubleLE;
            arr.writeDoubleBE = BP.writeDoubleBE;
            arr.fill = BP.fill;
            arr.inspect = BP.inspect;
            arr.toArrayBuffer = BP.toArrayBuffer;

            return arr;
          };

          var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;

          function base64clean(str) {
            // Node strips out invalid characters like \n and \t from the string, base64-js does not
            str = stringtrim(str).replace(INVALID_BASE64_RE, "");
            // Node converts strings with length < 2 to ''
            if (str.length < 2) return "";
            // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
            while (str.length % 4 !== 0) {
              str = str + "=";
            }
            return str;
          }

          function stringtrim(str) {
            if (str.trim) return str.trim();
            return str.replace(/^\s+|\s+$/g, "");
          }

          function toHex(n) {
            if (n < 16) return "0" + n.toString(16);
            return n.toString(16);
          }

          function utf8ToBytes(string, units) {
            units = units || Infinity;
            var codePoint;
            var length = string.length;
            var leadSurrogate = null;
            var bytes = [];

            for (var i = 0; i < length; i++) {
              codePoint = string.charCodeAt(i);

              // is surrogate component
              if (codePoint > 0xd7ff && codePoint < 0xe000) {
                // last char was a lead
                if (!leadSurrogate) {
                  // no lead yet
                  if (codePoint > 0xdbff) {
                    // unexpected trail
                    if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd);
                    continue;
                  } else if (i + 1 === length) {
                    // unpaired lead
                    if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd);
                    continue;
                  }

                  // valid lead
                  leadSurrogate = codePoint;

                  continue;
                }

                // 2 leads in a row
                if (codePoint < 0xdc00) {
                  if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd);
                  leadSurrogate = codePoint;
                  continue;
                }

                // valid surrogate pair
                codePoint =
                  ((leadSurrogate - 0xd800) << 10) |
                  (codePoint - 0xdc00) |
                  0x10000;
              } else if (leadSurrogate) {
                // valid bmp char, but last char was a lead
                if ((units -= 3) > -1) bytes.push(0xef, 0xbf, 0xbd);
              }

              leadSurrogate = null;

              // encode utf8
              if (codePoint < 0x80) {
                if ((units -= 1) < 0) break;
                bytes.push(codePoint);
              } else if (codePoint < 0x800) {
                if ((units -= 2) < 0) break;
                bytes.push(
                  (codePoint >> 0x6) | 0xc0,
                  (codePoint & 0x3f) | 0x80,
                );
              } else if (codePoint < 0x10000) {
                if ((units -= 3) < 0) break;
                bytes.push(
                  (codePoint >> 0xc) | 0xe0,
                  ((codePoint >> 0x6) & 0x3f) | 0x80,
                  (codePoint & 0x3f) | 0x80,
                );
              } else if (codePoint < 0x110000) {
                if ((units -= 4) < 0) break;
                bytes.push(
                  (codePoint >> 0x12) | 0xf0,
                  ((codePoint >> 0xc) & 0x3f) | 0x80,
                  ((codePoint >> 0x6) & 0x3f) | 0x80,
                  (codePoint & 0x3f) | 0x80,
                );
              } else {
                throw new Error("Invalid code point");
              }
            }

            return bytes;
          }

          function asciiToBytes(str) {
            var byteArray = [];
            for (var i = 0; i < str.length; i++) {
              // Node's code seems to be doing this and not & 0x7F..
              byteArray.push(str.charCodeAt(i) & 0xff);
            }
            return byteArray;
          }

          function utf16leToBytes(str, units) {
            var c, hi, lo;
            var byteArray = [];
            for (var i = 0; i < str.length; i++) {
              if ((units -= 2) < 0) break;

              c = str.charCodeAt(i);
              hi = c >> 8;
              lo = c % 256;
              byteArray.push(lo);
              byteArray.push(hi);
            }

            return byteArray;
          }

          function base64ToBytes(str) {
            return base64.toByteArray(base64clean(str));
          }

          function blitBuffer(src, dst, offset, length) {
            for (var i = 0; i < length; i++) {
              if (i + offset >= dst.length || i >= src.length) break;
              dst[i + offset] = src[i];
            }
            return i;
          }
        }).call(
          this,
          typeof global !== "undefined"
            ? global
            : typeof self !== "undefined"
            ? self
            : typeof window !== "undefined"
            ? window
            : {},
        );
      },
      { "base64-js": 12, ieee754: 13, "is-array": 14 },
    ],
    lz4: [
      function (require, module, exports) {
        module.exports = require("./static");

        module.exports.version = "0.5.1";
        module.exports.createDecoderStream = require("./decoder_stream");
        module.exports.decode = require("./decoder").LZ4_uncompress;

        module.exports.createEncoderStream = require("./encoder_stream");
        module.exports.encode = require("./encoder").LZ4_compress;

        // Expose block decoder and encoders
        var bindings = module.exports.utils.bindings;

        module.exports.decodeBlock = bindings.uncompress;

        module.exports.encodeBound = bindings.compressBound;
        module.exports.encodeBlock = bindings.compress;
        module.exports.encodeBlockHC = bindings.compressHC;
        __exports__.lz4 = module.exports;
      },
      {
        "./decoder": 2,
        "./decoder_stream": 3,
        "./encoder": 4,
        "./encoder_stream": 5,
        "./static": 6,
      },
    ],
  },
  {},
  ["lz4"],
);

// hack to unpackage the packaging above...
for (const k in __exports__.lz4) {
  exports[k] = __exports__.lz4[k];
}