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","file":"static/js/6.f290e411.chunk.js","sourcesContent":["'use strict';\n\nvar utils = require('./utils');\nvar assert = require('minimalistic-assert');\n\nfunction BlockHash() {\n  this.pending = null;\n  this.pendingTotal = 0;\n  this.blockSize = this.constructor.blockSize;\n  this.outSize = this.constructor.outSize;\n  this.hmacStrength = this.constructor.hmacStrength;\n  this.padLength = this.constructor.padLength / 8;\n  this.endian = 'big';\n\n  this._delta8 = this.blockSize / 8;\n  this._delta32 = this.blockSize / 32;\n}\nexports.BlockHash = BlockHash;\n\nBlockHash.prototype.update = function update(msg, enc) {\n  // Convert message to array, pad it, and join into 32bit blocks\n  msg = utils.toArray(msg, enc);\n  if (!this.pending)\n    this.pending = msg;\n  else\n    this.pending = this.pending.concat(msg);\n  this.pendingTotal += msg.length;\n\n  // Enough data, try updating\n  if (this.pending.length >= this._delta8) {\n    msg = this.pending;\n\n    // Process pending data in blocks\n    var r = msg.length % this._delta8;\n    this.pending = msg.slice(msg.length - r, msg.length);\n    if (this.pending.length === 0)\n      this.pending = null;\n\n    msg = utils.join32(msg, 0, msg.length - r, this.endian);\n    for (var i = 0; i < msg.length; i += this._delta32)\n      this._update(msg, i, i + this._delta32);\n  }\n\n  return this;\n};\n\nBlockHash.prototype.digest = function digest(enc) {\n  this.update(this._pad());\n  assert(this.pending === null);\n\n  return this._digest(enc);\n};\n\nBlockHash.prototype._pad = function pad() {\n  var len = this.pendingTotal;\n  var bytes = this._delta8;\n  var k = bytes - ((len + this.padLength) % bytes);\n  var res = new Array(k + this.padLength);\n  res[0] = 0x80;\n  for (var i = 1; i < k; i++)\n    res[i] = 0;\n\n  // Append length\n  len <<= 3;\n  if (this.endian === 'big') {\n    for (var t = 8; t < this.padLength; t++)\n      res[i++] = 0;\n\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = (len >>> 24) & 0xff;\n    res[i++] = (len >>> 16) & 0xff;\n    res[i++] = (len >>> 8) & 0xff;\n    res[i++] = len & 0xff;\n  } else {\n    res[i++] = len & 0xff;\n    res[i++] = (len >>> 8) & 0xff;\n    res[i++] = (len >>> 16) & 0xff;\n    res[i++] = (len >>> 24) & 0xff;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n    res[i++] = 0;\n\n    for (t = 8; t < this.padLength; t++)\n      res[i++] = 0;\n  }\n\n  return res;\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.baToJSON = exports.addHexPrefix = exports.toUnsigned = exports.fromSigned = exports.bufferToHex = exports.bufferToInt = exports.toBuffer = exports.stripZeros = exports.unpad = exports.setLengthRight = exports.setLength = exports.setLengthLeft = exports.zeros = void 0;\nvar ethjsUtil = require('ethjs-util');\nvar BN = require(\"bn.js\");\n/**\n * Returns a buffer filled with 0s.\n * @param bytes the number of bytes the buffer should be\n */\nexports.zeros = function (bytes) {\n    return Buffer.allocUnsafe(bytes).fill(0);\n};\n/**\n * Left Pads an `Array` or `Buffer` with leading zeros till it has `length` bytes.\n * Or it truncates the beginning if it exceeds.\n * @param msg the value to pad (Buffer|Array)\n * @param length the number of bytes the output should be\n * @param right whether to start padding form the left or right\n * @return (Buffer|Array)\n */\nexports.setLengthLeft = function (msg, length, right) {\n    if (right === void 0) { right = false; }\n    var buf = exports.zeros(length);\n    msg = exports.toBuffer(msg);\n    if (right) {\n        if (msg.length < length) {\n            msg.copy(buf);\n            return buf;\n        }\n        return msg.slice(0, length);\n    }\n    else {\n        if (msg.length < length) {\n            msg.copy(buf, length - msg.length);\n            return buf;\n        }\n        return msg.slice(-length);\n    }\n};\nexports.setLength = exports.setLengthLeft;\n/**\n * Right Pads an `Array` or `Buffer` with leading zeros till it has `length` bytes.\n * Or it truncates the beginning if it exceeds.\n * @param msg the value to pad (Buffer|Array)\n * @param length the number of bytes the output should be\n * @return (Buffer|Array)\n */\nexports.setLengthRight = function (msg, length) {\n    return exports.setLength(msg, length, true);\n};\n/**\n * Trims leading zeros from a `Buffer` or an `Array`.\n * @param a (Buffer|Array|String)\n * @return (Buffer|Array|String)\n */\nexports.unpad = function (a) {\n    a = ethjsUtil.stripHexPrefix(a);\n    var first = a[0];\n    while (a.length > 0 && first.toString() === '0') {\n        a = a.slice(1);\n        first = a[0];\n    }\n    return a;\n};\nexports.stripZeros = exports.unpad;\n/**\n * Attempts to turn a value into a `Buffer`. As input it supports `Buffer`, `String`, `Number`, null/undefined, `BN` and other objects with a `toArray()` method.\n * @param v the value\n */\nexports.toBuffer = function (v) {\n    if (!Buffer.isBuffer(v)) {\n        if (Array.isArray(v)) {\n            v = Buffer.from(v);\n        }\n        else if (typeof v === 'string') {\n            if (ethjsUtil.isHexString(v)) {\n                v = Buffer.from(ethjsUtil.padToEven(ethjsUtil.stripHexPrefix(v)), 'hex');\n            }\n            else {\n                throw new Error(\"Cannot convert string to buffer. toBuffer only supports 0x-prefixed hex strings and this string was given: \" + v);\n            }\n        }\n        else if (typeof v === 'number') {\n            v = ethjsUtil.intToBuffer(v);\n        }\n        else if (v === null || v === undefined) {\n            v = Buffer.allocUnsafe(0);\n        }\n        else if (BN.isBN(v)) {\n            v = v.toArrayLike(Buffer);\n        }\n        else if (v.toArray) {\n            // converts a BN to a Buffer\n            v = Buffer.from(v.toArray());\n        }\n        else {\n            throw new Error('invalid type');\n        }\n    }\n    return v;\n};\n/**\n * Converts a `Buffer` to a `Number`.\n * @param buf `Buffer` object to convert\n * @throws If the input number exceeds 53 bits.\n */\nexports.bufferToInt = function (buf) {\n    return new BN(exports.toBuffer(buf)).toNumber();\n};\n/**\n * Converts a `Buffer` into a `0x`-prefixed hex `String`.\n * @param buf `Buffer` object to convert\n */\nexports.bufferToHex = function (buf) {\n    buf = exports.toBuffer(buf);\n    return '0x' + buf.toString('hex');\n};\n/**\n * Interprets a `Buffer` as a signed integer and returns a `BN`. Assumes 256-bit numbers.\n * @param num Signed integer value\n */\nexports.fromSigned = function (num) {\n    return new BN(num).fromTwos(256);\n};\n/**\n * Converts a `BN` to an unsigned integer and returns it as a `Buffer`. Assumes 256-bit numbers.\n * @param num\n */\nexports.toUnsigned = function (num) {\n    return Buffer.from(num.toTwos(256).toArray());\n};\n/**\n * Adds \"0x\" to a given `String` if it does not already start with \"0x\".\n */\nexports.addHexPrefix = function (str) {\n    if (typeof str !== 'string') {\n        return str;\n    }\n    return ethjsUtil.isHexPrefixed(str) ? str : '0x' + str;\n};\n/**\n * Converts a `Buffer` or `Array` to JSON.\n * @param ba (Buffer|Array)\n * @return (Array|String|null)\n */\nexports.baToJSON = function (ba) {\n    if (Buffer.isBuffer(ba)) {\n        return \"0x\" + ba.toString('hex');\n    }\n    else if (ba instanceof Array) {\n        var array = [];\n        for (var i = 0; i < ba.length; i++) {\n            array.push(exports.baToJSON(ba[i]));\n        }\n        return array;\n    }\n};\n//# sourceMappingURL=bytes.js.map","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\nvar R = typeof Reflect === 'object' ? Reflect : null\nvar ReflectApply = R && typeof R.apply === 'function'\n  ? R.apply\n  : function ReflectApply(target, receiver, args) {\n    return Function.prototype.apply.call(target, receiver, args);\n  }\n\nvar ReflectOwnKeys\nif (R && typeof R.ownKeys === 'function') {\n  ReflectOwnKeys = R.ownKeys\n} else if (Object.getOwnPropertySymbols) {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target)\n      .concat(Object.getOwnPropertySymbols(target));\n  };\n} else {\n  ReflectOwnKeys = function ReflectOwnKeys(target) {\n    return Object.getOwnPropertyNames(target);\n  };\n}\n\nfunction ProcessEmitWarning(warning) {\n  if (console && console.warn) console.warn(warning);\n}\n\nvar NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {\n  return value !== value;\n}\n\nfunction EventEmitter() {\n  EventEmitter.init.call(this);\n}\nmodule.exports = EventEmitter;\nmodule.exports.once = once;\n\n// Backwards-compat with node 0.10.x\nEventEmitter.EventEmitter = EventEmitter;\n\nEventEmitter.prototype._events = undefined;\nEventEmitter.prototype._eventsCount = 0;\nEventEmitter.prototype._maxListeners = undefined;\n\n// By default EventEmitters will print a warning if more than 10 listeners are\n// added to it. This is a useful default which helps finding memory leaks.\nvar defaultMaxListeners = 10;\n\nfunction checkListener(listener) {\n  if (typeof listener !== 'function') {\n    throw new TypeError('The \"listener\" argument must be of type Function. Received type ' + typeof listener);\n  }\n}\n\nObject.defineProperty(EventEmitter, 'defaultMaxListeners', {\n  enumerable: true,\n  get: function() {\n    return defaultMaxListeners;\n  },\n  set: function(arg) {\n    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {\n      throw new RangeError('The value of \"defaultMaxListeners\" is out of range. It must be a non-negative number. Received ' + arg + '.');\n    }\n    defaultMaxListeners = arg;\n  }\n});\n\nEventEmitter.init = function() {\n\n  if (this._events === undefined ||\n      this._events === Object.getPrototypeOf(this)._events) {\n    this._events = Object.create(null);\n    this._eventsCount = 0;\n  }\n\n  this._maxListeners = this._maxListeners || undefined;\n};\n\n// Obviously not all Emitters should be limited to 10. This function allows\n// that to be increased. Set to zero for unlimited.\nEventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {\n  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {\n    throw new RangeError('The value of \"n\" is out of range. It must be a non-negative number. Received ' + n + '.');\n  }\n  this._maxListeners = n;\n  return this;\n};\n\nfunction _getMaxListeners(that) {\n  if (that._maxListeners === undefined)\n    return EventEmitter.defaultMaxListeners;\n  return that._maxListeners;\n}\n\nEventEmitter.prototype.getMaxListeners = function getMaxListeners() {\n  return _getMaxListeners(this);\n};\n\nEventEmitter.prototype.emit = function emit(type) {\n  var args = [];\n  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);\n  var doError = (type === 'error');\n\n  var events = this._events;\n  if (events !== undefined)\n    doError = (doError && events.error === undefined);\n  else if (!doError)\n    return false;\n\n  // If there is no 'error' event listener then throw.\n  if (doError) {\n    var er;\n    if (args.length > 0)\n      er = args[0];\n    if (er instanceof Error) {\n      // Note: The comments on the `throw` lines are intentional, they show\n      // up in Node's output if this results in an unhandled exception.\n      throw er; // Unhandled 'error' event\n    }\n    // At least give some kind of context to the user\n    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));\n    err.context = er;\n    throw err; // Unhandled 'error' event\n  }\n\n  var handler = events[type];\n\n  if (handler === undefined)\n    return false;\n\n  if (typeof handler === 'function') {\n    ReflectApply(handler, this, args);\n  } else {\n    var len = handler.length;\n    var listeners = arrayClone(handler, len);\n    for (var i = 0; i < len; ++i)\n      ReflectApply(listeners[i], this, args);\n  }\n\n  return true;\n};\n\nfunction _addListener(target, type, listener, prepend) {\n  var m;\n  var events;\n  var existing;\n\n  checkListener(listener);\n\n  events = target._events;\n  if (events === undefined) {\n    events = target._events = Object.create(null);\n    target._eventsCount = 0;\n  } else {\n    // To avoid recursion in the case that type === \"newListener\"! Before\n    // adding it to the listeners, first emit \"newListener\".\n    if (events.newListener !== undefined) {\n      target.emit('newListener', type,\n                  listener.listener ? listener.listener : listener);\n\n      // Re-assign `events` because a newListener handler could have caused the\n      // this._events to be assigned to a new object\n      events = target._events;\n    }\n    existing = events[type];\n  }\n\n  if (existing === undefined) {\n    // Optimize the case of one listener. Don't need the extra array object.\n    existing = events[type] = listener;\n    ++target._eventsCount;\n  } else {\n    if (typeof existing === 'function') {\n      // Adding the second element, need to change to array.\n      existing = events[type] =\n        prepend ? [listener, existing] : [existing, listener];\n      // If we've already got an array, just append.\n    } else if (prepend) {\n      existing.unshift(listener);\n    } else {\n      existing.push(listener);\n    }\n\n    // Check for listener leak\n    m = _getMaxListeners(target);\n    if (m > 0 && existing.length > m && !existing.warned) {\n      existing.warned = true;\n      // No error code for this since it is a Warning\n      // eslint-disable-next-line no-restricted-syntax\n      var w = new Error('Possible EventEmitter memory leak detected. ' +\n                          existing.length + ' ' + String(type) + ' listeners ' +\n                          'added. Use emitter.setMaxListeners() to ' +\n                          'increase limit');\n      w.name = 'MaxListenersExceededWarning';\n      w.emitter = target;\n      w.type = type;\n      w.count = existing.length;\n      ProcessEmitWarning(w);\n    }\n  }\n\n  return target;\n}\n\nEventEmitter.prototype.addListener = function addListener(type, listener) {\n  return _addListener(this, type, listener, false);\n};\n\nEventEmitter.prototype.on = EventEmitter.prototype.addListener;\n\nEventEmitter.prototype.prependListener =\n    function prependListener(type, listener) {\n      return _addListener(this, type, listener, true);\n    };\n\nfunction onceWrapper() {\n  if (!this.fired) {\n    this.target.removeListener(this.type, this.wrapFn);\n    this.fired = true;\n    if (arguments.length === 0)\n      return this.listener.call(this.target);\n    return this.listener.apply(this.target, arguments);\n  }\n}\n\nfunction _onceWrap(target, type, listener) {\n  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };\n  var wrapped = onceWrapper.bind(state);\n  wrapped.listener = listener;\n  state.wrapFn = wrapped;\n  return wrapped;\n}\n\nEventEmitter.prototype.once = function once(type, listener) {\n  checkListener(listener);\n  this.on(type, _onceWrap(this, type, listener));\n  return this;\n};\n\nEventEmitter.prototype.prependOnceListener =\n    function prependOnceListener(type, listener) {\n      checkListener(listener);\n      this.prependListener(type, _onceWrap(this, type, listener));\n      return this;\n    };\n\n// Emits a 'removeListener' event if and only if the listener was removed.\nEventEmitter.prototype.removeListener =\n    function removeListener(type, listener) {\n      var list, events, position, i, originalListener;\n\n      checkListener(listener);\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      list = events[type];\n      if (list === undefined)\n        return this;\n\n      if (list === listener || list.listener === listener) {\n        if (--this._eventsCount === 0)\n          this._events = Object.create(null);\n        else {\n          delete events[type];\n          if (events.removeListener)\n            this.emit('removeListener', type, list.listener || listener);\n        }\n      } else if (typeof list !== 'function') {\n        position = -1;\n\n        for (i = list.length - 1; i >= 0; i--) {\n          if (list[i] === listener || list[i].listener === listener) {\n            originalListener = list[i].listener;\n            position = i;\n            break;\n          }\n        }\n\n        if (position < 0)\n          return this;\n\n        if (position === 0)\n          list.shift();\n        else {\n          spliceOne(list, position);\n        }\n\n        if (list.length === 1)\n          events[type] = list[0];\n\n        if (events.removeListener !== undefined)\n          this.emit('removeListener', type, originalListener || listener);\n      }\n\n      return this;\n    };\n\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\n\nEventEmitter.prototype.removeAllListeners =\n    function removeAllListeners(type) {\n      var listeners, events, i;\n\n      events = this._events;\n      if (events === undefined)\n        return this;\n\n      // not listening for removeListener, no need to emit\n      if (events.removeListener === undefined) {\n        if (arguments.length === 0) {\n          this._events = Object.create(null);\n          this._eventsCount = 0;\n        } else if (events[type] !== undefined) {\n          if (--this._eventsCount === 0)\n            this._events = Object.create(null);\n          else\n            delete events[type];\n        }\n        return this;\n      }\n\n      // emit removeListener for all listeners on all events\n      if (arguments.length === 0) {\n        var keys = Object.keys(events);\n        var key;\n        for (i = 0; i < keys.length; ++i) {\n          key = keys[i];\n          if (key === 'removeListener') continue;\n          this.removeAllListeners(key);\n        }\n        this.removeAllListeners('removeListener');\n        this._events = Object.create(null);\n        this._eventsCount = 0;\n        return this;\n      }\n\n      listeners = events[type];\n\n      if (typeof listeners === 'function') {\n        this.removeListener(type, listeners);\n      } else if (listeners !== undefined) {\n        // LIFO order\n        for (i = listeners.length - 1; i >= 0; i--) {\n          this.removeListener(type, listeners[i]);\n        }\n      }\n\n      return this;\n    };\n\nfunction _listeners(target, type, unwrap) {\n  var events = target._events;\n\n  if (events === undefined)\n    return [];\n\n  var evlistener = events[type];\n  if (evlistener === undefined)\n    return [];\n\n  if (typeof evlistener === 'function')\n    return unwrap ? [evlistener.listener || evlistener] : [evlistener];\n\n  return unwrap ?\n    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);\n}\n\nEventEmitter.prototype.listeners = function listeners(type) {\n  return _listeners(this, type, true);\n};\n\nEventEmitter.prototype.rawListeners = function rawListeners(type) {\n  return _listeners(this, type, false);\n};\n\nEventEmitter.listenerCount = function(emitter, type) {\n  if (typeof emitter.listenerCount === 'function') {\n    return emitter.listenerCount(type);\n  } else {\n    return listenerCount.call(emitter, type);\n  }\n};\n\nEventEmitter.prototype.listenerCount = listenerCount;\nfunction listenerCount(type) {\n  var events = this._events;\n\n  if (events !== undefined) {\n    var evlistener = events[type];\n\n    if (typeof evlistener === 'function') {\n      return 1;\n    } else if (evlistener !== undefined) {\n      return evlistener.length;\n    }\n  }\n\n  return 0;\n}\n\nEventEmitter.prototype.eventNames = function eventNames() {\n  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];\n};\n\nfunction arrayClone(arr, n) {\n  var copy = new Array(n);\n  for (var i = 0; i < n; ++i)\n    copy[i] = arr[i];\n  return copy;\n}\n\nfunction spliceOne(list, index) {\n  for (; index + 1 < list.length; index++)\n    list[index] = list[index + 1];\n  list.pop();\n}\n\nfunction unwrapListeners(arr) {\n  var ret = new Array(arr.length);\n  for (var i = 0; i < ret.length; ++i) {\n    ret[i] = arr[i].listener || arr[i];\n  }\n  return ret;\n}\n\nfunction once(emitter, name) {\n  return new Promise(function (resolve, reject) {\n    function eventListener() {\n      if (errorListener !== undefined) {\n        emitter.removeListener('error', errorListener);\n      }\n      resolve([].slice.call(arguments));\n    };\n    var errorListener;\n\n    // Adding an error listener is not optional because\n    // if an error is thrown on an event emitter we cannot\n    // guarantee that the actual event we are waiting will\n    // be fired. The result could be a silent way to create\n    // memory or file descriptor leaks, which is something\n    // we should avoid.\n    if (name !== 'error') {\n      errorListener = function errorListener(err) {\n        emitter.removeListener(name, eventListener);\n        reject(err);\n      };\n\n      emitter.once('error', errorListener);\n    }\n\n    emitter.once(name, eventListener);\n  });\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// NOTE: These type checking functions intentionally don't use `instanceof`\n// because it is fragile and can be easily faked with `Object.create()`.\n\nfunction isArray(arg) {\n  if (Array.isArray) {\n    return Array.isArray(arg);\n  }\n  return objectToString(arg) === '[object Array]';\n}\nexports.isArray = isArray;\n\nfunction isBoolean(arg) {\n  return typeof arg === 'boolean';\n}\nexports.isBoolean = isBoolean;\n\nfunction isNull(arg) {\n  return arg === null;\n}\nexports.isNull = isNull;\n\nfunction isNullOrUndefined(arg) {\n  return arg == null;\n}\nexports.isNullOrUndefined = isNullOrUndefined;\n\nfunction isNumber(arg) {\n  return typeof arg === 'number';\n}\nexports.isNumber = isNumber;\n\nfunction isString(arg) {\n  return typeof arg === 'string';\n}\nexports.isString = isString;\n\nfunction isSymbol(arg) {\n  return typeof arg === 'symbol';\n}\nexports.isSymbol = isSymbol;\n\nfunction isUndefined(arg) {\n  return arg === void 0;\n}\nexports.isUndefined = isUndefined;\n\nfunction isRegExp(re) {\n  return objectToString(re) === '[object RegExp]';\n}\nexports.isRegExp = isRegExp;\n\nfunction isObject(arg) {\n  return typeof arg === 'object' && arg !== null;\n}\nexports.isObject = isObject;\n\nfunction isDate(d) {\n  return objectToString(d) === '[object Date]';\n}\nexports.isDate = isDate;\n\nfunction isError(e) {\n  return (objectToString(e) === '[object Error]' || e instanceof Error);\n}\nexports.isError = isError;\n\nfunction isFunction(arg) {\n  return typeof arg === 'function';\n}\nexports.isFunction = isFunction;\n\nfunction isPrimitive(arg) {\n  return arg === null ||\n         typeof arg === 'boolean' ||\n         typeof arg === 'number' ||\n         typeof arg === 'string' ||\n         typeof arg === 'symbol' ||  // ES6 symbol\n         typeof arg === 'undefined';\n}\nexports.isPrimitive = isPrimitive;\n\nexports.isBuffer = Buffer.isBuffer;\n\nfunction objectToString(o) {\n  return Object.prototype.toString.call(o);\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n'use strict';\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\n/*</replacement>*/\n\nvar isEncoding = Buffer.isEncoding || function (encoding) {\n  encoding = '' + encoding;\n  switch (encoding && encoding.toLowerCase()) {\n    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':\n      return true;\n    default:\n      return false;\n  }\n};\n\nfunction _normalizeEncoding(enc) {\n  if (!enc) return 'utf8';\n  var retried;\n  while (true) {\n    switch (enc) {\n      case 'utf8':\n      case 'utf-8':\n        return 'utf8';\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return 'utf16le';\n      case 'latin1':\n      case 'binary':\n        return 'latin1';\n      case 'base64':\n      case 'ascii':\n      case 'hex':\n        return enc;\n      default:\n        if (retried) return; // undefined\n        enc = ('' + enc).toLowerCase();\n        retried = true;\n    }\n  }\n};\n\n// Do not cache `Buffer.isEncoding` when checking encoding names as some\n// modules monkey-patch it to support additional encodings\nfunction normalizeEncoding(enc) {\n  var nenc = _normalizeEncoding(enc);\n  if (typeof nenc !== 'string' && (Buffer.isEncoding === isEncoding || !isEncoding(enc))) throw new Error('Unknown encoding: ' + enc);\n  return nenc || enc;\n}\n\n// StringDecoder provides an interface for efficiently splitting a series of\n// buffers into a series of JS strings without breaking apart multi-byte\n// characters.\nexports.StringDecoder = StringDecoder;\nfunction StringDecoder(encoding) {\n  this.encoding = normalizeEncoding(encoding);\n  var nb;\n  switch (this.encoding) {\n    case 'utf16le':\n      this.text = utf16Text;\n      this.end = utf16End;\n      nb = 4;\n      break;\n    case 'utf8':\n      this.fillLast = utf8FillLast;\n      nb = 4;\n      break;\n    case 'base64':\n      this.text = base64Text;\n      this.end = base64End;\n      nb = 3;\n      break;\n    default:\n      this.write = simpleWrite;\n      this.end = simpleEnd;\n      return;\n  }\n  this.lastNeed = 0;\n  this.lastTotal = 0;\n  this.lastChar = Buffer.allocUnsafe(nb);\n}\n\nStringDecoder.prototype.write = function (buf) {\n  if (buf.length === 0) return '';\n  var r;\n  var i;\n  if (this.lastNeed) {\n    r = this.fillLast(buf);\n    if (r === undefined) return '';\n    i = this.lastNeed;\n    this.lastNeed = 0;\n  } else {\n    i = 0;\n  }\n  if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);\n  return r || '';\n};\n\nStringDecoder.prototype.end = utf8End;\n\n// Returns only complete characters in a Buffer\nStringDecoder.prototype.text = utf8Text;\n\n// Attempts to complete a partial non-UTF-8 character using bytes from a Buffer\nStringDecoder.prototype.fillLast = function (buf) {\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);\n  this.lastNeed -= buf.length;\n};\n\n// Checks the type of a UTF-8 byte, whether it's ASCII, a leading byte, or a\n// continuation byte. If an invalid byte is detected, -2 is returned.\nfunction utf8CheckByte(byte) {\n  if (byte <= 0x7F) return 0;else if (byte >> 5 === 0x06) return 2;else if (byte >> 4 === 0x0E) return 3;else if (byte >> 3 === 0x1E) return 4;\n  return byte >> 6 === 0x02 ? -1 : -2;\n}\n\n// Checks at most 3 bytes at the end of a Buffer in order to detect an\n// incomplete multi-byte UTF-8 character. The total number of bytes (2, 3, or 4)\n// needed to complete the UTF-8 character (if applicable) are returned.\nfunction utf8CheckIncomplete(self, buf, i) {\n  var j = buf.length - 1;\n  if (j < i) return 0;\n  var nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 1;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) self.lastNeed = nb - 2;\n    return nb;\n  }\n  if (--j < i || nb === -2) return 0;\n  nb = utf8CheckByte(buf[j]);\n  if (nb >= 0) {\n    if (nb > 0) {\n      if (nb === 2) nb = 0;else self.lastNeed = nb - 3;\n    }\n    return nb;\n  }\n  return 0;\n}\n\n// Validates as many continuation bytes for a multi-byte UTF-8 character as\n// needed or are available. If we see a non-continuation byte where we expect\n// one, we \"replace\" the validated continuation bytes we've seen so far with\n// a single UTF-8 replacement character ('\\ufffd'), to match v8's UTF-8 decoding\n// behavior. The continuation byte check is included three times in the case\n// where all of the continuation bytes for a character exist in the same buffer.\n// It is also done this way as a slight performance increase instead of using a\n// loop.\nfunction utf8CheckExtraBytes(self, buf, p) {\n  if ((buf[0] & 0xC0) !== 0x80) {\n    self.lastNeed = 0;\n    return '\\ufffd';\n  }\n  if (self.lastNeed > 1 && buf.length > 1) {\n    if ((buf[1] & 0xC0) !== 0x80) {\n      self.lastNeed = 1;\n      return '\\ufffd';\n    }\n    if (self.lastNeed > 2 && buf.length > 2) {\n      if ((buf[2] & 0xC0) !== 0x80) {\n        self.lastNeed = 2;\n        return '\\ufffd';\n      }\n    }\n  }\n}\n\n// Attempts to complete a multi-byte UTF-8 character using bytes from a Buffer.\nfunction utf8FillLast(buf) {\n  var p = this.lastTotal - this.lastNeed;\n  var r = utf8CheckExtraBytes(this, buf, p);\n  if (r !== undefined) return r;\n  if (this.lastNeed <= buf.length) {\n    buf.copy(this.lastChar, p, 0, this.lastNeed);\n    return this.lastChar.toString(this.encoding, 0, this.lastTotal);\n  }\n  buf.copy(this.lastChar, p, 0, buf.length);\n  this.lastNeed -= buf.length;\n}\n\n// Returns all complete UTF-8 characters in a Buffer. If the Buffer ended on a\n// partial character, the character's bytes are buffered until the required\n// number of bytes are available.\nfunction utf8Text(buf, i) {\n  var total = utf8CheckIncomplete(this, buf, i);\n  if (!this.lastNeed) return buf.toString('utf8', i);\n  this.lastTotal = total;\n  var end = buf.length - (total - this.lastNeed);\n  buf.copy(this.lastChar, 0, end);\n  return buf.toString('utf8', i, end);\n}\n\n// For UTF-8, a replacement character is added when ending on a partial\n// character.\nfunction utf8End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + '\\ufffd';\n  return r;\n}\n\n// UTF-16LE typically needs two bytes per character, but even if we have an even\n// number of bytes available, we need to check if we end on a leading/high\n// surrogate. In that case, we need to wait for the next two bytes in order to\n// decode the last character properly.\nfunction utf16Text(buf, i) {\n  if ((buf.length - i) % 2 === 0) {\n    var r = buf.toString('utf16le', i);\n    if (r) {\n      var c = r.charCodeAt(r.length - 1);\n      if (c >= 0xD800 && c <= 0xDBFF) {\n        this.lastNeed = 2;\n        this.lastTotal = 4;\n        this.lastChar[0] = buf[buf.length - 2];\n        this.lastChar[1] = buf[buf.length - 1];\n        return r.slice(0, -1);\n      }\n    }\n    return r;\n  }\n  this.lastNeed = 1;\n  this.lastTotal = 2;\n  this.lastChar[0] = buf[buf.length - 1];\n  return buf.toString('utf16le', i, buf.length - 1);\n}\n\n// For UTF-16LE we do not explicitly append special replacement characters if we\n// end on a partial character, we simply let v8 handle that.\nfunction utf16End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) {\n    var end = this.lastTotal - this.lastNeed;\n    return r + this.lastChar.toString('utf16le', 0, end);\n  }\n  return r;\n}\n\nfunction base64Text(buf, i) {\n  var n = (buf.length - i) % 3;\n  if (n === 0) return buf.toString('base64', i);\n  this.lastNeed = 3 - n;\n  this.lastTotal = 3;\n  if (n === 1) {\n    this.lastChar[0] = buf[buf.length - 1];\n  } else {\n    this.lastChar[0] = buf[buf.length - 2];\n    this.lastChar[1] = buf[buf.length - 1];\n  }\n  return buf.toString('base64', i, buf.length - n);\n}\n\nfunction base64End(buf) {\n  var r = buf && buf.length ? this.write(buf) : '';\n  if (this.lastNeed) return r + this.lastChar.toString('base64', 0, 3 - this.lastNeed);\n  return r;\n}\n\n// Pass bytes on through for single-byte encodings (e.g. ascii, latin1, hex)\nfunction simpleWrite(buf) {\n  return buf.toString(this.encoding);\n}\n\nfunction simpleEnd(buf) {\n  return buf && buf.length ? this.write(buf) : '';\n}","'use strict'\nconst CID = require('cids')\nconst multicodec = require('multicodec')\nconst createUtil = require('../util/createUtil')\n\nconst createResolver = (codec, deserialize) => {\n  const util = createUtil(codec, deserialize)\n\n  /**\n   * Resolves a path within a Ethereum block.\n   *\n   * Returns the value or a link and the partial mising path. This way the\n   * IPLD Resolver can fetch the link and continue to resolve.\n   *\n   * @param {Uint8Array} binaryBlob - Binary representation of a Ethereum block\n   * @param {string} [path='/'] - Path that should be resolved\n   * @returns {Object} result - Result of the path it it was resolved successfully\n   * @returns {*} result.value - Value the path resolves to\n   * @returns {string} result.remainderPath - If the path resolves half-way to a\n   *   link, then the `remainderPath` is the part after the link that can be used\n   *   for further resolving\n   */\n  const resolve = (binaryBlob, path) => {\n    let node = util.deserialize(binaryBlob)\n\n    const parts = path.split('/').filter((x) => x)\n    while (parts.length) {\n      const key = parts.shift()\n      if (node[key] === undefined) {\n        throw new Error(`Object has no property '${key}'`)\n      }\n\n      node = node[key]\n      if (CID.isCID(node)) {\n        return {\n          value: node,\n          remainderPath: parts.join('/')\n        }\n      }\n    }\n\n    return {\n      value: node,\n      remainderPath: ''\n    }\n  }\n\n  const _traverse = function * (node, path) {\n    // Traverse only objects and arrays\n    if (node instanceof Uint8Array || CID.isCID(node) || typeof node === 'string' ||\n        node === null) {\n      return\n    }\n    for (const item of Object.keys(node)) {\n      const nextpath = path === undefined ? item : path + '/' + item\n      yield nextpath\n      yield * _traverse(node[item], nextpath)\n    }\n  }\n\n  /**\n   * Return all available paths of a block.\n   *\n   * @generator\n   * @param {Uint8Array} binaryBlob - Binary representation of a Bitcoin block\n   * @yields {string} - A single path\n   */\n  const tree = function * (binaryBlob) {\n    const node = util.deserialize(binaryBlob)\n\n    yield * _traverse(node)\n  }\n\n  return {\n    codec: codec,\n    defaultHashAlg: multicodec.KECCAK_256,\n    resolver: {\n      resolve: resolve,\n      tree: tree,\n    },\n    util: util,\n  }\n}\n\nmodule.exports = createResolver\n","'use strict'\n\nconst multihash = require('multihashing-async').multihash\nconst CID = require('cids')\nconst strftime = require('strftime')\nconst { Buffer } = require('buffer')\n\nconst SHA1_LENGTH = 20\n\nfunction find (buf, byte) {\n  for (let i = 0; i < buf.length; i++) {\n    if (buf[i] === byte) {\n      return i\n    }\n  }\n  return -1\n}\n\nconst ISO_8601_STRICT = '%FT%T%:z'\nconst TIMESTAMP_WITH_OFFSET = '%s %z'\n\nconst timestampWithOffsetToISOStrict = (timestamp, offset) => strftime.timezone(offset)(ISO_8601_STRICT, new Date(timestamp * 1000))\n\nconst isoStrictToTimestampWithOffset = (isoString) => {\n  const matched = isoString.match(/([+-]\\d{2}:\\d{2})/)\n  const offset = matched === null ? '+0000' : (matched[0].slice(0, 3) + matched[0].slice(4))\n  return strftime.timezone(offset)(TIMESTAMP_WITH_OFFSET, new Date(isoString))\n}\n\nfunction parsePersonLine (line) {\n  const matched = line.match(/^(([^<]+)\\s)?\\s?<([^>]+)>\\s?(?:(\\d+)\\s([+-]\\d+))?$/)\n  if (matched === null) {\n    return null\n  }\n\n  return {\n    name: matched[2],\n    email: matched[3],\n    date: matched[4] && matched[5] && timestampWithOffsetToISOStrict(parseInt(matched[4]), matched[5])\n  }\n}\n\nfunction serializePersonLine (node) {\n  const parts = []\n  if (node.name) {\n    parts.push(node.name)\n  }\n  parts.push('<' + node.email + '>')\n  if (node.date) {\n    parts.push(isoStrictToTimestampWithOffset(node.date))\n  }\n\n  return parts.join(' ')\n}\n\nfunction shaToCid (buf) {\n  const mh = multihash.encode(buf, 'sha1')\n  return new CID(1, 'git-raw', mh)\n}\n\nfunction cidToSha (cid) {\n  const mh = multihash.decode(cid.multihash)\n  if (mh.name !== 'sha1') {\n    return null\n  }\n\n  return Buffer.from(mh.digest.buffer, mh.digest.byteOffset, mh.digest.byteLength)\n}\n\nmodule.exports = {\n  SHA1_LENGTH,\n  find,\n  parsePersonLine,\n  serializePersonLine,\n  shaToCid,\n  cidToSha\n}\n","'use strict';\n\nvar elliptic = exports;\n\nelliptic.version = require('../package.json').version;\nelliptic.utils = require('./elliptic/utils');\nelliptic.rand = require('brorand');\nelliptic.curve = require('./elliptic/curve');\nelliptic.curves = require('./elliptic/curves');\n\n// Protocols\nelliptic.ec = require('./elliptic/ec');\nelliptic.eddsa = require('./elliptic/eddsa');\n","'use strict';\n\nvar BN = require('bn.js');\nvar utils = require('../utils');\nvar getNAF = utils.getNAF;\nvar getJSF = utils.getJSF;\nvar assert = utils.assert;\n\nfunction BaseCurve(type, conf) {\n  this.type = type;\n  this.p = new BN(conf.p, 16);\n\n  // Use Montgomery, when there is no fast reduction for the prime\n  this.red = conf.prime ? BN.red(conf.prime) : BN.mont(this.p);\n\n  // Useful for many curves\n  this.zero = new BN(0).toRed(this.red);\n  this.one = new BN(1).toRed(this.red);\n  this.two = new BN(2).toRed(this.red);\n\n  // Curve configuration, optional\n  this.n = conf.n && new BN(conf.n, 16);\n  this.g = conf.g && this.pointFromJSON(conf.g, conf.gRed);\n\n  // Temporary arrays\n  this._wnafT1 = new Array(4);\n  this._wnafT2 = new Array(4);\n  this._wnafT3 = new Array(4);\n  this._wnafT4 = new Array(4);\n\n  this._bitLength = this.n ? this.n.bitLength() : 0;\n\n  // Generalized Greg Maxwell's trick\n  var adjustCount = this.n && this.p.div(this.n);\n  if (!adjustCount || adjustCount.cmpn(100) > 0) {\n    this.redN = null;\n  } else {\n    this._maxwellTrick = true;\n    this.redN = this.n.toRed(this.red);\n  }\n}\nmodule.exports = BaseCurve;\n\nBaseCurve.prototype.point = function point() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype.validate = function validate() {\n  throw new Error('Not implemented');\n};\n\nBaseCurve.prototype._fixedNafMul = function _fixedNafMul(p, k) {\n  assert(p.precomputed);\n  var doubles = p._getDoubles();\n\n  var naf = getNAF(k, 1, this._bitLength);\n  var I = (1 << (doubles.step + 1)) - (doubles.step % 2 === 0 ? 2 : 1);\n  I /= 3;\n\n  // Translate into more windowed form\n  var repr = [];\n  var j;\n  var nafW;\n  for (j = 0; j < naf.length; j += doubles.step) {\n    nafW = 0;\n    for (var l = j + doubles.step - 1; l >= j; l--)\n      nafW = (nafW << 1) + naf[l];\n    repr.push(nafW);\n  }\n\n  var a = this.jpoint(null, null, null);\n  var b = this.jpoint(null, null, null);\n  for (var i = I; i > 0; i--) {\n    for (j = 0; j < repr.length; j++) {\n      nafW = repr[j];\n      if (nafW === i)\n        b = b.mixedAdd(doubles.points[j]);\n      else if (nafW === -i)\n        b = b.mixedAdd(doubles.points[j].neg());\n    }\n    a = a.add(b);\n  }\n  return a.toP();\n};\n\nBaseCurve.prototype._wnafMul = function _wnafMul(p, k) {\n  var w = 4;\n\n  // Precompute window\n  var nafPoints = p._getNAFPoints(w);\n  w = nafPoints.wnd;\n  var wnd = nafPoints.points;\n\n  // Get NAF form\n  var naf = getNAF(k, w, this._bitLength);\n\n  // Add `this`*(N+1) for every w-NAF index\n  var acc = this.jpoint(null, null, null);\n  for (var i = naf.length - 1; i >= 0; i--) {\n    // Count zeroes\n    for (var l = 0; i >= 0 && naf[i] === 0; i--)\n      l++;\n    if (i >= 0)\n      l++;\n    acc = acc.dblp(l);\n\n    if (i < 0)\n      break;\n    var z = naf[i];\n    assert(z !== 0);\n    if (p.type === 'affine') {\n      // J +- P\n      if (z > 0)\n        acc = acc.mixedAdd(wnd[(z - 1) >> 1]);\n      else\n        acc = acc.mixedAdd(wnd[(-z - 1) >> 1].neg());\n    } else {\n      // J +- J\n      if (z > 0)\n        acc = acc.add(wnd[(z - 1) >> 1]);\n      else\n        acc = acc.add(wnd[(-z - 1) >> 1].neg());\n    }\n  }\n  return p.type === 'affine' ? acc.toP() : acc;\n};\n\nBaseCurve.prototype._wnafMulAdd = function _wnafMulAdd(defW,\n  points,\n  coeffs,\n  len,\n  jacobianResult) {\n  var wndWidth = this._wnafT1;\n  var wnd = this._wnafT2;\n  var naf = this._wnafT3;\n\n  // Fill all arrays\n  var max = 0;\n  var i;\n  var j;\n  var p;\n  for (i = 0; i < len; i++) {\n    p = points[i];\n    var nafPoints = p._getNAFPoints(defW);\n    wndWidth[i] = nafPoints.wnd;\n    wnd[i] = nafPoints.points;\n  }\n\n  // Comb small window NAFs\n  for (i = len - 1; i >= 1; i -= 2) {\n    var a = i - 1;\n    var b = i;\n    if (wndWidth[a] !== 1 || wndWidth[b] !== 1) {\n      naf[a] = getNAF(coeffs[a], wndWidth[a], this._bitLength);\n      naf[b] = getNAF(coeffs[b], wndWidth[b], this._bitLength);\n      max = Math.max(naf[a].length, max);\n      max = Math.max(naf[b].length, max);\n      continue;\n    }\n\n    var comb = [\n      points[a], /* 1 */\n      null, /* 3 */\n      null, /* 5 */\n      points[b], /* 7 */\n    ];\n\n    // Try to avoid Projective points, if possible\n    if (points[a].y.cmp(points[b].y) === 0) {\n      comb[1] = points[a].add(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    } else if (points[a].y.cmp(points[b].y.redNeg()) === 0) {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].add(points[b].neg());\n    } else {\n      comb[1] = points[a].toJ().mixedAdd(points[b]);\n      comb[2] = points[a].toJ().mixedAdd(points[b].neg());\n    }\n\n    var index = [\n      -3, /* -1 -1 */\n      -1, /* -1 0 */\n      -5, /* -1 1 */\n      -7, /* 0 -1 */\n      0, /* 0 0 */\n      7, /* 0 1 */\n      5, /* 1 -1 */\n      1, /* 1 0 */\n      3,  /* 1 1 */\n    ];\n\n    var jsf = getJSF(coeffs[a], coeffs[b]);\n    max = Math.max(jsf[0].length, max);\n    naf[a] = new Array(max);\n    naf[b] = new Array(max);\n    for (j = 0; j < max; j++) {\n      var ja = jsf[0][j] | 0;\n      var jb = jsf[1][j] | 0;\n\n      naf[a][j] = index[(ja + 1) * 3 + (jb + 1)];\n      naf[b][j] = 0;\n      wnd[a] = comb;\n    }\n  }\n\n  var acc = this.jpoint(null, null, null);\n  var tmp = this._wnafT4;\n  for (i = max; i >= 0; i--) {\n    var k = 0;\n\n    while (i >= 0) {\n      var zero = true;\n      for (j = 0; j < len; j++) {\n        tmp[j] = naf[j][i] | 0;\n        if (tmp[j] !== 0)\n          zero = false;\n      }\n      if (!zero)\n        break;\n      k++;\n      i--;\n    }\n    if (i >= 0)\n      k++;\n    acc = acc.dblp(k);\n    if (i < 0)\n      break;\n\n    for (j = 0; j < len; j++) {\n      var z = tmp[j];\n      p;\n      if (z === 0)\n        continue;\n      else if (z > 0)\n        p = wnd[j][(z - 1) >> 1];\n      else if (z < 0)\n        p = wnd[j][(-z - 1) >> 1].neg();\n\n      if (p.type === 'affine')\n        acc = acc.mixedAdd(p);\n      else\n        acc = acc.add(p);\n    }\n  }\n  // Zeroify references\n  for (i = 0; i < len; i++)\n    wnd[i] = null;\n\n  if (jacobianResult)\n    return acc;\n  else\n    return acc.toP();\n};\n\nfunction BasePoint(curve, type) {\n  this.curve = curve;\n  this.type = type;\n  this.precomputed = null;\n}\nBaseCurve.BasePoint = BasePoint;\n\nBasePoint.prototype.eq = function eq(/*other*/) {\n  throw new Error('Not implemented');\n};\n\nBasePoint.prototype.validate = function validate() {\n  return this.curve.validate(this);\n};\n\nBaseCurve.prototype.decodePoint = function decodePoint(bytes, enc) {\n  bytes = utils.toArray(bytes, enc);\n\n  var len = this.p.byteLength();\n\n  // uncompressed, hybrid-odd, hybrid-even\n  if ((bytes[0] === 0x04 || bytes[0] === 0x06 || bytes[0] === 0x07) &&\n      bytes.length - 1 === 2 * len) {\n    if (bytes[0] === 0x06)\n      assert(bytes[bytes.length - 1] % 2 === 0);\n    else if (bytes[0] === 0x07)\n      assert(bytes[bytes.length - 1] % 2 === 1);\n\n    var res =  this.point(bytes.slice(1, 1 + len),\n      bytes.slice(1 + len, 1 + 2 * len));\n\n    return res;\n  } else if ((bytes[0] === 0x02 || bytes[0] === 0x03) &&\n              bytes.length - 1 === len) {\n    return this.pointFromX(bytes.slice(1, 1 + len), bytes[0] === 0x03);\n  }\n  throw new Error('Unknown point format');\n};\n\nBasePoint.prototype.encodeCompressed = function encodeCompressed(enc) {\n  return this.encode(enc, true);\n};\n\nBasePoint.prototype._encode = function _encode(compact) {\n  var len = this.curve.p.byteLength();\n  var x = this.getX().toArray('be', len);\n\n  if (compact)\n    return [ this.getY().isEven() ? 0x02 : 0x03 ].concat(x);\n\n  return [ 0x04 ].concat(x, this.getY().toArray('be', len));\n};\n\nBasePoint.prototype.encode = function encode(enc, compact) {\n  return utils.encode(this._encode(compact), enc);\n};\n\nBasePoint.prototype.precompute = function precompute(power) {\n  if (this.precomputed)\n    return this;\n\n  var precomputed = {\n    doubles: null,\n    naf: null,\n    beta: null,\n  };\n  precomputed.naf = this._getNAFPoints(8);\n  precomputed.doubles = this._getDoubles(4, power);\n  precomputed.beta = this._getBeta();\n  this.precomputed = precomputed;\n\n  return this;\n};\n\nBasePoint.prototype._hasDoubles = function _hasDoubles(k) {\n  if (!this.precomputed)\n    return false;\n\n  var doubles = this.precomputed.doubles;\n  if (!doubles)\n    return false;\n\n  return doubles.points.length >= Math.ceil((k.bitLength() + 1) / doubles.step);\n};\n\nBasePoint.prototype._getDoubles = function _getDoubles(step, power) {\n  if (this.precomputed && this.precomputed.doubles)\n    return this.precomputed.doubles;\n\n  var doubles = [ this ];\n  var acc = this;\n  for (var i = 0; i < power; i += step) {\n    for (var j = 0; j < step; j++)\n      acc = acc.dbl();\n    doubles.push(acc);\n  }\n  return {\n    step: step,\n    points: doubles,\n  };\n};\n\nBasePoint.prototype._getNAFPoints = function _getNAFPoints(wnd) {\n  if (this.precomputed && this.precomputed.naf)\n    return this.precomputed.naf;\n\n  var res = [ this ];\n  var max = (1 << wnd) - 1;\n  var dbl = max === 1 ? null : this.dbl();\n  for (var i = 1; i < max; i++)\n    res[i] = res[i - 1].add(dbl);\n  return {\n    wnd: wnd,\n    points: res,\n  };\n};\n\nBasePoint.prototype._getBeta = function _getBeta() {\n  return null;\n};\n\nBasePoint.prototype.dblp = function dblp(k) {\n  var r = this;\n  for (var i = 0; i < k; i++)\n    r = r.dbl();\n  return r;\n};\n","'use strict';\n\nvar objectAssign = require('object-assign');\n\n// compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js\n// original notice:\n\n/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\nfunction compare(a, b) {\n  if (a === b) {\n    return 0;\n  }\n\n  var x = a.length;\n  var y = b.length;\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i];\n      y = b[i];\n      break;\n    }\n  }\n\n  if (x < y) {\n    return -1;\n  }\n  if (y < x) {\n    return 1;\n  }\n  return 0;\n}\nfunction isBuffer(b) {\n  if (global.Buffer && typeof global.Buffer.isBuffer === 'function') {\n    return global.Buffer.isBuffer(b);\n  }\n  return !!(b != null && b._isBuffer);\n}\n\n// based on node assert, original notice:\n// NB: The URL to the CommonJS spec is kept just for tradition.\n//     node-assert has evolved a lot since then, both in API and behavior.\n\n// http://wiki.commonjs.org/wiki/Unit_Testing/1.0\n//\n// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!\n//\n// Originally from narwhal.js (http://narwhaljs.org)\n// Copyright (c) 2009 Thomas Robinson <280north.com>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the 'Software'), to\n// deal in the Software without restriction, including without limitation the\n// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n// sell copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN\n// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\n// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nvar util = require('util/');\nvar hasOwn = Object.prototype.hasOwnProperty;\nvar pSlice = Array.prototype.slice;\nvar functionsHaveNames = (function () {\n  return function foo() {}.name === 'foo';\n}());\nfunction pToString (obj) {\n  return Object.prototype.toString.call(obj);\n}\nfunction isView(arrbuf) {\n  if (isBuffer(arrbuf)) {\n    return false;\n  }\n  if (typeof global.ArrayBuffer !== 'function') {\n    return false;\n  }\n  if (typeof ArrayBuffer.isView === 'function') {\n    return ArrayBuffer.isView(arrbuf);\n  }\n  if (!arrbuf) {\n    return false;\n  }\n  if (arrbuf instanceof DataView) {\n    return true;\n  }\n  if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) {\n    return true;\n  }\n  return false;\n}\n// 1. The assert module provides functions that throw\n// AssertionError's when particular conditions are not met. The\n// assert module must conform to the following interface.\n\nvar assert = module.exports = ok;\n\n// 2. The AssertionError is defined in assert.\n// new assert.AssertionError({ message: message,\n//                             actual: actual,\n//                             expected: expected })\n\nvar regex = /\\s*function\\s+([^\\(\\s]*)\\s*/;\n// based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js\nfunction getName(func) {\n  if (!util.isFunction(func)) {\n    return;\n  }\n  if (functionsHaveNames) {\n    return func.name;\n  }\n  var str = func.toString();\n  var match = str.match(regex);\n  return match && match[1];\n}\nassert.AssertionError = function AssertionError(options) {\n  this.name = 'AssertionError';\n  this.actual = options.actual;\n  this.expected = options.expected;\n  this.operator = options.operator;\n  if (options.message) {\n    this.message = options.message;\n    this.generatedMessage = false;\n  } else {\n    this.message = getMessage(this);\n    this.generatedMessage = true;\n  }\n  var stackStartFunction = options.stackStartFunction || fail;\n  if (Error.captureStackTrace) {\n    Error.captureStackTrace(this, stackStartFunction);\n  } else {\n    // non v8 browsers so we can have a stacktrace\n    var err = new Error();\n    if (err.stack) {\n      var out = err.stack;\n\n      // try to strip useless frames\n      var fn_name = getName(stackStartFunction);\n      var idx = out.indexOf('\\n' + fn_name);\n      if (idx >= 0) {\n        // once we have located the function frame\n        // we need to strip out everything before it (and its line)\n        var next_line = out.indexOf('\\n', idx + 1);\n        out = out.substring(next_line + 1);\n      }\n\n      this.stack = out;\n    }\n  }\n};\n\n// assert.AssertionError instanceof Error\nutil.inherits(assert.AssertionError, Error);\n\nfunction truncate(s, n) {\n  if (typeof s === 'string') {\n    return s.length < n ? s : s.slice(0, n);\n  } else {\n    return s;\n  }\n}\nfunction inspect(something) {\n  if (functionsHaveNames || !util.isFunction(something)) {\n    return util.inspect(something);\n  }\n  var rawname = getName(something);\n  var name = rawname ? ': ' + rawname : '';\n  return '[Function' +  name + ']';\n}\nfunction getMessage(self) {\n  return truncate(inspect(self.actual), 128) + ' ' +\n         self.operator + ' ' +\n         truncate(inspect(self.expected), 128);\n}\n\n// At present only the three keys mentioned above are used and\n// understood by the spec. Implementations or sub modules can pass\n// other keys to the AssertionError's constructor - they will be\n// ignored.\n\n// 3. All of the following functions must throw an AssertionError\n// when a corresponding condition is not met, with a message that\n// may be undefined if not provided.  All assertion methods provide\n// both the actual and expected values to the assertion error for\n// display purposes.\n\nfunction fail(actual, expected, message, operator, stackStartFunction) {\n  throw new assert.AssertionError({\n    message: message,\n    actual: actual,\n    expected: expected,\n    operator: operator,\n    stackStartFunction: stackStartFunction\n  });\n}\n\n// EXTENSION! allows for well behaved errors defined elsewhere.\nassert.fail = fail;\n\n// 4. Pure assertion tests whether a value is truthy, as determined\n// by !!guard.\n// assert.ok(guard, message_opt);\n// This statement is equivalent to assert.equal(true, !!guard,\n// message_opt);. To test strictly for the value true, use\n// assert.strictEqual(true, guard, message_opt);.\n\nfunction ok(value, message) {\n  if (!value) fail(value, true, message, '==', assert.ok);\n}\nassert.ok = ok;\n\n// 5. The equality assertion tests shallow, coercive equality with\n// ==.\n// assert.equal(actual, expected, message_opt);\n\nassert.equal = function equal(actual, expected, message) {\n  if (actual != expected) fail(actual, expected, message, '==', assert.equal);\n};\n\n// 6. The non-equality assertion tests for whether two objects are not equal\n// with != assert.notEqual(actual, expected, message_opt);\n\nassert.notEqual = function notEqual(actual, expected, message) {\n  if (actual == expected) {\n    fail(actual, expected, message, '!=', assert.notEqual);\n  }\n};\n\n// 7. The equivalence assertion tests a deep equality relation.\n// assert.deepEqual(actual, expected, message_opt);\n\nassert.deepEqual = function deepEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'deepEqual', assert.deepEqual);\n  }\n};\n\nassert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {\n  if (!_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual);\n  }\n};\n\nfunction _deepEqual(actual, expected, strict, memos) {\n  // 7.1. All identical values are equivalent, as determined by ===.\n  if (actual === expected) {\n    return true;\n  } else if (isBuffer(actual) && isBuffer(expected)) {\n    return compare(actual, expected) === 0;\n\n  // 7.2. If the expected value is a Date object, the actual value is\n  // equivalent if it is also a Date object that refers to the same time.\n  } else if (util.isDate(actual) && util.isDate(expected)) {\n    return actual.getTime() === expected.getTime();\n\n  // 7.3 If the expected value is a RegExp object, the actual value is\n  // equivalent if it is also a RegExp object with the same source and\n  // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).\n  } else if (util.isRegExp(actual) && util.isRegExp(expected)) {\n    return actual.source === expected.source &&\n           actual.global === expected.global &&\n           actual.multiline === expected.multiline &&\n           actual.lastIndex === expected.lastIndex &&\n           actual.ignoreCase === expected.ignoreCase;\n\n  // 7.4. Other pairs that do not both pass typeof value == 'object',\n  // equivalence is determined by ==.\n  } else if ((actual === null || typeof actual !== 'object') &&\n             (expected === null || typeof expected !== 'object')) {\n    return strict ? actual === expected : actual == expected;\n\n  // If both values are instances of typed arrays, wrap their underlying\n  // ArrayBuffers in a Buffer each to increase performance\n  // This optimization requires the arrays to have the same type as checked by\n  // Object.prototype.toString (aka pToString). Never perform binary\n  // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their\n  // bit patterns are not identical.\n  } else if (isView(actual) && isView(expected) &&\n             pToString(actual) === pToString(expected) &&\n             !(actual instanceof Float32Array ||\n               actual instanceof Float64Array)) {\n    return compare(new Uint8Array(actual.buffer),\n                   new Uint8Array(expected.buffer)) === 0;\n\n  // 7.5 For all other Object pairs, including Array objects, equivalence is\n  // determined by having the same number of owned properties (as verified\n  // with Object.prototype.hasOwnProperty.call), the same set of keys\n  // (although not necessarily the same order), equivalent values for every\n  // corresponding key, and an identical 'prototype' property. Note: this\n  // accounts for both named and indexed properties on Arrays.\n  } else if (isBuffer(actual) !== isBuffer(expected)) {\n    return false;\n  } else {\n    memos = memos || {actual: [], expected: []};\n\n    var actualIndex = memos.actual.indexOf(actual);\n    if (actualIndex !== -1) {\n      if (actualIndex === memos.expected.indexOf(expected)) {\n        return true;\n      }\n    }\n\n    memos.actual.push(actual);\n    memos.expected.push(expected);\n\n    return objEquiv(actual, expected, strict, memos);\n  }\n}\n\nfunction isArguments(object) {\n  return Object.prototype.toString.call(object) == '[object Arguments]';\n}\n\nfunction objEquiv(a, b, strict, actualVisitedObjects) {\n  if (a === null || a === undefined || b === null || b === undefined)\n    return false;\n  // if one is a primitive, the other must be same\n  if (util.isPrimitive(a) || util.isPrimitive(b))\n    return a === b;\n  if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b))\n    return false;\n  var aIsArgs = isArguments(a);\n  var bIsArgs = isArguments(b);\n  if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))\n    return false;\n  if (aIsArgs) {\n    a = pSlice.call(a);\n    b = pSlice.call(b);\n    return _deepEqual(a, b, strict);\n  }\n  var ka = objectKeys(a);\n  var kb = objectKeys(b);\n  var key, i;\n  // having the same number of owned properties (keys incorporates\n  // hasOwnProperty)\n  if (ka.length !== kb.length)\n    return false;\n  //the same set of keys (although not necessarily the same order),\n  ka.sort();\n  kb.sort();\n  //~~~cheap key test\n  for (i = ka.length - 1; i >= 0; i--) {\n    if (ka[i] !== kb[i])\n      return false;\n  }\n  //equivalent values for every corresponding key, and\n  //~~~possibly expensive deep test\n  for (i = ka.length - 1; i >= 0; i--) {\n    key = ka[i];\n    if (!_deepEqual(a[key], b[key], strict, actualVisitedObjects))\n      return false;\n  }\n  return true;\n}\n\n// 8. The non-equivalence assertion tests for any deep inequality.\n// assert.notDeepEqual(actual, expected, message_opt);\n\nassert.notDeepEqual = function notDeepEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, false)) {\n    fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);\n  }\n};\n\nassert.notDeepStrictEqual = notDeepStrictEqual;\nfunction notDeepStrictEqual(actual, expected, message) {\n  if (_deepEqual(actual, expected, true)) {\n    fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual);\n  }\n}\n\n\n// 9. The strict equality assertion tests strict equality, as determined by ===.\n// assert.strictEqual(actual, expected, message_opt);\n\nassert.strictEqual = function strictEqual(actual, expected, message) {\n  if (actual !== expected) {\n    fail(actual, expected, message, '===', assert.strictEqual);\n  }\n};\n\n// 10. The strict non-equality assertion tests for strict inequality, as\n// determined by !==.  assert.notStrictEqual(actual, expected, message_opt);\n\nassert.notStrictEqual = function notStrictEqual(actual, expected, message) {\n  if (actual === expected) {\n    fail(actual, expected, message, '!==', assert.notStrictEqual);\n  }\n};\n\nfunction expectedException(actual, expected) {\n  if (!actual || !expected) {\n    return false;\n  }\n\n  if (Object.prototype.toString.call(expected) == '[object RegExp]') {\n    return expected.test(actual);\n  }\n\n  try {\n    if (actual instanceof expected) {\n      return true;\n    }\n  } catch (e) {\n    // Ignore.  The instanceof check doesn't work for arrow functions.\n  }\n\n  if (Error.isPrototypeOf(expected)) {\n    return false;\n  }\n\n  return expected.call({}, actual) === true;\n}\n\nfunction _tryBlock(block) {\n  var error;\n  try {\n    block();\n  } catch (e) {\n    error = e;\n  }\n  return error;\n}\n\nfunction _throws(shouldThrow, block, expected, message) {\n  var actual;\n\n  if (typeof block !== 'function') {\n    throw new TypeError('\"block\" argument must be a function');\n  }\n\n  if (typeof expected === 'string') {\n    message = expected;\n    expected = null;\n  }\n\n  actual = _tryBlock(block);\n\n  message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +\n            (message ? ' ' + message : '.');\n\n  if (shouldThrow && !actual) {\n    fail(actual, expected, 'Missing expected exception' + message);\n  }\n\n  var userProvidedMessage = typeof message === 'string';\n  var isUnwantedException = !shouldThrow && util.isError(actual);\n  var isUnexpectedException = !shouldThrow && actual && !expected;\n\n  if ((isUnwantedException &&\n      userProvidedMessage &&\n      expectedException(actual, expected)) ||\n      isUnexpectedException) {\n    fail(actual, expected, 'Got unwanted exception' + message);\n  }\n\n  if ((shouldThrow && actual && expected &&\n      !expectedException(actual, expected)) || (!shouldThrow && actual)) {\n    throw actual;\n  }\n}\n\n// 11. Expected to throw an error:\n// assert.throws(block, Error_opt, message_opt);\n\nassert.throws = function(block, /*optional*/error, /*optional*/message) {\n  _throws(true, block, error, message);\n};\n\n// EXTENSION! This is annoying to write outside this module.\nassert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) {\n  _throws(false, block, error, message);\n};\n\nassert.ifError = function(err) { if (err) throw err; };\n\n// Expose a strict only variant of assert\nfunction strict(value, message) {\n  if (!value) fail(value, true, message, '==', strict);\n}\nassert.strict = objectAssign(strict, assert, {\n  equal: assert.strictEqual,\n  deepEqual: assert.deepStrictEqual,\n  notEqual: assert.notStrictEqual,\n  notDeepEqual: assert.notDeepStrictEqual\n});\nassert.strict.strict = assert.strict;\n\nvar objectKeys = Object.keys || function (obj) {\n  var keys = [];\n  for (var key in obj) {\n    if (hasOwn.call(obj, key)) keys.push(key);\n  }\n  return keys;\n};\n","'use strict';\n\nif (typeof process === 'undefined' ||\n    !process.version ||\n    process.version.indexOf('v0.') === 0 ||\n    process.version.indexOf('v1.') === 0 && process.version.indexOf('v1.8.') !== 0) {\n  module.exports = { nextTick: nextTick };\n} else {\n  module.exports = process\n}\n\nfunction nextTick(fn, arg1, arg2, arg3) {\n  if (typeof fn !== 'function') {\n    throw new TypeError('\"callback\" argument must be a function');\n  }\n  var len = arguments.length;\n  var args, i;\n  switch (len) {\n  case 0:\n  case 1:\n    return process.nextTick(fn);\n  case 2:\n    return process.nextTick(function afterTickOne() {\n      fn.call(null, arg1);\n    });\n  case 3:\n    return process.nextTick(function afterTickTwo() {\n      fn.call(null, arg1, arg2);\n    });\n  case 4:\n    return process.nextTick(function afterTickThree() {\n      fn.call(null, arg1, arg2, arg3);\n    });\n  default:\n    args = new Array(len - 1);\n    i = 0;\n    while (i < args.length) {\n      args[i++] = arguments[i];\n    }\n    return process.nextTick(function afterTick() {\n      fn.apply(null, args);\n    });\n  }\n}\n\n","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n","/**\n * Implementation of the multicodec specification.\n *\n * @module multicodec\n * @example\n * const multicodec = require('multicodec')\n *\n * const prefixedProtobuf = multicodec.addPrefix('protobuf', protobufBuffer)\n * // prefixedProtobuf 0x50...\n *\n */\n'use strict'\n\n/** @typedef {import('./generated-types').CodecName} CodecName */\n/** @typedef {import('./generated-types').CodecCode} CodecCode */\n\nconst varint = require('varint')\nconst uint8ArrayConcat = require('uint8arrays/concat')\nconst util = require('./util')\nconst { nameToVarint, constantToCode, nameToCode, codeToName } = require('./maps')\n\n/**\n * Prefix a buffer with a multicodec-packed.\n *\n * @param {CodecName|Uint8Array} multicodecStrOrCode\n * @param {Uint8Array} data\n * @returns {Uint8Array}\n */\nfunction addPrefix (multicodecStrOrCode, data) {\n  let prefix\n\n  if (multicodecStrOrCode instanceof Uint8Array) {\n    prefix = util.varintUint8ArrayEncode(multicodecStrOrCode)\n  } else {\n    if (nameToVarint[multicodecStrOrCode]) {\n      prefix = nameToVarint[multicodecStrOrCode]\n    } else {\n      throw new Error('multicodec not recognized')\n    }\n  }\n\n  return uint8ArrayConcat([prefix, data], prefix.length + data.length)\n}\n\n/**\n * Decapsulate the multicodec-packed prefix from the data.\n *\n * @param {Uint8Array} data\n * @returns {Uint8Array}\n */\nfunction rmPrefix (data) {\n  varint.decode(/** @type {Buffer} */(data))\n  return data.slice(varint.decode.bytes)\n}\n\n/**\n * Get the codec name of the prefixed data.\n *\n * @param {Uint8Array} prefixedData\n * @returns {CodecName}\n */\nfunction getNameFromData (prefixedData) {\n  const code = /** @type {CodecCode} */(varint.decode(/** @type {Buffer} */(prefixedData)))\n  const name = codeToName[code]\n  if (name === undefined) {\n    throw new Error(`Code \"${code}\" not found`)\n  }\n  return name\n}\n\n/**\n * Get the codec name from a code.\n *\n * @param {CodecCode} codec\n * @returns {CodecName}\n */\nfunction getNameFromCode (codec) {\n  return codeToName[codec]\n}\n\n/**\n * Get the code of the codec\n *\n * @param {CodecName} name\n * @returns {CodecCode}\n */\nfunction getCodeFromName (name) {\n  const code = nameToCode[name]\n  if (code === undefined) {\n    throw new Error(`Codec \"${name}\" not found`)\n  }\n  return code\n}\n\n/**\n * Get the code of the prefixed data.\n *\n * @param {Uint8Array} prefixedData\n * @returns {CodecCode}\n */\nfunction getCodeFromData (prefixedData) {\n  return /** @type {CodecCode} */(varint.decode(/** @type {Buffer} */(prefixedData)))\n}\n\n/**\n * Get the code as varint of a codec name.\n *\n * @param {CodecName} name\n * @returns {Uint8Array}\n */\nfunction getVarintFromName (name) {\n  const code = nameToVarint[name]\n  if (code === undefined) {\n    throw new Error(`Codec \"${name}\" not found`)\n  }\n  return code\n}\n\n/**\n * Get the varint of a code.\n *\n * @param {CodecCode} code\n * @returns {Uint8Array}\n */\nfunction getVarintFromCode (code) {\n  return util.varintEncode(code)\n}\n\n/**\n * Get the codec name of the prefixed data.\n *\n * @deprecated use getNameFromData instead.\n * @param {Uint8Array} prefixedData\n * @returns {CodecName}\n */\nfunction getCodec (prefixedData) {\n  return getNameFromData(prefixedData)\n}\n\n/**\n * Get the codec name from a code.\n *\n * @deprecated use getNameFromCode instead.\n * @param {CodecCode} codec\n * @returns {CodecName}\n */\nfunction getName (codec) {\n  return getNameFromCode(codec)\n}\n\n/**\n * Get the code of the codec\n *\n * @deprecated use getCodeFromName instead.\n * @param {CodecName} name\n * @returns {CodecCode}\n */\nfunction getNumber (name) {\n  return getCodeFromName(name)\n}\n\n/**\n * Get the code of the prefixed data.\n *\n * @deprecated use getCodeFromData instead.\n * @param {Uint8Array} prefixedData\n * @returns {CodecCode}\n */\nfunction getCode (prefixedData) {\n  return getCodeFromData(prefixedData)\n}\n\n/**\n * Get the code as varint of a codec name.\n *\n * @deprecated use getVarintFromName instead.\n * @param {CodecName} name\n * @returns {Uint8Array}\n */\nfunction getCodeVarint (name) {\n  return getVarintFromName(name)\n}\n\n/**\n * Get the varint of a code.\n *\n * @deprecated use getVarintFromCode instead.\n * @param {CodecCode} code\n * @returns {Array.<number>}\n */\nfunction getVarint (code) {\n  return Array.from(getVarintFromCode(code))\n}\n\nmodule.exports = {\n  addPrefix,\n  rmPrefix,\n  getNameFromData,\n  getNameFromCode,\n  getCodeFromName,\n  getCodeFromData,\n  getVarintFromName,\n  getVarintFromCode,\n  // Deprecated\n  getCodec,\n  getName,\n  getNumber,\n  getCode,\n  getCodeVarint,\n  getVarint,\n  // Make the constants top-level constants\n  ...constantToCode,\n  // Export the maps\n  nameToVarint,\n  nameToCode,\n  codeToName\n}\n","'use strict'\n\n/**\n * Returns a new Uint8Array created by concatenating the passed ArrayLikes\n *\n * @param {Array<ArrayLike<number>>} arrays\n * @param {number} [length]\n */\nfunction concat (arrays, length) {\n  if (!length) {\n    length = arrays.reduce((acc, curr) => acc + curr.length, 0)\n  }\n\n  const output = new Uint8Array(length)\n  let offset = 0\n\n  for (const arr of arrays) {\n    output.set(arr, offset)\n    offset += arr.length\n  }\n\n  return output\n}\n\nmodule.exports = concat\n","'use strict'\n\nconst { encoding: getCodec } = require('multibase')\nconst utf8Decoder = new TextDecoder('utf8')\n\n/**\n * @typedef {import('multibase/src/types').BaseName} BaseName\n */\n\n/**\n * Turns a Uint8Array of bytes into a string with each\n * character being the char code of the corresponding byte\n *\n * @param {Uint8Array} array - The array to turn into a string\n */\nfunction uint8ArrayToAsciiString (array) {\n  let string = ''\n\n  for (let i = 0; i < array.length; i++) {\n    string += String.fromCharCode(array[i])\n  }\n  return string\n}\n\n/**\n * Turns a `Uint8Array` into a string.\n *\n * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.\n *\n * Also `ascii` which is similar to node's 'binary' encoding.\n *\n * @param {Uint8Array} array - The array to turn into a string\n * @param {BaseName | 'utf8' | 'utf-8' | 'ascii'} [encoding=utf8] - The encoding to use\n * @returns {string}\n */\nfunction toString (array, encoding = 'utf8') {\n  if (encoding === 'utf8' || encoding === 'utf-8') {\n    return utf8Decoder.decode(array)\n  }\n\n  if (encoding === 'ascii') {\n    return uint8ArrayToAsciiString(array)\n  }\n\n  return getCodec(encoding).encode(array)\n}\n\nmodule.exports = toString\n","/**\n * Implementation of the [multibase](https://github.com/multiformats/multibase) specification.\n *\n */\n'use strict'\n\nconst constants = require('./constants')\nconst { encodeText, decodeText, concat } = require('./util')\n\n/** @typedef {import('./base')} Base */\n/** @typedef {import(\"./types\").BaseNameOrCode} BaseNameOrCode */\n/** @typedef {import(\"./types\").BaseCode} BaseCode */\n/** @typedef {import(\"./types\").BaseName} BaseName */\n\n/**\n * Create a new Uint8Array with the multibase varint+code.\n *\n * @param {BaseNameOrCode} nameOrCode - The multibase name or code number.\n * @param {Uint8Array} buf - The data to be prefixed with multibase.\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction multibase (nameOrCode, buf) {\n  if (!buf) {\n    throw new Error('requires an encoded Uint8Array')\n  }\n  const { name, codeBuf } = encoding(nameOrCode)\n  validEncode(name, buf)\n\n  return concat([codeBuf, buf], codeBuf.length + buf.length)\n}\n\n/**\n * Encode data with the specified base and add the multibase prefix.\n *\n * @param {BaseNameOrCode} nameOrCode - The multibase name or code number.\n * @param {Uint8Array} buf - The data to be encoded.\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n *\n */\nfunction encode (nameOrCode, buf) {\n  const enc = encoding(nameOrCode)\n  const data = encodeText(enc.encode(buf))\n\n  return concat([enc.codeBuf, data], enc.codeBuf.length + data.length)\n}\n\n/**\n * Takes a Uint8Array or string encoded with multibase header, decodes it and\n * returns the decoded buffer\n *\n * @param {Uint8Array|string} data\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n *\n */\nfunction decode (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n  const prefix = data[0]\n\n  // Make all encodings case-insensitive except the ones that include upper and lower chars in the alphabet\n  if (['f', 'F', 'v', 'V', 't', 'T', 'b', 'B', 'c', 'C', 'h', 'k', 'K'].includes(prefix)) {\n    data = data.toLowerCase()\n  }\n  const enc = encoding(/** @type {BaseCode} */(data[0]))\n  return enc.decode(data.substring(1))\n}\n\n/**\n * Is the given data multibase encoded?\n *\n * @param {Uint8Array|string} data\n */\nfunction isEncoded (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n\n  // Ensure bufOrString is a string\n  if (Object.prototype.toString.call(data) !== '[object String]') {\n    return false\n  }\n\n  try {\n    const enc = encoding(/** @type {BaseCode} */(data[0]))\n    return enc.name\n  } catch (err) {\n    return false\n  }\n}\n\n/**\n * Validate encoded data\n *\n * @param {BaseNameOrCode} name\n * @param {Uint8Array} buf\n * @returns {void}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction validEncode (name, buf) {\n  const enc = encoding(name)\n  enc.decode(decodeText(buf))\n}\n\n/**\n * Get the encoding by name or code\n *\n * @param {BaseNameOrCode} nameOrCode\n * @returns {Base}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction encoding (nameOrCode) {\n  if (Object.prototype.hasOwnProperty.call(constants.names, /** @type {BaseName} */(nameOrCode))) {\n    return constants.names[/** @type {BaseName} */(nameOrCode)]\n  } else if (Object.prototype.hasOwnProperty.call(constants.codes, /** @type {BaseCode} */(nameOrCode))) {\n    return constants.codes[/** @type {BaseCode} */(nameOrCode)]\n  } else {\n    throw new Error(`Unsupported encoding: ${nameOrCode}`)\n  }\n}\n\n/**\n * Get encoding from data\n *\n * @param {string|Uint8Array} data\n * @returns {Base}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction encodingFromData (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n\n  return encoding(/** @type {BaseCode} */(data[0]))\n}\n\nexports = module.exports = multibase\nexports.encode = encode\nexports.decode = decode\nexports.isEncoded = isEncoded\nexports.encoding = encoding\nexports.encodingFromData = encodingFromData\nconst names = Object.freeze(constants.names)\nconst codes = Object.freeze(constants.codes)\nexports.names = names\nexports.codes = codes\n","'use strict'\n\nconst textDecoder = new TextDecoder()\n/**\n * @param {ArrayBufferView|ArrayBuffer} bytes\n * @returns {string}\n */\nconst decodeText = (bytes) => textDecoder.decode(bytes)\n\nconst textEncoder = new TextEncoder()\n/**\n * @param {string} text\n * @returns {Uint8Array}\n */\nconst encodeText = (text) => textEncoder.encode(text)\n\n/**\n * Returns a new Uint8Array created by concatenating the passed Arrays\n *\n * @param {Array<ArrayLike<number>>} arrs\n * @param {number} length\n * @returns {Uint8Array}\n */\nfunction concat (arrs, length) {\n  const output = new Uint8Array(length)\n  let offset = 0\n\n  for (const arr of arrs) {\n    output.set(arr, offset)\n    offset += arr.length\n  }\n\n  return output\n}\n\nmodule.exports = { decodeText, encodeText, concat }\n","/**\n * Implementation of the [multibase](https://github.com/multiformats/multibase) specification.\n *\n */\n'use strict'\n\nconst constants = require('./constants')\nconst { encodeText, decodeText, concat } = require('./util')\n\n/** @typedef {import('./base')} Base */\n/** @typedef {import(\"./types\").BaseNameOrCode} BaseNameOrCode */\n/** @typedef {import(\"./types\").BaseCode} BaseCode */\n/** @typedef {import(\"./types\").BaseName} BaseName */\n\n/**\n * Create a new Uint8Array with the multibase varint+code.\n *\n * @param {BaseNameOrCode} nameOrCode - The multibase name or code number.\n * @param {Uint8Array} buf - The data to be prefixed with multibase.\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction multibase (nameOrCode, buf) {\n  if (!buf) {\n    throw new Error('requires an encoded Uint8Array')\n  }\n  const { name, codeBuf } = encoding(nameOrCode)\n  validEncode(name, buf)\n\n  return concat([codeBuf, buf], codeBuf.length + buf.length)\n}\n\n/**\n * Encode data with the specified base and add the multibase prefix.\n *\n * @param {BaseNameOrCode} nameOrCode - The multibase name or code number.\n * @param {Uint8Array} buf - The data to be encoded.\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n *\n */\nfunction encode (nameOrCode, buf) {\n  const enc = encoding(nameOrCode)\n  const data = encodeText(enc.encode(buf))\n\n  return concat([enc.codeBuf, data], enc.codeBuf.length + data.length)\n}\n\n/**\n * Takes a Uint8Array or string encoded with multibase header, decodes it and\n * returns the decoded buffer\n *\n * @param {Uint8Array|string} data\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n *\n */\nfunction decode (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n  const prefix = data[0]\n\n  // Make all encodings case-insensitive except the ones that include upper and lower chars in the alphabet\n  if (['f', 'F', 'v', 'V', 't', 'T', 'b', 'B', 'c', 'C', 'h', 'k', 'K'].includes(prefix)) {\n    data = data.toLowerCase()\n  }\n  const enc = encoding(/** @type {BaseCode} */(data[0]))\n  return enc.decode(data.substring(1))\n}\n\n/**\n * Is the given data multibase encoded?\n *\n * @param {Uint8Array|string} data\n */\nfunction isEncoded (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n\n  // Ensure bufOrString is a string\n  if (Object.prototype.toString.call(data) !== '[object String]') {\n    return false\n  }\n\n  try {\n    const enc = encoding(/** @type {BaseCode} */(data[0]))\n    return enc.name\n  } catch (err) {\n    return false\n  }\n}\n\n/**\n * Validate encoded data\n *\n * @param {BaseNameOrCode} name\n * @param {Uint8Array} buf\n * @returns {void}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction validEncode (name, buf) {\n  const enc = encoding(name)\n  enc.decode(decodeText(buf))\n}\n\n/**\n * Get the encoding by name or code\n *\n * @param {BaseNameOrCode} nameOrCode\n * @returns {Base}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction encoding (nameOrCode) {\n  if (Object.prototype.hasOwnProperty.call(constants.names, /** @type {BaseName} */(nameOrCode))) {\n    return constants.names[/** @type {BaseName} */(nameOrCode)]\n  } else if (Object.prototype.hasOwnProperty.call(constants.codes, /** @type {BaseCode} */(nameOrCode))) {\n    return constants.codes[/** @type {BaseCode} */(nameOrCode)]\n  } else {\n    throw new Error(`Unsupported encoding: ${nameOrCode}`)\n  }\n}\n\n/**\n * Get encoding from data\n *\n * @param {string|Uint8Array} data\n * @returns {Base}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction encodingFromData (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n\n  return encoding(/** @type {BaseCode} */(data[0]))\n}\n\nexports = module.exports = multibase\nexports.encode = encode\nexports.decode = decode\nexports.isEncoded = isEncoded\nexports.encoding = encoding\nexports.encodingFromData = encodingFromData\nconst names = Object.freeze(constants.names)\nconst codes = Object.freeze(constants.codes)\nexports.names = names\nexports.codes = codes\n","'use strict'\n\nconst textDecoder = new TextDecoder()\n/**\n * @param {ArrayBufferView|ArrayBuffer} bytes\n * @returns {string}\n */\nconst decodeText = (bytes) => textDecoder.decode(bytes)\n\nconst textEncoder = new TextEncoder()\n/**\n * @param {string} text\n * @returns {Uint8Array}\n */\nconst encodeText = (text) => textEncoder.encode(text)\n\n/**\n * Returns a new Uint8Array created by concatenating the passed Arrays\n *\n * @param {Array<ArrayLike<number>>} arrs\n * @param {number} length\n * @returns {Uint8Array}\n */\nfunction concat (arrs, length) {\n  const output = new Uint8Array(length)\n  let offset = 0\n\n  for (const arr of arrs) {\n    output.set(arr, offset)\n    offset += arr.length\n  }\n\n  return output\n}\n\nmodule.exports = { decodeText, encodeText, concat }\n","'use strict'\n\nconst { encoding: getCodec } = require('multibase')\nconst utf8Encoder = new TextEncoder()\n\n/**\n * @typedef {import('multibase/src/types').BaseName} BaseName\n */\n\n/**\n * Interprets each character in a string as a byte and\n * returns a Uint8Array of those bytes.\n *\n * @param {string} string - The string to turn into an array\n */\nfunction asciiStringToUint8Array (string) {\n  const array = new Uint8Array(string.length)\n\n  for (let i = 0; i < string.length; i++) {\n    array[i] = string.charCodeAt(i)\n  }\n\n  return array\n}\n\n/**\n * Create a `Uint8Array` from the passed string\n *\n * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.\n *\n * Also `ascii` which is similar to node's 'binary' encoding.\n *\n * @param {string} string\n * @param {BaseName | 'utf8' | 'utf-8' | 'ascii'} [encoding=utf8] - utf8, base16, base64, base64urlpad, etc\n * @returns {Uint8Array}\n */\nfunction fromString (string, encoding = 'utf8') {\n  if (encoding === 'utf8' || encoding === 'utf-8') {\n    return utf8Encoder.encode(string)\n  }\n\n  if (encoding === 'ascii') {\n    return asciiStringToUint8Array(string)\n  }\n\n  return getCodec(encoding).decode(string)\n}\n\nmodule.exports = fromString\n","/**\n * Implementation of the [multibase](https://github.com/multiformats/multibase) specification.\n *\n */\n'use strict'\n\nconst constants = require('./constants')\nconst { encodeText, decodeText, concat } = require('./util')\n\n/** @typedef {import('./base')} Base */\n/** @typedef {import(\"./types\").BaseNameOrCode} BaseNameOrCode */\n/** @typedef {import(\"./types\").BaseCode} BaseCode */\n/** @typedef {import(\"./types\").BaseName} BaseName */\n\n/**\n * Create a new Uint8Array with the multibase varint+code.\n *\n * @param {BaseNameOrCode} nameOrCode - The multibase name or code number.\n * @param {Uint8Array} buf - The data to be prefixed with multibase.\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction multibase (nameOrCode, buf) {\n  if (!buf) {\n    throw new Error('requires an encoded Uint8Array')\n  }\n  const { name, codeBuf } = encoding(nameOrCode)\n  validEncode(name, buf)\n\n  return concat([codeBuf, buf], codeBuf.length + buf.length)\n}\n\n/**\n * Encode data with the specified base and add the multibase prefix.\n *\n * @param {BaseNameOrCode} nameOrCode - The multibase name or code number.\n * @param {Uint8Array} buf - The data to be encoded.\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n *\n */\nfunction encode (nameOrCode, buf) {\n  const enc = encoding(nameOrCode)\n  const data = encodeText(enc.encode(buf))\n\n  return concat([enc.codeBuf, data], enc.codeBuf.length + data.length)\n}\n\n/**\n * Takes a Uint8Array or string encoded with multibase header, decodes it and\n * returns the decoded buffer\n *\n * @param {Uint8Array|string} data\n * @returns {Uint8Array}\n * @throws {Error} Will throw if the encoding is not supported\n *\n */\nfunction decode (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n  const prefix = data[0]\n\n  // Make all encodings case-insensitive except the ones that include upper and lower chars in the alphabet\n  if (['f', 'F', 'v', 'V', 't', 'T', 'b', 'B', 'c', 'C', 'h', 'k', 'K'].includes(prefix)) {\n    data = data.toLowerCase()\n  }\n  const enc = encoding(/** @type {BaseCode} */(data[0]))\n  return enc.decode(data.substring(1))\n}\n\n/**\n * Is the given data multibase encoded?\n *\n * @param {Uint8Array|string} data\n * @returns {false | string}\n */\nfunction isEncoded (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n\n  // Ensure bufOrString is a string\n  if (Object.prototype.toString.call(data) !== '[object String]') {\n    return false\n  }\n\n  try {\n    const enc = encoding(/** @type {BaseCode} */(data[0]))\n    return enc.name\n  } catch (err) {\n    return false\n  }\n}\n\n/**\n * Validate encoded data\n *\n * @param {BaseNameOrCode} name\n * @param {Uint8Array} buf\n * @returns {void}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction validEncode (name, buf) {\n  const enc = encoding(name)\n  enc.decode(decodeText(buf))\n}\n\n/**\n * Get the encoding by name or code\n *\n * @param {BaseNameOrCode} nameOrCode\n * @returns {Base}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction encoding (nameOrCode) {\n  if (Object.prototype.hasOwnProperty.call(constants.names, /** @type {BaseName} */(nameOrCode))) {\n    return constants.names[/** @type {BaseName} */(nameOrCode)]\n  } else if (Object.prototype.hasOwnProperty.call(constants.codes, /** @type {BaseCode} */(nameOrCode))) {\n    return constants.codes[/** @type {BaseCode} */(nameOrCode)]\n  } else {\n    throw new Error(`Unsupported encoding: ${nameOrCode}`)\n  }\n}\n\n/**\n * Get encoding from data\n *\n * @param {string|Uint8Array} data\n * @returns {Base}\n * @throws {Error} Will throw if the encoding is not supported\n */\nfunction encodingFromData (data) {\n  if (data instanceof Uint8Array) {\n    data = decodeText(data)\n  }\n\n  return encoding(/** @type {BaseCode} */(data[0]))\n}\n\nexports = module.exports = multibase\nexports.encode = encode\nexports.decode = decode\nexports.isEncoded = isEncoded\nexports.encoding = encoding\nexports.encodingFromData = encodingFromData\nconst names = Object.freeze(constants.names)\nconst codes = Object.freeze(constants.codes)\nexports.names = names\nexports.codes = codes\n","'use strict'\n\n// @ts-ignore\nconst { TextEncoder, TextDecoder } = require('web-encoding')\n\nconst textDecoder = new TextDecoder()\n/**\n * @param {ArrayBufferView|ArrayBuffer} bytes\n * @returns {string}\n */\nconst decodeText = (bytes) => textDecoder.decode(bytes)\n\nconst textEncoder = new TextEncoder()\n/**\n * @param {string} text\n * @returns {Uint8Array}\n */\nconst encodeText = (text) => textEncoder.encode(text)\n\n/**\n * Returns a new Uint8Array created by concatenating the passed Arrays\n *\n * @param {Array<ArrayLike<number>>} arrs\n * @param {number} length\n * @returns {Uint8Array}\n */\nfunction concat (arrs, length) {\n  const output = new Uint8Array(length)\n  let offset = 0\n\n  for (const arr of arrs) {\n    output.set(arr, offset)\n    offset += arr.length\n  }\n\n  return output\n}\n\nmodule.exports = { decodeText, encodeText, concat }\n","// In node `export { TextEncoder }` throws:\n// \"Export 'TextEncoder' is not definedin module\"\n// To workaround we first define constants and then export with as.\nconst Encoder = TextEncoder\nconst Decoder = TextDecoder\n\nexport { Encoder as TextEncoder, Decoder as TextDecoder }\n","'use strict'\n\nconst { encoding: getCodec } = require('multibase')\nconst { TextDecoder } = require('web-encoding')\nconst utf8Decoder = new TextDecoder('utf8')\n\n/**\n * @typedef {import('multibase/src/types').BaseName} BaseName\n */\n\n/**\n * Turns a Uint8Array of bytes into a string with each\n * character being the char code of the corresponding byte\n *\n * @param {Uint8Array} array - The array to turn into a string\n */\nfunction uint8ArrayToAsciiString (array) {\n  let string = ''\n\n  for (let i = 0; i < array.length; i++) {\n    string += String.fromCharCode(array[i])\n  }\n  return string\n}\n\n/**\n * Turns a `Uint8Array` into a string.\n *\n * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.\n *\n * Also `ascii` which is similar to node's 'binary' encoding.\n *\n * @param {Uint8Array} array - The array to turn into a string\n * @param {BaseName | 'utf8' | 'utf-8' | 'ascii'} [encoding=utf8] - The encoding to use\n * @returns {string}\n */\nfunction toString (array, encoding = 'utf8') {\n  if (encoding === 'utf8' || encoding === 'utf-8') {\n    return utf8Decoder.decode(array)\n  }\n\n  if (encoding === 'ascii') {\n    return uint8ArrayToAsciiString(array)\n  }\n\n  return getCodec(encoding).encode(array)\n}\n\nmodule.exports = toString\n","'use strict'\n\nconst { encoding: getCodec } = require('multibase')\nconst { TextEncoder } = require('web-encoding')\nconst utf8Encoder = new TextEncoder()\n\n/**\n * @typedef {import('multibase/src/types').BaseName} BaseName\n */\n\n/**\n * Interprets each character in a string as a byte and\n * returns a Uint8Array of those bytes.\n *\n * @param {string} string - The string to turn into an array\n */\nfunction asciiStringToUint8Array (string) {\n  const array = new Uint8Array(string.length)\n\n  for (let i = 0; i < string.length; i++) {\n    array[i] = string.charCodeAt(i)\n  }\n\n  return array\n}\n\n/**\n * Create a `Uint8Array` from the passed string\n *\n * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.\n *\n * Also `ascii` which is similar to node's 'binary' encoding.\n *\n * @param {string} string\n * @param {BaseName | 'utf8' | 'utf-8' | 'ascii'} [encoding=utf8] - utf8, base16, base64, base64urlpad, etc\n * @returns {Uint8Array}\n */\nfunction fromString (string, encoding = 'utf8') {\n  if (encoding === 'utf8' || encoding === 'utf-8') {\n    return utf8Encoder.encode(string)\n  }\n\n  if (encoding === 'ascii') {\n    return asciiStringToUint8Array(string)\n  }\n\n  return getCodec(encoding).decode(string)\n}\n\nmodule.exports = fromString\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nconst utils_1 = require(\"./utils\");\n// The default Buffer size if one is not provided.\nconst DEFAULT_SMARTBUFFER_SIZE = 4096;\n// The default string encoding to use for reading/writing strings.\nconst DEFAULT_SMARTBUFFER_ENCODING = 'utf8';\nclass SmartBuffer {\n    /**\n     * Creates a new SmartBuffer instance.\n     *\n     * @param options { SmartBufferOptions } The SmartBufferOptions to apply to this instance.\n     */\n    constructor(options) {\n        this.length = 0;\n        this._encoding = DEFAULT_SMARTBUFFER_ENCODING;\n        this._writeOffset = 0;\n        this._readOffset = 0;\n        if (SmartBuffer.isSmartBufferOptions(options)) {\n            // Checks for encoding\n            if (options.encoding) {\n                utils_1.checkEncoding(options.encoding);\n                this._encoding = options.encoding;\n            }\n            // Checks for initial size length\n            if (options.size) {\n                if (utils_1.isFiniteInteger(options.size) && options.size > 0) {\n                    this._buff = Buffer.allocUnsafe(options.size);\n                }\n                else {\n                    throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_SIZE);\n                }\n                // Check for initial Buffer\n            }\n            else if (options.buff) {\n                if (options.buff instanceof Buffer) {\n                    this._buff = options.buff;\n                    this.length = options.buff.length;\n                }\n                else {\n                    throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_BUFFER);\n                }\n            }\n            else {\n                this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);\n            }\n        }\n        else {\n            // If something was passed but it's not a SmartBufferOptions object\n            if (typeof options !== 'undefined') {\n                throw new Error(utils_1.ERRORS.INVALID_SMARTBUFFER_OBJECT);\n            }\n            // Otherwise default to sane options\n            this._buff = Buffer.allocUnsafe(DEFAULT_SMARTBUFFER_SIZE);\n        }\n    }\n    /**\n     * Creates a new SmartBuffer instance with the provided internal Buffer size and optional encoding.\n     *\n     * @param size { Number } The size of the internal Buffer.\n     * @param encoding { String } The BufferEncoding to use for strings.\n     *\n     * @return { SmartBuffer }\n     */\n    static fromSize(size, encoding) {\n        return new this({\n            size: size,\n            encoding: encoding\n        });\n    }\n    /**\n     * Creates a new SmartBuffer instance with the provided Buffer and optional encoding.\n     *\n     * @param buffer { Buffer } The Buffer to use as the internal Buffer value.\n     * @param encoding { String } The BufferEncoding to use for strings.\n     *\n     * @return { SmartBuffer }\n     */\n    static fromBuffer(buff, encoding) {\n        return new this({\n            buff: buff,\n            encoding: encoding\n        });\n    }\n    /**\n     * Creates a new SmartBuffer instance with the provided SmartBufferOptions options.\n     *\n     * @param options { SmartBufferOptions } The options to use when creating the SmartBuffer instance.\n     */\n    static fromOptions(options) {\n        return new this(options);\n    }\n    /**\n     * Type checking function that determines if an object is a SmartBufferOptions object.\n     */\n    static isSmartBufferOptions(options) {\n        const castOptions = options;\n        return (castOptions &&\n            (castOptions.encoding !== undefined || castOptions.size !== undefined || castOptions.buff !== undefined));\n    }\n    // Signed integers\n    /**\n     * Reads an Int8 value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readInt8(offset) {\n        return this._readNumberValue(Buffer.prototype.readInt8, 1, offset);\n    }\n    /**\n     * Reads an Int16BE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readInt16BE(offset) {\n        return this._readNumberValue(Buffer.prototype.readInt16BE, 2, offset);\n    }\n    /**\n     * Reads an Int16LE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readInt16LE(offset) {\n        return this._readNumberValue(Buffer.prototype.readInt16LE, 2, offset);\n    }\n    /**\n     * Reads an Int32BE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readInt32BE(offset) {\n        return this._readNumberValue(Buffer.prototype.readInt32BE, 4, offset);\n    }\n    /**\n     * Reads an Int32LE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readInt32LE(offset) {\n        return this._readNumberValue(Buffer.prototype.readInt32LE, 4, offset);\n    }\n    /**\n     * Reads a BigInt64BE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { BigInt }\n     */\n    readBigInt64BE(offset) {\n        utils_1.bigIntAndBufferInt64Check('readBigInt64BE');\n        return this._readNumberValue(Buffer.prototype.readBigInt64BE, 8, offset);\n    }\n    /**\n     * Reads a BigInt64LE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { BigInt }\n     */\n    readBigInt64LE(offset) {\n        utils_1.bigIntAndBufferInt64Check('readBigInt64LE');\n        return this._readNumberValue(Buffer.prototype.readBigInt64LE, 8, offset);\n    }\n    /**\n     * Writes an Int8 value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeInt8(value, offset) {\n        this._writeNumberValue(Buffer.prototype.writeInt8, 1, value, offset);\n        return this;\n    }\n    /**\n     * Inserts an Int8 value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertInt8(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeInt8, 1, value, offset);\n    }\n    /**\n     * Writes an Int16BE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeInt16BE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);\n    }\n    /**\n     * Inserts an Int16BE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertInt16BE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeInt16BE, 2, value, offset);\n    }\n    /**\n     * Writes an Int16LE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeInt16LE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);\n    }\n    /**\n     * Inserts an Int16LE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertInt16LE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeInt16LE, 2, value, offset);\n    }\n    /**\n     * Writes an Int32BE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeInt32BE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);\n    }\n    /**\n     * Inserts an Int32BE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertInt32BE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeInt32BE, 4, value, offset);\n    }\n    /**\n     * Writes an Int32LE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeInt32LE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);\n    }\n    /**\n     * Inserts an Int32LE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertInt32LE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeInt32LE, 4, value, offset);\n    }\n    /**\n     * Writes a BigInt64BE value to the current write position (or at optional offset).\n     *\n     * @param value { BigInt } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeBigInt64BE(value, offset) {\n        utils_1.bigIntAndBufferInt64Check('writeBigInt64BE');\n        return this._writeNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);\n    }\n    /**\n     * Inserts a BigInt64BE value at the given offset value.\n     *\n     * @param value { BigInt } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertBigInt64BE(value, offset) {\n        utils_1.bigIntAndBufferInt64Check('writeBigInt64BE');\n        return this._insertNumberValue(Buffer.prototype.writeBigInt64BE, 8, value, offset);\n    }\n    /**\n     * Writes a BigInt64LE value to the current write position (or at optional offset).\n     *\n     * @param value { BigInt } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeBigInt64LE(value, offset) {\n        utils_1.bigIntAndBufferInt64Check('writeBigInt64LE');\n        return this._writeNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);\n    }\n    /**\n     * Inserts a Int64LE value at the given offset value.\n     *\n     * @param value { BigInt } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertBigInt64LE(value, offset) {\n        utils_1.bigIntAndBufferInt64Check('writeBigInt64LE');\n        return this._insertNumberValue(Buffer.prototype.writeBigInt64LE, 8, value, offset);\n    }\n    // Unsigned Integers\n    /**\n     * Reads an UInt8 value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readUInt8(offset) {\n        return this._readNumberValue(Buffer.prototype.readUInt8, 1, offset);\n    }\n    /**\n     * Reads an UInt16BE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readUInt16BE(offset) {\n        return this._readNumberValue(Buffer.prototype.readUInt16BE, 2, offset);\n    }\n    /**\n     * Reads an UInt16LE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readUInt16LE(offset) {\n        return this._readNumberValue(Buffer.prototype.readUInt16LE, 2, offset);\n    }\n    /**\n     * Reads an UInt32BE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readUInt32BE(offset) {\n        return this._readNumberValue(Buffer.prototype.readUInt32BE, 4, offset);\n    }\n    /**\n     * Reads an UInt32LE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readUInt32LE(offset) {\n        return this._readNumberValue(Buffer.prototype.readUInt32LE, 4, offset);\n    }\n    /**\n     * Reads a BigUInt64BE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { BigInt }\n     */\n    readBigUInt64BE(offset) {\n        utils_1.bigIntAndBufferInt64Check('readBigUInt64BE');\n        return this._readNumberValue(Buffer.prototype.readBigUInt64BE, 8, offset);\n    }\n    /**\n     * Reads a BigUInt64LE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { BigInt }\n     */\n    readBigUInt64LE(offset) {\n        utils_1.bigIntAndBufferInt64Check('readBigUInt64LE');\n        return this._readNumberValue(Buffer.prototype.readBigUInt64LE, 8, offset);\n    }\n    /**\n     * Writes an UInt8 value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeUInt8(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);\n    }\n    /**\n     * Inserts an UInt8 value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertUInt8(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeUInt8, 1, value, offset);\n    }\n    /**\n     * Writes an UInt16BE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeUInt16BE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);\n    }\n    /**\n     * Inserts an UInt16BE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertUInt16BE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeUInt16BE, 2, value, offset);\n    }\n    /**\n     * Writes an UInt16LE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeUInt16LE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);\n    }\n    /**\n     * Inserts an UInt16LE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertUInt16LE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeUInt16LE, 2, value, offset);\n    }\n    /**\n     * Writes an UInt32BE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeUInt32BE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);\n    }\n    /**\n     * Inserts an UInt32BE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertUInt32BE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeUInt32BE, 4, value, offset);\n    }\n    /**\n     * Writes an UInt32LE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeUInt32LE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);\n    }\n    /**\n     * Inserts an UInt32LE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertUInt32LE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeUInt32LE, 4, value, offset);\n    }\n    /**\n     * Writes a BigUInt64BE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeBigUInt64BE(value, offset) {\n        utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE');\n        return this._writeNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);\n    }\n    /**\n     * Inserts a BigUInt64BE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertBigUInt64BE(value, offset) {\n        utils_1.bigIntAndBufferInt64Check('writeBigUInt64BE');\n        return this._insertNumberValue(Buffer.prototype.writeBigUInt64BE, 8, value, offset);\n    }\n    /**\n     * Writes a BigUInt64LE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeBigUInt64LE(value, offset) {\n        utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE');\n        return this._writeNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);\n    }\n    /**\n     * Inserts a BigUInt64LE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertBigUInt64LE(value, offset) {\n        utils_1.bigIntAndBufferInt64Check('writeBigUInt64LE');\n        return this._insertNumberValue(Buffer.prototype.writeBigUInt64LE, 8, value, offset);\n    }\n    // Floating Point\n    /**\n     * Reads an FloatBE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readFloatBE(offset) {\n        return this._readNumberValue(Buffer.prototype.readFloatBE, 4, offset);\n    }\n    /**\n     * Reads an FloatLE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readFloatLE(offset) {\n        return this._readNumberValue(Buffer.prototype.readFloatLE, 4, offset);\n    }\n    /**\n     * Writes a FloatBE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeFloatBE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);\n    }\n    /**\n     * Inserts a FloatBE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertFloatBE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeFloatBE, 4, value, offset);\n    }\n    /**\n     * Writes a FloatLE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeFloatLE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);\n    }\n    /**\n     * Inserts a FloatLE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertFloatLE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeFloatLE, 4, value, offset);\n    }\n    // Double Floating Point\n    /**\n     * Reads an DoublEBE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readDoubleBE(offset) {\n        return this._readNumberValue(Buffer.prototype.readDoubleBE, 8, offset);\n    }\n    /**\n     * Reads an DoubleLE value from the current read position or an optionally provided offset.\n     *\n     * @param offset { Number } The offset to read data from (optional)\n     * @return { Number }\n     */\n    readDoubleLE(offset) {\n        return this._readNumberValue(Buffer.prototype.readDoubleLE, 8, offset);\n    }\n    /**\n     * Writes a DoubleBE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeDoubleBE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);\n    }\n    /**\n     * Inserts a DoubleBE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertDoubleBE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeDoubleBE, 8, value, offset);\n    }\n    /**\n     * Writes a DoubleLE value to the current write position (or at optional offset).\n     *\n     * @param value { Number } The value to write.\n     * @param offset { Number } The offset to write the value at.\n     *\n     * @return this\n     */\n    writeDoubleLE(value, offset) {\n        return this._writeNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);\n    }\n    /**\n     * Inserts a DoubleLE value at the given offset value.\n     *\n     * @param value { Number } The value to insert.\n     * @param offset { Number } The offset to insert the value at.\n     *\n     * @return this\n     */\n    insertDoubleLE(value, offset) {\n        return this._insertNumberValue(Buffer.prototype.writeDoubleLE, 8, value, offset);\n    }\n    // Strings\n    /**\n     * Reads a String from the current read position.\n     *\n     * @param arg1 { Number | String } The number of bytes to read as a String, or the BufferEncoding to use for\n     *             the string (Defaults to instance level encoding).\n     * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding).\n     *\n     * @return { String }\n     */\n    readString(arg1, encoding) {\n        let lengthVal;\n        // Length provided\n        if (typeof arg1 === 'number') {\n            utils_1.checkLengthValue(arg1);\n            lengthVal = Math.min(arg1, this.length - this._readOffset);\n        }\n        else {\n            encoding = arg1;\n            lengthVal = this.length - this._readOffset;\n        }\n        // Check encoding\n        if (typeof encoding !== 'undefined') {\n            utils_1.checkEncoding(encoding);\n        }\n        const value = this._buff.slice(this._readOffset, this._readOffset + lengthVal).toString(encoding || this._encoding);\n        this._readOffset += lengthVal;\n        return value;\n    }\n    /**\n     * Inserts a String\n     *\n     * @param value { String } The String value to insert.\n     * @param offset { Number } The offset to insert the string at.\n     * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).\n     *\n     * @return this\n     */\n    insertString(value, offset, encoding) {\n        utils_1.checkOffsetValue(offset);\n        return this._handleString(value, true, offset, encoding);\n    }\n    /**\n     * Writes a String\n     *\n     * @param value { String } The String value to write.\n     * @param arg2 { Number | String } The offset to write the string at, or the BufferEncoding to use.\n     * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).\n     *\n     * @return this\n     */\n    writeString(value, arg2, encoding) {\n        return this._handleString(value, false, arg2, encoding);\n    }\n    /**\n     * Reads a null-terminated String from the current read position.\n     *\n     * @param encoding { String } The BufferEncoding to use for the string (Defaults to instance level encoding).\n     *\n     * @return { String }\n     */\n    readStringNT(encoding) {\n        if (typeof encoding !== 'undefined') {\n            utils_1.checkEncoding(encoding);\n        }\n        // Set null character position to the end SmartBuffer instance.\n        let nullPos = this.length;\n        // Find next null character (if one is not found, default from above is used)\n        for (let i = this._readOffset; i < this.length; i++) {\n            if (this._buff[i] === 0x00) {\n                nullPos = i;\n                break;\n            }\n        }\n        // Read string value\n        const value = this._buff.slice(this._readOffset, nullPos);\n        // Increment internal Buffer read offset\n        this._readOffset = nullPos + 1;\n        return value.toString(encoding || this._encoding);\n    }\n    /**\n     * Inserts a null-terminated String.\n     *\n     * @param value { String } The String value to write.\n     * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use.\n     * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).\n     *\n     * @return this\n     */\n    insertStringNT(value, offset, encoding) {\n        utils_1.checkOffsetValue(offset);\n        // Write Values\n        this.insertString(value, offset, encoding);\n        this.insertUInt8(0x00, offset + value.length);\n        return this;\n    }\n    /**\n     * Writes a null-terminated String.\n     *\n     * @param value { String } The String value to write.\n     * @param arg2 { Number | String } The offset to write the string to, or the BufferEncoding to use.\n     * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).\n     *\n     * @return this\n     */\n    writeStringNT(value, arg2, encoding) {\n        // Write Values\n        this.writeString(value, arg2, encoding);\n        this.writeUInt8(0x00, typeof arg2 === 'number' ? arg2 + value.length : this.writeOffset);\n        return this;\n    }\n    // Buffers\n    /**\n     * Reads a Buffer from the internal read position.\n     *\n     * @param length { Number } The length of data to read as a Buffer.\n     *\n     * @return { Buffer }\n     */\n    readBuffer(length) {\n        if (typeof length !== 'undefined') {\n            utils_1.checkLengthValue(length);\n        }\n        const lengthVal = typeof length === 'number' ? length : this.length;\n        const endPoint = Math.min(this.length, this._readOffset + lengthVal);\n        // Read buffer value\n        const value = this._buff.slice(this._readOffset, endPoint);\n        // Increment internal Buffer read offset\n        this._readOffset = endPoint;\n        return value;\n    }\n    /**\n     * Writes a Buffer to the current write position.\n     *\n     * @param value { Buffer } The Buffer to write.\n     * @param offset { Number } The offset to write the Buffer to.\n     *\n     * @return this\n     */\n    insertBuffer(value, offset) {\n        utils_1.checkOffsetValue(offset);\n        return this._handleBuffer(value, true, offset);\n    }\n    /**\n     * Writes a Buffer to the current write position.\n     *\n     * @param value { Buffer } The Buffer to write.\n     * @param offset { Number } The offset to write the Buffer to.\n     *\n     * @return this\n     */\n    writeBuffer(value, offset) {\n        return this._handleBuffer(value, false, offset);\n    }\n    /**\n     * Reads a null-terminated Buffer from the current read poisiton.\n     *\n     * @return { Buffer }\n     */\n    readBufferNT() {\n        // Set null character position to the end SmartBuffer instance.\n        let nullPos = this.length;\n        // Find next null character (if one is not found, default from above is used)\n        for (let i = this._readOffset; i < this.length; i++) {\n            if (this._buff[i] === 0x00) {\n                nullPos = i;\n                break;\n            }\n        }\n        // Read value\n        const value = this._buff.slice(this._readOffset, nullPos);\n        // Increment internal Buffer read offset\n        this._readOffset = nullPos + 1;\n        return value;\n    }\n    /**\n     * Inserts a null-terminated Buffer.\n     *\n     * @param value { Buffer } The Buffer to write.\n     * @param offset { Number } The offset to write the Buffer to.\n     *\n     * @return this\n     */\n    insertBufferNT(value, offset) {\n        utils_1.checkOffsetValue(offset);\n        // Write Values\n        this.insertBuffer(value, offset);\n        this.insertUInt8(0x00, offset + value.length);\n        return this;\n    }\n    /**\n     * Writes a null-terminated Buffer.\n     *\n     * @param value { Buffer } The Buffer to write.\n     * @param offset { Number } The offset to write the Buffer to.\n     *\n     * @return this\n     */\n    writeBufferNT(value, offset) {\n        // Checks for valid numberic value;\n        if (typeof offset !== 'undefined') {\n            utils_1.checkOffsetValue(offset);\n        }\n        // Write Values\n        this.writeBuffer(value, offset);\n        this.writeUInt8(0x00, typeof offset === 'number' ? offset + value.length : this._writeOffset);\n        return this;\n    }\n    /**\n     * Clears the SmartBuffer instance to its original empty state.\n     */\n    clear() {\n        this._writeOffset = 0;\n        this._readOffset = 0;\n        this.length = 0;\n        return this;\n    }\n    /**\n     * Gets the remaining data left to be read from the SmartBuffer instance.\n     *\n     * @return { Number }\n     */\n    remaining() {\n        return this.length - this._readOffset;\n    }\n    /**\n     * Gets the current read offset value of the SmartBuffer instance.\n     *\n     * @return { Number }\n     */\n    get readOffset() {\n        return this._readOffset;\n    }\n    /**\n     * Sets the read offset value of the SmartBuffer instance.\n     *\n     * @param offset { Number } - The offset value to set.\n     */\n    set readOffset(offset) {\n        utils_1.checkOffsetValue(offset);\n        // Check for bounds.\n        utils_1.checkTargetOffset(offset, this);\n        this._readOffset = offset;\n    }\n    /**\n     * Gets the current write offset value of the SmartBuffer instance.\n     *\n     * @return { Number }\n     */\n    get writeOffset() {\n        return this._writeOffset;\n    }\n    /**\n     * Sets the write offset value of the SmartBuffer instance.\n     *\n     * @param offset { Number } - The offset value to set.\n     */\n    set writeOffset(offset) {\n        utils_1.checkOffsetValue(offset);\n        // Check for bounds.\n        utils_1.checkTargetOffset(offset, this);\n        this._writeOffset = offset;\n    }\n    /**\n     * Gets the currently set string encoding of the SmartBuffer instance.\n     *\n     * @return { BufferEncoding } The string Buffer encoding currently set.\n     */\n    get encoding() {\n        return this._encoding;\n    }\n    /**\n     * Sets the string encoding of the SmartBuffer instance.\n     *\n     * @param encoding { BufferEncoding } The string Buffer encoding to set.\n     */\n    set encoding(encoding) {\n        utils_1.checkEncoding(encoding);\n        this._encoding = encoding;\n    }\n    /**\n     * Gets the underlying internal Buffer. (This includes unmanaged data in the Buffer)\n     *\n     * @return { Buffer } The Buffer value.\n     */\n    get internalBuffer() {\n        return this._buff;\n    }\n    /**\n     * Gets the value of the internal managed Buffer (Includes managed data only)\n     *\n     * @param { Buffer }\n     */\n    toBuffer() {\n        return this._buff.slice(0, this.length);\n    }\n    /**\n     * Gets the String value of the internal managed Buffer\n     *\n     * @param encoding { String } The BufferEncoding to display the Buffer as (defaults to instance level encoding).\n     */\n    toString(encoding) {\n        const encodingVal = typeof encoding === 'string' ? encoding : this._encoding;\n        // Check for invalid encoding.\n        utils_1.checkEncoding(encodingVal);\n        return this._buff.toString(encodingVal, 0, this.length);\n    }\n    /**\n     * Destroys the SmartBuffer instance.\n     */\n    destroy() {\n        this.clear();\n        return this;\n    }\n    /**\n     * Handles inserting and writing strings.\n     *\n     * @param value { String } The String value to insert.\n     * @param isInsert { Boolean } True if inserting a string, false if writing.\n     * @param arg2 { Number | String } The offset to insert the string at, or the BufferEncoding to use.\n     * @param encoding { String } The BufferEncoding to use for writing strings (defaults to instance encoding).\n     */\n    _handleString(value, isInsert, arg3, encoding) {\n        let offsetVal = this._writeOffset;\n        let encodingVal = this._encoding;\n        // Check for offset\n        if (typeof arg3 === 'number') {\n            offsetVal = arg3;\n            // Check for encoding\n        }\n        else if (typeof arg3 === 'string') {\n            utils_1.checkEncoding(arg3);\n            encodingVal = arg3;\n        }\n        // Check for encoding (third param)\n        if (typeof encoding === 'string') {\n            utils_1.checkEncoding(encoding);\n            encodingVal = encoding;\n        }\n        // Calculate bytelength of string.\n        const byteLength = Buffer.byteLength(value, encodingVal);\n        // Ensure there is enough internal Buffer capacity.\n        if (isInsert) {\n            this.ensureInsertable(byteLength, offsetVal);\n        }\n        else {\n            this._ensureWriteable(byteLength, offsetVal);\n        }\n        // Write value\n        this._buff.write(value, offsetVal, byteLength, encodingVal);\n        // Increment internal Buffer write offset;\n        if (isInsert) {\n            this._writeOffset += byteLength;\n        }\n        else {\n            // If an offset was given, check to see if we wrote beyond the current writeOffset.\n            if (typeof arg3 === 'number') {\n                this._writeOffset = Math.max(this._writeOffset, offsetVal + byteLength);\n            }\n            else {\n                // If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.\n                this._writeOffset += byteLength;\n            }\n        }\n        return this;\n    }\n    /**\n     * Handles writing or insert of a Buffer.\n     *\n     * @param value { Buffer } The Buffer to write.\n     * @param offset { Number } The offset to write the Buffer to.\n     */\n    _handleBuffer(value, isInsert, offset) {\n        const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;\n        // Ensure there is enough internal Buffer capacity.\n        if (isInsert) {\n            this.ensureInsertable(value.length, offsetVal);\n        }\n        else {\n            this._ensureWriteable(value.length, offsetVal);\n        }\n        // Write buffer value\n        value.copy(this._buff, offsetVal);\n        // Increment internal Buffer write offset;\n        if (isInsert) {\n            this._writeOffset += value.length;\n        }\n        else {\n            // If an offset was given, check to see if we wrote beyond the current writeOffset.\n            if (typeof offset === 'number') {\n                this._writeOffset = Math.max(this._writeOffset, offsetVal + value.length);\n            }\n            else {\n                // If no offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.\n                this._writeOffset += value.length;\n            }\n        }\n        return this;\n    }\n    /**\n     * Ensures that the internal Buffer is large enough to read data.\n     *\n     * @param length { Number } The length of the data that needs to be read.\n     * @param offset { Number } The offset of the data that needs to be read.\n     */\n    ensureReadable(length, offset) {\n        // Offset value defaults to managed read offset.\n        let offsetVal = this._readOffset;\n        // If an offset was provided, use it.\n        if (typeof offset !== 'undefined') {\n            // Checks for valid numberic value;\n            utils_1.checkOffsetValue(offset);\n            // Overide with custom offset.\n            offsetVal = offset;\n        }\n        // Checks if offset is below zero, or the offset+length offset is beyond the total length of the managed data.\n        if (offsetVal < 0 || offsetVal + length > this.length) {\n            throw new Error(utils_1.ERRORS.INVALID_READ_BEYOND_BOUNDS);\n        }\n    }\n    /**\n     * Ensures that the internal Buffer is large enough to insert data.\n     *\n     * @param dataLength { Number } The length of the data that needs to be written.\n     * @param offset { Number } The offset of the data to be written.\n     */\n    ensureInsertable(dataLength, offset) {\n        // Checks for valid numberic value;\n        utils_1.checkOffsetValue(offset);\n        // Ensure there is enough internal Buffer capacity.\n        this._ensureCapacity(this.length + dataLength);\n        // If an offset was provided and its not the very end of the buffer, copy data into appropriate location in regards to the offset.\n        if (offset < this.length) {\n            this._buff.copy(this._buff, offset + dataLength, offset, this._buff.length);\n        }\n        // Adjust tracked smart buffer length\n        if (offset + dataLength > this.length) {\n            this.length = offset + dataLength;\n        }\n        else {\n            this.length += dataLength;\n        }\n    }\n    /**\n     * Ensures that the internal Buffer is large enough to write data.\n     *\n     * @param dataLength { Number } The length of the data that needs to be written.\n     * @param offset { Number } The offset of the data to be written (defaults to writeOffset).\n     */\n    _ensureWriteable(dataLength, offset) {\n        const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;\n        // Ensure enough capacity to write data.\n        this._ensureCapacity(offsetVal + dataLength);\n        // Adjust SmartBuffer length (if offset + length is larger than managed length, adjust length)\n        if (offsetVal + dataLength > this.length) {\n            this.length = offsetVal + dataLength;\n        }\n    }\n    /**\n     * Ensures that the internal Buffer is large enough to write at least the given amount of data.\n     *\n     * @param minLength { Number } The minimum length of the data needs to be written.\n     */\n    _ensureCapacity(minLength) {\n        const oldLength = this._buff.length;\n        if (minLength > oldLength) {\n            let data = this._buff;\n            let newLength = (oldLength * 3) / 2 + 1;\n            if (newLength < minLength) {\n                newLength = minLength;\n            }\n            this._buff = Buffer.allocUnsafe(newLength);\n            data.copy(this._buff, 0, 0, oldLength);\n        }\n    }\n    /**\n     * Reads a numeric number value using the provided function.\n     *\n     * @typeparam T { number | bigint } The type of the value to be read\n     *\n     * @param func { Function(offset: number) => number } The function to read data on the internal Buffer with.\n     * @param byteSize { Number } The number of bytes read.\n     * @param offset { Number } The offset to read from (optional). When this is not provided, the managed readOffset is used instead.\n     *\n     * @returns { T } the number value\n     */\n    _readNumberValue(func, byteSize, offset) {\n        this.ensureReadable(byteSize, offset);\n        // Call Buffer.readXXXX();\n        const value = func.call(this._buff, typeof offset === 'number' ? offset : this._readOffset);\n        // Adjust internal read offset if an optional read offset was not provided.\n        if (typeof offset === 'undefined') {\n            this._readOffset += byteSize;\n        }\n        return value;\n    }\n    /**\n     * Inserts a numeric number value based on the given offset and value.\n     *\n     * @typeparam T { number | bigint } The type of the value to be written\n     *\n     * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with.\n     * @param byteSize { Number } The number of bytes written.\n     * @param value { T } The number value to write.\n     * @param offset { Number } the offset to write the number at (REQUIRED).\n     *\n     * @returns SmartBuffer this buffer\n     */\n    _insertNumberValue(func, byteSize, value, offset) {\n        // Check for invalid offset values.\n        utils_1.checkOffsetValue(offset);\n        // Ensure there is enough internal Buffer capacity. (raw offset is passed)\n        this.ensureInsertable(byteSize, offset);\n        // Call buffer.writeXXXX();\n        func.call(this._buff, value, offset);\n        // Adjusts internally managed write offset.\n        this._writeOffset += byteSize;\n        return this;\n    }\n    /**\n     * Writes a numeric number value based on the given offset and value.\n     *\n     * @typeparam T { number | bigint } The type of the value to be written\n     *\n     * @param func { Function(offset: T, offset?) => number} The function to write data on the internal Buffer with.\n     * @param byteSize { Number } The number of bytes written.\n     * @param value { T } The number value to write.\n     * @param offset { Number } the offset to write the number at (REQUIRED).\n     *\n     * @returns SmartBuffer this buffer\n     */\n    _writeNumberValue(func, byteSize, value, offset) {\n        // If an offset was provided, validate it.\n        if (typeof offset === 'number') {\n            // Check if we're writing beyond the bounds of the managed data.\n            if (offset < 0) {\n                throw new Error(utils_1.ERRORS.INVALID_WRITE_BEYOND_BOUNDS);\n            }\n            utils_1.checkOffsetValue(offset);\n        }\n        // Default to writeOffset if no offset value was given.\n        const offsetVal = typeof offset === 'number' ? offset : this._writeOffset;\n        // Ensure there is enough internal Buffer capacity. (raw offset is passed)\n        this._ensureWriteable(byteSize, offsetVal);\n        func.call(this._buff, value, offsetVal);\n        // If an offset was given, check to see if we wrote beyond the current writeOffset.\n        if (typeof offset === 'number') {\n            this._writeOffset = Math.max(this._writeOffset, offsetVal + byteSize);\n        }\n        else {\n            // If no numeric offset was given, we wrote to the end of the SmartBuffer so increment writeOffset.\n            this._writeOffset += byteSize;\n        }\n        return this;\n    }\n}\nexports.SmartBuffer = SmartBuffer;\n//# sourceMappingURL=smartbuffer.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.getLength = exports.decode = exports.encode = void 0;\nvar BN = require(\"bn.js\");\n/**\n * RLP Encoding based on: https://github.com/ethereum/wiki/wiki/%5BEnglish%5D-RLP\n * This function takes in a data, convert it to buffer if not, and a length for recursion\n * @param input - will be converted to buffer\n * @returns returns buffer of encoded data\n **/\nfunction encode(input) {\n    if (Array.isArray(input)) {\n        var output = [];\n        for (var i = 0; i < input.length; i++) {\n            output.push(encode(input[i]));\n        }\n        var buf = Buffer.concat(output);\n        return Buffer.concat([encodeLength(buf.length, 192), buf]);\n    }\n    else {\n        var inputBuf = toBuffer(input);\n        return inputBuf.length === 1 && inputBuf[0] < 128\n            ? inputBuf\n            : Buffer.concat([encodeLength(inputBuf.length, 128), inputBuf]);\n    }\n}\nexports.encode = encode;\n/**\n * Parse integers. Check if there is no leading zeros\n * @param v The value to parse\n * @param base The base to parse the integer into\n */\nfunction safeParseInt(v, base) {\n    if (v.slice(0, 2) === '00') {\n        throw new Error('invalid RLP: extra zeros');\n    }\n    return parseInt(v, base);\n}\nfunction encodeLength(len, offset) {\n    if (len < 56) {\n        return Buffer.from([len + offset]);\n    }\n    else {\n        var hexLength = intToHex(len);\n        var lLength = hexLength.length / 2;\n        var firstByte = intToHex(offset + 55 + lLength);\n        return Buffer.from(firstByte + hexLength, 'hex');\n    }\n}\nfunction decode(input, stream) {\n    if (stream === void 0) { stream = false; }\n    if (!input || input.length === 0) {\n        return Buffer.from([]);\n    }\n    var inputBuffer = toBuffer(input);\n    var decoded = _decode(inputBuffer);\n    if (stream) {\n        return decoded;\n    }\n    if (decoded.remainder.length !== 0) {\n        throw new Error('invalid remainder');\n    }\n    return decoded.data;\n}\nexports.decode = decode;\n/**\n * Get the length of the RLP input\n * @param input\n * @returns The length of the input or an empty Buffer if no input\n */\nfunction getLength(input) {\n    if (!input || input.length === 0) {\n        return Buffer.from([]);\n    }\n    var inputBuffer = toBuffer(input);\n    var firstByte = inputBuffer[0];\n    if (firstByte <= 0x7f) {\n        return inputBuffer.length;\n    }\n    else if (firstByte <= 0xb7) {\n        return firstByte - 0x7f;\n    }\n    else if (firstByte <= 0xbf) {\n        return firstByte - 0xb6;\n    }\n    else if (firstByte <= 0xf7) {\n        // a list between  0-55 bytes long\n        return firstByte - 0xbf;\n    }\n    else {\n        // a list  over 55 bytes long\n        var llength = firstByte - 0xf6;\n        var length = safeParseInt(inputBuffer.slice(1, llength).toString('hex'), 16);\n        return llength + length;\n    }\n}\nexports.getLength = getLength;\n/** Decode an input with RLP */\nfunction _decode(input) {\n    var length, llength, data, innerRemainder, d;\n    var decoded = [];\n    var firstByte = input[0];\n    if (firstByte <= 0x7f) {\n        // a single byte whose value is in the [0x00, 0x7f] range, that byte is its own RLP encoding.\n        return {\n            data: input.slice(0, 1),\n            remainder: input.slice(1),\n        };\n    }\n    else if (firstByte <= 0xb7) {\n        // string is 0-55 bytes long. A single byte with value 0x80 plus the length of the string followed by the string\n        // The range of the first byte is [0x80, 0xb7]\n        length = firstByte - 0x7f;\n        // set 0x80 null to 0\n        if (firstByte === 0x80) {\n            data = Buffer.from([]);\n        }\n        else {\n            data = input.slice(1, length);\n        }\n        if (length === 2 && data[0] < 0x80) {\n            throw new Error('invalid rlp encoding: byte must be less 0x80');\n        }\n        return {\n            data: data,\n            remainder: input.slice(length),\n        };\n    }\n    else if (firstByte <= 0xbf) {\n        // string is greater than 55 bytes long. A single byte with the value (0xb7 plus the length of the length),\n        // followed by the length, followed by the string\n        llength = firstByte - 0xb6;\n        if (input.length - 1 < llength) {\n            throw new Error('invalid RLP: not enough bytes for string length');\n        }\n        length = safeParseInt(input.slice(1, llength).toString('hex'), 16);\n        if (length <= 55) {\n            throw new Error('invalid RLP: expected string length to be greater than 55');\n        }\n        data = input.slice(llength, length + llength);\n        if (data.length < length) {\n            throw new Error('invalid RLP: not enough bytes for string');\n        }\n        return {\n            data: data,\n            remainder: input.slice(length + llength),\n        };\n    }\n    else if (firstByte <= 0xf7) {\n        // a list between  0-55 bytes long\n        length = firstByte - 0xbf;\n        innerRemainder = input.slice(1, length);\n        while (innerRemainder.length) {\n            d = _decode(innerRemainder);\n            decoded.push(d.data);\n            innerRemainder = d.remainder;\n        }\n        return {\n            data: decoded,\n            remainder: input.slice(length),\n        };\n    }\n    else {\n        // a list  over 55 bytes long\n        llength = firstByte - 0xf6;\n        length = safeParseInt(input.slice(1, llength).toString('hex'), 16);\n        var totalLength = llength + length;\n        if (totalLength > input.length) {\n            throw new Error('invalid rlp: total length is larger than the data');\n        }\n        innerRemainder = input.slice(llength, totalLength);\n        if (innerRemainder.length === 0) {\n            throw new Error('invalid rlp, List has a invalid length');\n        }\n        while (innerRemainder.length) {\n            d = _decode(innerRemainder);\n            decoded.push(d.data);\n            innerRemainder = d.remainder;\n        }\n        return {\n            data: decoded,\n            remainder: input.slice(totalLength),\n        };\n    }\n}\n/** Check if a string is prefixed by 0x */\nfunction isHexPrefixed(str) {\n    return str.slice(0, 2) === '0x';\n}\n/** Removes 0x from a given String */\nfunction stripHexPrefix(str) {\n    if (typeof str !== 'string') {\n        return str;\n    }\n    return isHexPrefixed(str) ? str.slice(2) : str;\n}\n/** Transform an integer into its hexadecimal value */\nfunction intToHex(integer) {\n    if (integer < 0) {\n        throw new Error('Invalid integer as argument, must be unsigned!');\n    }\n    var hex = integer.toString(16);\n    return hex.length % 2 ? \"0\" + hex : hex;\n}\n/** Pad a string to be even */\nfunction padToEven(a) {\n    return a.length % 2 ? \"0\" + a : a;\n}\n/** Transform an integer into a Buffer */\nfunction intToBuffer(integer) {\n    var hex = intToHex(integer);\n    return Buffer.from(hex, 'hex');\n}\n/** Transform anything into a Buffer */\nfunction toBuffer(v) {\n    if (!Buffer.isBuffer(v)) {\n        if (typeof v === 'string') {\n            if (isHexPrefixed(v)) {\n                return Buffer.from(padToEven(stripHexPrefix(v)), 'hex');\n            }\n            else {\n                return Buffer.from(v);\n            }\n        }\n        else if (typeof v === 'number' || typeof v === 'bigint') {\n            if (!v) {\n                return Buffer.from([]);\n            }\n            else {\n                return intToBuffer(v);\n            }\n        }\n        else if (v === null || v === undefined) {\n            return Buffer.from([]);\n        }\n        else if (v instanceof Uint8Array) {\n            return Buffer.from(v);\n        }\n        else if (BN.isBN(v)) {\n            // converts a BN to a Buffer\n            return Buffer.from(v.toArray());\n        }\n        else {\n            throw new Error('invalid type');\n        }\n    }\n    return v;\n}\n//# sourceMappingURL=index.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.ecdhUnsafe = exports.ecdh = exports.recover = exports.verify = exports.sign = exports.signatureImportLax = exports.signatureImport = exports.signatureExport = exports.signatureNormalize = exports.publicKeyCombine = exports.publicKeyTweakMul = exports.publicKeyTweakAdd = exports.publicKeyVerify = exports.publicKeyConvert = exports.publicKeyCreate = exports.privateKeyTweakMul = exports.privateKeyTweakAdd = exports.privateKeyModInverse = exports.privateKeyNegate = exports.privateKeyImport = exports.privateKeyExport = exports.privateKeyVerify = void 0;\nvar secp256k1 = require('ethereum-cryptography/secp256k1');\nvar secp256k1v3 = require('./secp256k1v3-lib/index');\nvar der = require('./secp256k1v3-lib/der');\n/**\n * Verify an ECDSA privateKey\n * @method privateKeyVerify\n * @param {Buffer} privateKey\n * @return {boolean}\n */\nexports.privateKeyVerify = function (privateKey) {\n    // secp256k1 v4 version throws when privateKey length is not 32\n    if (privateKey.length !== 32) {\n        return false;\n    }\n    return secp256k1.privateKeyVerify(Uint8Array.from(privateKey));\n};\n/**\n * Export a privateKey in DER format\n * @method privateKeyExport\n * @param {Buffer} privateKey\n * @param {boolean} compressed\n * @return {boolean}\n */\nexports.privateKeyExport = function (privateKey, compressed) {\n    // secp256k1 v4 version throws when privateKey length is not 32\n    if (privateKey.length !== 32) {\n        throw new RangeError('private key length is invalid');\n    }\n    var publicKey = secp256k1v3.privateKeyExport(privateKey, compressed);\n    return der.privateKeyExport(privateKey, publicKey, compressed);\n};\n/**\n * Import a privateKey in DER format\n * @method privateKeyImport\n * @param {Buffer} privateKey\n * @return {Buffer}\n */\nexports.privateKeyImport = function (privateKey) {\n    // privateKeyImport method is not part of secp256k1 v4 package\n    // this implementation is based on v3\n    privateKey = der.privateKeyImport(privateKey);\n    if (privateKey !== null && privateKey.length === 32 && exports.privateKeyVerify(privateKey)) {\n        return privateKey;\n    }\n    throw new Error(\"couldn't import from DER format\");\n};\n/**\n * Negate a privateKey by subtracting it from the order of the curve's base point\n * @method privateKeyNegate\n * @param {Buffer} privateKey\n * @return {Buffer}\n */\nexports.privateKeyNegate = function (privateKey) {\n    return Buffer.from(secp256k1.privateKeyNegate(Uint8Array.from(privateKey)));\n};\n/**\n * Compute the inverse of a privateKey (modulo the order of the curve's base point).\n * @method privateKeyModInverse\n * @param {Buffer} privateKey\n * @return {Buffer}\n */\nexports.privateKeyModInverse = function (privateKey) {\n    if (privateKey.length !== 32) {\n        throw new Error('private key length is invalid');\n    }\n    return Buffer.from(secp256k1v3.privateKeyModInverse(Uint8Array.from(privateKey)));\n};\n/**\n * Tweak a privateKey by adding tweak to it.\n * @method privateKeyTweakAdd\n * @param {Buffer} privateKey\n * @param {Buffer} tweak\n * @return {Buffer}\n */\nexports.privateKeyTweakAdd = function (privateKey, tweak) {\n    return Buffer.from(secp256k1.privateKeyTweakAdd(Uint8Array.from(privateKey), tweak));\n};\n/**\n * Tweak a privateKey by multiplying it by a tweak.\n * @method privateKeyTweakMul\n * @param {Buffer} privateKey\n * @param {Buffer} tweak\n * @return {Buffer}\n */\nexports.privateKeyTweakMul = function (privateKey, tweak) {\n    return Buffer.from(secp256k1.privateKeyTweakMul(Uint8Array.from(privateKey), Uint8Array.from(tweak)));\n};\n/**\n * Compute the public key for a privateKey.\n * @method publicKeyCreate\n * @param {Buffer} privateKey\n * @param {boolean} compressed\n * @return {Buffer}\n */\nexports.publicKeyCreate = function (privateKey, compressed) {\n    return Buffer.from(secp256k1.publicKeyCreate(Uint8Array.from(privateKey), compressed));\n};\n/**\n * Convert a publicKey to compressed or uncompressed form.\n * @method publicKeyConvert\n * @param {Buffer} publicKey\n * @param {boolean} compressed\n * @return {Buffer}\n */\nexports.publicKeyConvert = function (publicKey, compressed) {\n    return Buffer.from(secp256k1.publicKeyConvert(Uint8Array.from(publicKey), compressed));\n};\n/**\n * Verify an ECDSA publicKey.\n * @method publicKeyVerify\n * @param {Buffer} publicKey\n * @return {boolean}\n */\nexports.publicKeyVerify = function (publicKey) {\n    // secp256k1 v4 version throws when publicKey length is not 33 or 65\n    if (publicKey.length !== 33 && publicKey.length !== 65) {\n        return false;\n    }\n    return secp256k1.publicKeyVerify(Uint8Array.from(publicKey));\n};\n/**\n * Tweak a publicKey by adding tweak times the generator to it.\n * @method publicKeyTweakAdd\n * @param {Buffer} publicKey\n * @param {Buffer} tweak\n * @param {boolean} compressed\n * @return {Buffer}\n */\nexports.publicKeyTweakAdd = function (publicKey, tweak, compressed) {\n    return Buffer.from(secp256k1.publicKeyTweakAdd(Uint8Array.from(publicKey), Uint8Array.from(tweak), compressed));\n};\n/**\n * Tweak a publicKey by multiplying it by a tweak value\n * @method publicKeyTweakMul\n * @param {Buffer} publicKey\n * @param {Buffer} tweak\n * @param {boolean} compressed\n * @return {Buffer}\n */\nexports.publicKeyTweakMul = function (publicKey, tweak, compressed) {\n    return Buffer.from(secp256k1.publicKeyTweakMul(Uint8Array.from(publicKey), Uint8Array.from(tweak), compressed));\n};\n/**\n * Add a given publicKeys together.\n * @method publicKeyCombine\n * @param {Array<Buffer>} publicKeys\n * @param {boolean} compressed\n * @return {Buffer}\n */\nexports.publicKeyCombine = function (publicKeys, compressed) {\n    var keys = [];\n    publicKeys.forEach(function (publicKey) {\n        keys.push(Uint8Array.from(publicKey));\n    });\n    return Buffer.from(secp256k1.publicKeyCombine(keys, compressed));\n};\n/**\n * Convert a signature to a normalized lower-S form.\n * @method signatureNormalize\n * @param {Buffer} signature\n * @return {Buffer}\n */\nexports.signatureNormalize = function (signature) {\n    return Buffer.from(secp256k1.signatureNormalize(Uint8Array.from(signature)));\n};\n/**\n * Serialize an ECDSA signature in DER format.\n * @method signatureExport\n * @param {Buffer} signature\n * @return {Buffer}\n */\nexports.signatureExport = function (signature) {\n    return Buffer.from(secp256k1.signatureExport(Uint8Array.from(signature)));\n};\n/**\n * Parse a DER ECDSA signature (follow by [BIP66](https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki)).\n * @method signatureImport\n * @param {Buffer} signature\n * @return {Buffer}\n */\nexports.signatureImport = function (signature) {\n    return Buffer.from(secp256k1.signatureImport(Uint8Array.from(signature)));\n};\n/**\n * Parse a DER ECDSA signature (not follow by [BIP66](https://github.com/bitcoin/bips/blob/master/bip-0066.mediawiki)).\n * @method signatureImportLax\n * @param {Buffer} signature\n * @return {Buffer}\n */\nexports.signatureImportLax = function (signature) {\n    // signatureImportLax method is not part of secp256k1 v4 package\n    // this implementation is based on v3\n    // ensure that signature is greater than 0\n    if (signature.length === 0) {\n        throw new RangeError('signature length is invalid');\n    }\n    var sigObj = der.signatureImportLax(signature);\n    if (sigObj === null) {\n        throw new Error(\"couldn't parse DER signature\");\n    }\n    return secp256k1v3.signatureImport(sigObj);\n};\n/**\n * Create an ECDSA signature. Always return low-S signature.\n * @method sign\n * @param {Buffer} message\n * @param {Buffer} privateKey\n * @param {Object} options\n * @return {Buffer}\n */\nexports.sign = function (message, privateKey, options) {\n    if (options === null) {\n        throw new TypeError('options should be an Object');\n    }\n    var signOptions = undefined;\n    if (options) {\n        signOptions = {};\n        if (options.data === null) {\n            // validate option.data length\n            throw new TypeError('options.data should be a Buffer');\n        }\n        if (options.data) {\n            if (options.data.length != 32) {\n                throw new RangeError('options.data length is invalid');\n            }\n            signOptions.data = new Uint8Array(options.data);\n        }\n        if (options.noncefn === null) {\n            throw new TypeError('options.noncefn should be a Function');\n        }\n        if (options.noncefn) {\n            // convert option.noncefn function signature\n            signOptions.noncefn = function (message, privateKey, algo, data, attempt) {\n                var bufferAlgo = algo != null ? Buffer.from(algo) : null;\n                var bufferData = data != null ? Buffer.from(data) : null;\n                var buffer = Buffer.from('');\n                if (options.noncefn) {\n                    buffer = options.noncefn(Buffer.from(message), Buffer.from(privateKey), bufferAlgo, bufferData, attempt);\n                }\n                return new Uint8Array(buffer);\n            };\n        }\n    }\n    var sig = secp256k1.ecdsaSign(Uint8Array.from(message), Uint8Array.from(privateKey), signOptions);\n    return {\n        signature: Buffer.from(sig.signature),\n        recovery: sig.recid,\n    };\n};\n/**\n * Verify an ECDSA signature.\n * @method verify\n * @param {Buffer} message\n * @param {Buffer} signature\n * @param {Buffer} publicKey\n * @return {boolean}\n */\nexports.verify = function (message, signature, publicKey) {\n    return secp256k1.ecdsaVerify(Uint8Array.from(signature), Uint8Array.from(message), publicKey);\n};\n/**\n * Recover an ECDSA public key from a signature.\n * @method recover\n * @param {Buffer} message\n * @param {Buffer} signature\n * @param {Number} recid\n * @param {boolean} compressed\n * @return {Buffer}\n */\nexports.recover = function (message, signature, recid, compressed) {\n    return Buffer.from(secp256k1.ecdsaRecover(Uint8Array.from(signature), recid, Uint8Array.from(message), compressed));\n};\n/**\n * Compute an EC Diffie-Hellman secret and applied sha256 to compressed public key.\n * @method ecdh\n * @param {Buffer} publicKey\n * @param {Buffer} privateKey\n * @return {Buffer}\n */\nexports.ecdh = function (publicKey, privateKey) {\n    // note: secp256k1 v3 doesn't allow optional parameter\n    return Buffer.from(secp256k1.ecdh(Uint8Array.from(publicKey), Uint8Array.from(privateKey), {}));\n};\nexports.ecdhUnsafe = function (publicKey, privateKey, compressed) {\n    // ecdhUnsafe method is not part of secp256k1 v4 package\n    // this implementation is based on v3\n    // ensure valid publicKey length\n    if (publicKey.length !== 33 && publicKey.length !== 65) {\n        throw new RangeError('public key length is invalid');\n    }\n    // ensure valid privateKey length\n    if (privateKey.length !== 32) {\n        throw new RangeError('private key length is invalid');\n    }\n    return Buffer.from(secp256k1v3.ecdhUnsafe(Uint8Array.from(publicKey), Uint8Array.from(privateKey), compressed));\n};\n//# sourceMappingURL=secp256k1v3-adapter.js.map","\"use strict\";\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nfunction __export(m) {\n    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];\n}\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar secp256k1_1 = require(\"secp256k1\");\nvar random_1 = require(\"./random\");\nvar SECP256K1_PRIVATE_KEY_SIZE = 32;\nfunction createPrivateKey() {\n    return __awaiter(this, void 0, void 0, function () {\n        var pk;\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0:\n                    if (!true) return [3 /*break*/, 2];\n                    return [4 /*yield*/, random_1.getRandomBytes(SECP256K1_PRIVATE_KEY_SIZE)];\n                case 1:\n                    pk = _a.sent();\n                    if (secp256k1_1.privateKeyVerify(pk)) {\n                        return [2 /*return*/, pk];\n                    }\n                    return [3 /*break*/, 0];\n                case 2: return [2 /*return*/];\n            }\n        });\n    });\n}\nexports.createPrivateKey = createPrivateKey;\nfunction createPrivateKeySync() {\n    while (true) {\n        var pk = random_1.getRandomBytesSync(SECP256K1_PRIVATE_KEY_SIZE);\n        if (secp256k1_1.privateKeyVerify(pk)) {\n            return pk;\n        }\n    }\n}\nexports.createPrivateKeySync = createPrivateKeySync;\n__export(require(\"secp256k1\"));\n//# sourceMappingURL=secp256k1.js.map","'use strict';\n\nvar curves = exports;\n\nvar hash = require('hash.js');\nvar curve = require('./curve');\nvar utils = require('./utils');\n\nvar assert = utils.assert;\n\nfunction PresetCurve(options) {\n  if (options.type === 'short')\n    this.curve = new curve.short(options);\n  else if (options.type === 'edwards')\n    this.curve = new curve.edwards(options);\n  else\n    this.curve = new curve.mont(options);\n  this.g = this.curve.g;\n  this.n = this.curve.n;\n  this.hash = options.hash;\n\n  assert(this.g.validate(), 'Invalid curve');\n  assert(this.g.mul(this.n).isInfinity(), 'Invalid curve, G*N != O');\n}\ncurves.PresetCurve = PresetCurve;\n\nfunction defineCurve(name, options) {\n  Object.defineProperty(curves, name, {\n    configurable: true,\n    enumerable: true,\n    get: function() {\n      var curve = new PresetCurve(options);\n      Object.defineProperty(curves, name, {\n        configurable: true,\n        enumerable: true,\n        value: curve,\n      });\n      return curve;\n    },\n  });\n}\n\ndefineCurve('p192', {\n  type: 'short',\n  prime: 'p192',\n  p: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff fffffffc',\n  b: '64210519 e59c80e7 0fa7e9ab 72243049 feb8deec c146b9b1',\n  n: 'ffffffff ffffffff ffffffff 99def836 146bc9b1 b4d22831',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '188da80e b03090f6 7cbf20eb 43a18800 f4ff0afd 82ff1012',\n    '07192b95 ffc8da78 631011ed 6b24cdd5 73f977a1 1e794811',\n  ],\n});\n\ndefineCurve('p224', {\n  type: 'short',\n  prime: 'p224',\n  p: 'ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001',\n  a: 'ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff fffffffe',\n  b: 'b4050a85 0c04b3ab f5413256 5044b0b7 d7bfd8ba 270b3943 2355ffb4',\n  n: 'ffffffff ffffffff ffffffff ffff16a2 e0b8f03e 13dd2945 5c5c2a3d',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    'b70e0cbd 6bb4bf7f 321390b9 4a03c1d3 56c21122 343280d6 115c1d21',\n    'bd376388 b5f723fb 4c22dfe6 cd4375a0 5a074764 44d58199 85007e34',\n  ],\n});\n\ndefineCurve('p256', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff ffffffff',\n  a: 'ffffffff 00000001 00000000 00000000 00000000 ffffffff ffffffff fffffffc',\n  b: '5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b',\n  n: 'ffffffff 00000000 ffffffff ffffffff bce6faad a7179e84 f3b9cac2 fc632551',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296',\n    '4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5',\n  ],\n});\n\ndefineCurve('p384', {\n  type: 'short',\n  prime: null,\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'fffffffe ffffffff 00000000 00000000 ffffffff',\n  a: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'fffffffe ffffffff 00000000 00000000 fffffffc',\n  b: 'b3312fa7 e23ee7e4 988e056b e3f82d19 181d9c6e fe814112 0314088f ' +\n     '5013875a c656398d 8a2ed19d 2a85c8ed d3ec2aef',\n  n: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff c7634d81 ' +\n     'f4372ddf 581a0db2 48b0a77a ecec196a ccc52973',\n  hash: hash.sha384,\n  gRed: false,\n  g: [\n    'aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98 59f741e0 82542a38 ' +\n    '5502f25d bf55296c 3a545e38 72760ab7',\n    '3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c e9da3113 b5f0b8c0 ' +\n    '0a60b1ce 1d7e819d 7a431d7c 90ea0e5f',\n  ],\n});\n\ndefineCurve('p521', {\n  type: 'short',\n  prime: null,\n  p: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff',\n  a: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff ffffffff ffffffff fffffffc',\n  b: '00000051 953eb961 8e1c9a1f 929a21a0 b68540ee a2da725b ' +\n     '99b315f3 b8b48991 8ef109e1 56193951 ec7e937b 1652c0bd ' +\n     '3bb1bf07 3573df88 3d2c34f1 ef451fd4 6b503f00',\n  n: '000001ff ffffffff ffffffff ffffffff ffffffff ffffffff ' +\n     'ffffffff ffffffff fffffffa 51868783 bf2f966b 7fcc0148 ' +\n     'f709a5d0 3bb5c9b8 899c47ae bb6fb71e 91386409',\n  hash: hash.sha512,\n  gRed: false,\n  g: [\n    '000000c6 858e06b7 0404e9cd 9e3ecb66 2395b442 9c648139 ' +\n    '053fb521 f828af60 6b4d3dba a14b5e77 efe75928 fe1dc127 ' +\n    'a2ffa8de 3348b3c1 856a429b f97e7e31 c2e5bd66',\n    '00000118 39296a78 9a3bc004 5c8a5fb4 2c7d1bd9 98f54449 ' +\n    '579b4468 17afbd17 273e662c 97ee7299 5ef42640 c550b901 ' +\n    '3fad0761 353c7086 a272c240 88be9476 9fd16650',\n  ],\n});\n\ndefineCurve('curve25519', {\n  type: 'mont',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '76d06',\n  b: '1',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '9',\n  ],\n});\n\ndefineCurve('ed25519', {\n  type: 'edwards',\n  prime: 'p25519',\n  p: '7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed',\n  a: '-1',\n  c: '1',\n  // -121665 * (121666^(-1)) (mod P)\n  d: '52036cee2b6ffe73 8cc740797779e898 00700a4d4141d8ab 75eb4dca135978a3',\n  n: '1000000000000000 0000000000000000 14def9dea2f79cd6 5812631a5cf5d3ed',\n  hash: hash.sha256,\n  gRed: false,\n  g: [\n    '216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a',\n\n    // 4/5\n    '6666666666666666666666666666666666666666666666666666666666666658',\n  ],\n});\n\nvar pre;\ntry {\n  pre = require('./precomputed/secp256k1');\n} catch (e) {\n  pre = undefined;\n}\n\ndefineCurve('secp256k1', {\n  type: 'short',\n  prime: 'k256',\n  p: 'ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f',\n  a: '0',\n  b: '7',\n  n: 'ffffffff ffffffff ffffffff fffffffe baaedce6 af48a03b bfd25e8c d0364141',\n  h: '1',\n  hash: hash.sha256,\n\n  // Precomputed endomorphism\n  beta: '7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee',\n  lambda: '5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72',\n  basis: [\n    {\n      a: '3086d221a7d46bcde86c90e49284eb15',\n      b: '-e4437ed6010e88286f547fa90abfe4c3',\n    },\n    {\n      a: '114ca50f7a8e2f3f657c1108d9d44cfd8',\n      b: '3086d221a7d46bcde86c90e49284eb15',\n    },\n  ],\n\n  gRed: false,\n  g: [\n    '79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',\n    '483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',\n    pre,\n  ],\n});\n","var hash = exports;\n\nhash.utils = require('./hash/utils');\nhash.common = require('./hash/common');\nhash.sha = require('./hash/sha');\nhash.ripemd = require('./hash/ripemd');\nhash.hmac = require('./hash/hmac');\n\n// Proxy hash functions to the main object\nhash.sha1 = hash.sha.sha1;\nhash.sha256 = hash.sha.sha256;\nhash.sha224 = hash.sha.sha224;\nhash.sha384 = hash.sha.sha384;\nhash.sha512 = hash.sha.sha512;\nhash.ripemd160 = hash.ripemd.ripemd160;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.rlphash = exports.ripemd160 = exports.sha256 = exports.keccak256 = exports.keccak = void 0;\nvar _a = require('ethereum-cryptography/keccak'), keccak224 = _a.keccak224, keccak384 = _a.keccak384, k256 = _a.keccak256, keccak512 = _a.keccak512;\nvar createHash = require('create-hash');\nvar ethjsUtil = require('ethjs-util');\nvar rlp = require(\"rlp\");\nvar bytes_1 = require(\"./bytes\");\n/**\n * Creates Keccak hash of the input\n * @param a The input data (Buffer|Array|String|Number) If the string is a 0x-prefixed hex value\n * it's interpreted as hexadecimal, otherwise as utf8.\n * @param bits The Keccak width\n */\nexports.keccak = function (a, bits) {\n    if (bits === void 0) { bits = 256; }\n    if (typeof a === 'string' && !ethjsUtil.isHexString(a)) {\n        a = Buffer.from(a, 'utf8');\n    }\n    else {\n        a = bytes_1.toBuffer(a);\n    }\n    if (!bits)\n        bits = 256;\n    switch (bits) {\n        case 224: {\n            return keccak224(a);\n        }\n        case 256: {\n            return k256(a);\n        }\n        case 384: {\n            return keccak384(a);\n        }\n        case 512: {\n            return keccak512(a);\n        }\n        default: {\n            throw new Error(\"Invald algorithm: keccak\" + bits);\n        }\n    }\n};\n/**\n * Creates Keccak-256 hash of the input, alias for keccak(a, 256).\n * @param a The input data (Buffer|Array|String|Number)\n */\nexports.keccak256 = function (a) {\n    return exports.keccak(a);\n};\n/**\n * Creates SHA256 hash of the input.\n * @param a The input data (Buffer|Array|String|Number)\n */\nexports.sha256 = function (a) {\n    a = bytes_1.toBuffer(a);\n    return createHash('sha256')\n        .update(a)\n        .digest();\n};\n/**\n * Creates RIPEMD160 hash of the input.\n * @param a The input data (Buffer|Array|String|Number)\n * @param padded Whether it should be padded to 256 bits or not\n */\nexports.ripemd160 = function (a, padded) {\n    a = bytes_1.toBuffer(a);\n    var hash = createHash('rmd160')\n        .update(a)\n        .digest();\n    if (padded === true) {\n        return bytes_1.setLength(hash, 32);\n    }\n    else {\n        return hash;\n    }\n};\n/**\n * Creates SHA-3 hash of the RLP encoded version of the input.\n * @param a The input data\n */\nexports.rlphash = function (a) {\n    return exports.keccak(rlp.encode(a));\n};\n//# sourceMappingURL=hash.js.map","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nvar hash_utils_1 = require(\"./hash-utils\");\nvar createKeccakHash = require(\"keccak\");\nexports.keccak224 = hash_utils_1.createHashFunction(function () {\n    return createKeccakHash(\"keccak224\");\n});\nexports.keccak256 = hash_utils_1.createHashFunction(function () {\n    return createKeccakHash(\"keccak256\");\n});\nexports.keccak384 = hash_utils_1.createHashFunction(function () {\n    return createKeccakHash(\"keccak384\");\n});\nexports.keccak512 = hash_utils_1.createHashFunction(function () {\n    return createKeccakHash(\"keccak512\");\n});\n//# sourceMappingURL=keccak.js.map","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\nmodule.exports = Stream;\n\nvar EE = require('events').EventEmitter;\nvar inherits = require('inherits');\n\ninherits(Stream, EE);\nStream.Readable = require('readable-stream/readable.js');\nStream.Writable = require('readable-stream/writable.js');\nStream.Duplex = require('readable-stream/duplex.js');\nStream.Transform = require('readable-stream/transform.js');\nStream.PassThrough = require('readable-stream/passthrough.js');\n\n// Backwards-compat with node 0.4.x\nStream.Stream = Stream;\n\n\n\n// old-style streams.  Note that the pipe method (the only relevant\n// part of this class) is overridden in the Readable class.\n\nfunction Stream() {\n  EE.call(this);\n}\n\nStream.prototype.pipe = function(dest, options) {\n  var source = this;\n\n  function ondata(chunk) {\n    if (dest.writable) {\n      if (false === dest.write(chunk) && source.pause) {\n        source.pause();\n      }\n    }\n  }\n\n  source.on('data', ondata);\n\n  function ondrain() {\n    if (source.readable && source.resume) {\n      source.resume();\n    }\n  }\n\n  dest.on('drain', ondrain);\n\n  // If the 'end' option is not supplied, dest.end() will be called when\n  // source gets the 'end' or 'close' events.  Only dest.end() once.\n  if (!dest._isStdio && (!options || options.end !== false)) {\n    source.on('end', onend);\n    source.on('close', onclose);\n  }\n\n  var didOnEnd = false;\n  function onend() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    dest.end();\n  }\n\n\n  function onclose() {\n    if (didOnEnd) return;\n    didOnEnd = true;\n\n    if (typeof dest.destroy === 'function') dest.destroy();\n  }\n\n  // don't leave dangling pipes when there are errors.\n  function onerror(er) {\n    cleanup();\n    if (EE.listenerCount(this, 'error') === 0) {\n      throw er; // Unhandled stream error in pipe.\n    }\n  }\n\n  source.on('error', onerror);\n  dest.on('error', onerror);\n\n  // remove all the event listeners that were added.\n  function cleanup() {\n    source.removeListener('data', ondata);\n    dest.removeListener('drain', ondrain);\n\n    source.removeListener('end', onend);\n    source.removeListener('close', onclose);\n\n    source.removeListener('error', onerror);\n    dest.removeListener('error', onerror);\n\n    source.removeListener('end', cleanup);\n    source.removeListener('close', cleanup);\n\n    dest.removeListener('close', cleanup);\n  }\n\n  source.on('end', cleanup);\n  source.on('close', cleanup);\n\n  dest.on('close', cleanup);\n\n  dest.emit('pipe', source);\n\n  // Allow for unix-like usage: A.pipe(B).pipe(C)\n  return dest;\n};\n","exports = module.exports = require('./lib/_stream_readable.js');\nexports.Stream = exports;\nexports.Readable = exports;\nexports.Writable = require('./lib/_stream_writable.js');\nexports.Duplex = require('./lib/_stream_duplex.js');\nexports.Transform = require('./lib/_stream_transform.js');\nexports.PassThrough = require('./lib/_stream_passthrough.js');\n","/* eslint-disable node/no-deprecated-api */\nvar buffer = require('buffer')\nvar Buffer = buffer.Buffer\n\n// alternative to using Object.keys for old browsers\nfunction copyProps (src, dst) {\n  for (var key in src) {\n    dst[key] = src[key]\n  }\n}\nif (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {\n  module.exports = buffer\n} else {\n  // Copy properties from require('buffer')\n  copyProps(buffer, exports)\n  exports.Buffer = SafeBuffer\n}\n\nfunction SafeBuffer (arg, encodingOrOffset, length) {\n  return Buffer(arg, encodingOrOffset, length)\n}\n\n// Copy static methods from Buffer\ncopyProps(Buffer, SafeBuffer)\n\nSafeBuffer.from = function (arg, encodingOrOffset, length) {\n  if (typeof arg === 'number') {\n    throw new TypeError('Argument must not be a number')\n  }\n  return Buffer(arg, encodingOrOffset, length)\n}\n\nSafeBuffer.alloc = function (size, fill, encoding) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  var buf = Buffer(size)\n  if (fill !== undefined) {\n    if (typeof encoding === 'string') {\n      buf.fill(fill, encoding)\n    } else {\n      buf.fill(fill)\n    }\n  } else {\n    buf.fill(0)\n  }\n  return buf\n}\n\nSafeBuffer.allocUnsafe = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return Buffer(size)\n}\n\nSafeBuffer.allocUnsafeSlow = function (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('Argument must be a number')\n  }\n  return buffer.SlowBuffer(size)\n}\n","// Copyright Joyent, Inc. and other Node contributors.\n//\n// Permission is hereby granted, free of charge, to any person obtaining a\n// copy of this software and associated documentation files (the\n// \"Software\"), to deal in the Software without restriction, including\n// without limitation the rights to use, copy, modify, merge, publish,\n// distribute, sublicense, and/or sell copies of the Software, and to permit\n// persons to whom the Software is furnished to do so, subject to the\n// following conditions:\n//\n// The above copyright notice and this permission notice shall be included\n// in all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS\n// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\n// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN\n// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,\n// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR\n// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE\n// USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n// A bit simpler than readable streams.\n// Implement an async ._write(chunk, encoding, cb), and it'll handle all\n// the drain event emission and buffering.\n\n'use strict';\n\n/*<replacement>*/\n\nvar pna = require('process-nextick-args');\n/*</replacement>*/\n\nmodule.exports = Writable;\n\n/* <replacement> */\nfunction WriteReq(chunk, encoding, cb) {\n  this.chunk = chunk;\n  this.encoding = encoding;\n  this.callback = cb;\n  this.next = null;\n}\n\n// It seems a linked list but it is not\n// there will be only 2 of these for each stream\nfunction CorkedRequest(state) {\n  var _this = this;\n\n  this.next = null;\n  this.entry = null;\n  this.finish = function () {\n    onCorkedFinish(_this, state);\n  };\n}\n/* </replacement> */\n\n/*<replacement>*/\nvar asyncWrite = !process.browser && ['v0.10', 'v0.9.'].indexOf(process.version.slice(0, 5)) > -1 ? setImmediate : pna.nextTick;\n/*</replacement>*/\n\n/*<replacement>*/\nvar Duplex;\n/*</replacement>*/\n\nWritable.WritableState = WritableState;\n\n/*<replacement>*/\nvar util = Object.create(require('core-util-is'));\nutil.inherits = require('inherits');\n/*</replacement>*/\n\n/*<replacement>*/\nvar internalUtil = {\n  deprecate: require('util-deprecate')\n};\n/*</replacement>*/\n\n/*<replacement>*/\nvar Stream = require('./internal/streams/stream');\n/*</replacement>*/\n\n/*<replacement>*/\n\nvar Buffer = require('safe-buffer').Buffer;\nvar OurUint8Array = global.Uint8Array || function () {};\nfunction _uint8ArrayToBuffer(chunk) {\n  return Buffer.from(chunk);\n}\nfunction _isUint8Array(obj) {\n  return Buffer.isBuffer(obj) || obj instanceof OurUint8Array;\n}\n\n/*</replacement>*/\n\nvar destroyImpl = require('./internal/streams/destroy');\n\nutil.inherits(Writable, Stream);\n\nfunction nop() {}\n\nfunction WritableState(options, stream) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  options = options || {};\n\n  // Duplex streams are both readable and writable, but share\n  // the same options object.\n  // However, some cases require setting options to different\n  // values for the readable and the writable sides of the duplex stream.\n  // These options can be provided separately as readableXXX and writableXXX.\n  var isDuplex = stream instanceof Duplex;\n\n  // object stream flag to indicate whether or not this stream\n  // contains buffers or objects.\n  this.objectMode = !!options.objectMode;\n\n  if (isDuplex) this.objectMode = this.objectMode || !!options.writableObjectMode;\n\n  // the point at which write() starts returning false\n  // Note: 0 is a valid value, means that we always return false if\n  // the entire buffer is not flushed immediately on write()\n  var hwm = options.highWaterMark;\n  var writableHwm = options.writableHighWaterMark;\n  var defaultHwm = this.objectMode ? 16 : 16 * 1024;\n\n  if (hwm || hwm === 0) this.highWaterMark = hwm;else if (isDuplex && (writableHwm || writableHwm === 0)) this.highWaterMark = writableHwm;else this.highWaterMark = defaultHwm;\n\n  // cast to ints.\n  this.highWaterMark = Math.floor(this.highWaterMark);\n\n  // if _final has been called\n  this.finalCalled = false;\n\n  // drain event flag.\n  this.needDrain = false;\n  // at the start of calling end()\n  this.ending = false;\n  // when end() has been called, and returned\n  this.ended = false;\n  // when 'finish' is emitted\n  this.finished = false;\n\n  // has it been destroyed\n  this.destroyed = false;\n\n  // should we decode strings into buffers before passing to _write?\n  // this is here so that some node-core streams can optimize string\n  // handling at a lower level.\n  var noDecode = options.decodeStrings === false;\n  this.decodeStrings = !noDecode;\n\n  // Crypto is kind of old and crusty.  Historically, its default string\n  // encoding is 'binary' so we have to make this configurable.\n  // Everything else in the universe uses 'utf8', though.\n  this.defaultEncoding = options.defaultEncoding || 'utf8';\n\n  // not an actual buffer we keep track of, but a measurement\n  // of how much we're waiting to get pushed to some underlying\n  // socket or file.\n  this.length = 0;\n\n  // a flag to see when we're in the middle of a write.\n  this.writing = false;\n\n  // when true all writes will be buffered until .uncork() call\n  this.corked = 0;\n\n  // a flag to be able to tell if the onwrite cb is called immediately,\n  // or on a later tick.  We set this to true at first, because any\n  // actions that shouldn't happen until \"later\" should generally also\n  // not happen before the first write call.\n  this.sync = true;\n\n  // a flag to know if we're processing previously buffered items, which\n  // may call the _write() callback in the same tick, so that we don't\n  // end up in an overlapped onwrite situation.\n  this.bufferProcessing = false;\n\n  // the callback that's passed to _write(chunk,cb)\n  this.onwrite = function (er) {\n    onwrite(stream, er);\n  };\n\n  // the callback that the user supplies to write(chunk,encoding,cb)\n  this.writecb = null;\n\n  // the amount that is being written when _write is called.\n  this.writelen = 0;\n\n  this.bufferedRequest = null;\n  this.lastBufferedRequest = null;\n\n  // number of pending user-supplied write callbacks\n  // this must be 0 before 'finish' can be emitted\n  this.pendingcb = 0;\n\n  // emit prefinish if the only thing we're waiting for is _write cbs\n  // This is relevant for synchronous Transform streams\n  this.prefinished = false;\n\n  // True if the error was already emitted and should not be thrown again\n  this.errorEmitted = false;\n\n  // count buffered requests\n  this.bufferedRequestCount = 0;\n\n  // allocate the first CorkedRequest, there is always\n  // one allocated and free to use, and we maintain at most two\n  this.corkedRequestsFree = new CorkedRequest(this);\n}\n\nWritableState.prototype.getBuffer = function getBuffer() {\n  var current = this.bufferedRequest;\n  var out = [];\n  while (current) {\n    out.push(current);\n    current = current.next;\n  }\n  return out;\n};\n\n(function () {\n  try {\n    Object.defineProperty(WritableState.prototype, 'buffer', {\n      get: internalUtil.deprecate(function () {\n        return this.getBuffer();\n      }, '_writableState.buffer is deprecated. Use _writableState.getBuffer ' + 'instead.', 'DEP0003')\n    });\n  } catch (_) {}\n})();\n\n// Test _writableState for inheritance to account for Duplex streams,\n// whose prototype chain only points to Readable.\nvar realHasInstance;\nif (typeof Symbol === 'function' && Symbol.hasInstance && typeof Function.prototype[Symbol.hasInstance] === 'function') {\n  realHasInstance = Function.prototype[Symbol.hasInstance];\n  Object.defineProperty(Writable, Symbol.hasInstance, {\n    value: function (object) {\n      if (realHasInstance.call(this, object)) return true;\n      if (this !== Writable) return false;\n\n      return object && object._writableState instanceof WritableState;\n    }\n  });\n} else {\n  realHasInstance = function (object) {\n    return object instanceof this;\n  };\n}\n\nfunction Writable(options) {\n  Duplex = Duplex || require('./_stream_duplex');\n\n  // Writable ctor is applied to Duplexes, too.\n  // `realHasInstance` is necessary because using plain `instanceof`\n  // would return false, as no `_writableState` property is attached.\n\n  // Trying to use the custom `instanceof` for Writable here will also break the\n  // Node.js LazyTransform implementation, which has a non-trivial getter for\n  // `_writableState` that would lead to infinite recursion.\n  if (!realHasInstance.call(Writable, this) && !(this instanceof Duplex)) {\n    return new Writable(options);\n  }\n\n  this._writableState = new WritableState(options, this);\n\n  // legacy.\n  this.writable = true;\n\n  if (options) {\n    if (typeof options.write === 'function') this._write = options.write;\n\n    if (typeof options.writev === 'function') this._writev = options.writev;\n\n    if (typeof options.destroy === 'function') this._destroy = options.destroy;\n\n    if (typeof options.final === 'function') this._final = options.final;\n  }\n\n  Stream.call(this);\n}\n\n// Otherwise people can pipe Writable streams, which is just wrong.\nWritable.prototype.pipe = function () {\n  this.emit('error', new Error('Cannot pipe, not readable'));\n};\n\nfunction writeAfterEnd(stream, cb) {\n  var er = new Error('write after end');\n  // TODO: defer error events consistently everywhere, not just the cb\n  stream.emit('error', er);\n  pna.nextTick(cb, er);\n}\n\n// Checks that a user-supplied chunk is valid, especially for the particular\n// mode the stream is in. Currently this means that `null` is never accepted\n// and undefined/non-string values are only allowed in object mode.\nfunction validChunk(stream, state, chunk, cb) {\n  var valid = true;\n  var er = false;\n\n  if (chunk === null) {\n    er = new TypeError('May not write null values to stream');\n  } else if (typeof chunk !== 'string' && chunk !== undefined && !state.objectMode) {\n    er = new TypeError('Invalid non-string/buffer chunk');\n  }\n  if (er) {\n    stream.emit('error', er);\n    pna.nextTick(cb, er);\n    valid = false;\n  }\n  return valid;\n}\n\nWritable.prototype.write = function (chunk, encoding, cb) {\n  var state = this._writableState;\n  var ret = false;\n  var isBuf = !state.objectMode && _isUint8Array(chunk);\n\n  if (isBuf && !Buffer.isBuffer(chunk)) {\n    chunk = _uint8ArrayToBuffer(chunk);\n  }\n\n  if (typeof encoding === 'function') {\n    cb = encoding;\n    encoding = null;\n  }\n\n  if (isBuf) encoding = 'buffer';else if (!encoding) encoding = state.defaultEncoding;\n\n  if (typeof cb !== 'function') cb = nop;\n\n  if (state.ended) writeAfterEnd(this, cb);else if (isBuf || validChunk(this, state, chunk, cb)) {\n    state.pendingcb++;\n    ret = writeOrBuffer(this, state, isBuf, chunk, encoding, cb);\n  }\n\n  return ret;\n};\n\nWritable.prototype.cork = function () {\n  var state = this._writableState;\n\n  state.corked++;\n};\n\nWritable.prototype.uncork = function () {\n  var state = this._writableState;\n\n  if (state.corked) {\n    state.corked--;\n\n    if (!state.writing && !state.corked && !state.finished && !state.bufferProcessing && state.bufferedRequest) clearBuffer(this, state);\n  }\n};\n\nWritable.prototype.setDefaultEncoding = function setDefaultEncoding(encoding) {\n  // node::ParseEncoding() requires lower case.\n  if (typeof encoding === 'string') encoding = encoding.toLowerCase();\n  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);\n  this._writableState.defaultEncoding = encoding;\n  return this;\n};\n\nfunction decodeChunk(state, chunk, encoding) {\n  if (!state.objectMode && state.decodeStrings !== false && typeof chunk === 'string') {\n    chunk = Buffer.from(chunk, encoding);\n  }\n  return chunk;\n}\n\nObject.defineProperty(Writable.prototype, 'writableHighWaterMark', {\n  // making it explicit this property is not enumerable\n  // because otherwise some prototype manipulation in\n  // userland will fail\n  enumerable: false,\n  get: function () {\n    return this._writableState.highWaterMark;\n  }\n});\n\n// if we're already writing something, then just put this\n// in the queue, and wait our turn.  Otherwise, call _write\n// If we return false, then we need a drain event, so set that flag.\nfunction writeOrBuffer(stream, state, isBuf, chunk, encoding, cb) {\n  if (!isBuf) {\n    var newChunk = decodeChunk(state, chunk, encoding);\n    if (chunk !== newChunk) {\n      isBuf = true;\n      encoding = 'buffer';\n      chunk = newChunk;\n    }\n  }\n  var len = state.objectMode ? 1 : chunk.length;\n\n  state.length += len;\n\n  var ret = state.length < state.highWaterMark;\n  // we must ensure that previous needDrain will not be reset to false.\n  if (!ret) state.needDrain = true;\n\n  if (state.writing || state.corked) {\n    var last = state.lastBufferedRequest;\n    state.lastBufferedRequest = {\n      chunk: chunk,\n      encoding: encoding,\n      isBuf: isBuf,\n      callback: cb,\n      next: null\n    };\n    if (last) {\n      last.next = state.lastBufferedRequest;\n    } else {\n      state.bufferedRequest = state.lastBufferedRequest;\n    }\n    state.bufferedRequestCount += 1;\n  } else {\n    doWrite(stream, state, false, len, chunk, encoding, cb);\n  }\n\n  return ret;\n}\n\nfunction doWrite(stream, state, writev, len, chunk, encoding, cb) {\n  state.writelen = len;\n  state.writecb = cb;\n  state.writing = true;\n  state.sync = true;\n  if (writev) stream._writev(chunk, state.onwrite);else stream._write(chunk, encoding, state.onwrite);\n  state.sync = false;\