@leofcoin/peernet 0.11.31 → 0.12.0

package/dist/browser/160.peernet.js

@@ -0,0 +1,3809 @@
+(self["webpackChunkPeernet"] = self["webpackChunkPeernet"] || []).push([[160],{
+
+/***/ 1626:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var parse = __webpack_require__(7126)
+var stringify = __webpack_require__(2565)
+
+module.exports = parse
+module.exports.parse = parse
+module.exports.stringify = stringify
+
+
+/***/ }),
+
+/***/ 7126:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+var tokenize = __webpack_require__(989)
+var MAX_RANGE = 0x1FFFFFFF
+
+// "Only repeated fields of primitive numeric types (types which use the varint, 32-bit, or 64-bit wire types) can be declared "packed"."
+// https://developers.google.com/protocol-buffers/docs/encoding#optional
+var PACKABLE_TYPES = [
+  // varint wire types
+  'int32', 'int64', 'uint32', 'uint64', 'sint32', 'sint64', 'bool',
+  // + ENUMS
+  // 64-bit wire types
+  'fixed64', 'sfixed64', 'double',
+  // 32-bit wire types
+  'fixed32', 'sfixed32', 'float'
+]
+
+var onfieldoptionvalue = function (tokens) {
+  var value = tokens.shift()
+  if (value !== '{') {
+    return value
+  }
+  value = {}
+  var field = ''
+  while (tokens.length) {
+    switch (tokens[0]) {
+      case '}':
+        tokens.shift()
+        return value
+      case ':':
+        tokens.shift()
+        value[field] = onfieldoptionvalue(tokens)
+        break
+      default:
+        field = tokens.shift()
+    }
+  }
+}
+
+var onfieldoptions = function (tokens) {
+  var opts = {}
+
+  while (tokens.length) {
+    switch (tokens[0]) {
+      case '[':
+      case ',': {
+        tokens.shift()
+        var name = tokens.shift()
+        if (name === '(') { // handling [(A) = B]
+          name = tokens.shift()
+          tokens.shift() // remove the end of bracket
+        }
+        var field = []
+        if (tokens[0][0] === '.') {
+          field = tokens[0].substr(1).split('.')
+          tokens.shift()
+        }
+        if (tokens[0] !== '=') throw new Error('Unexpected token in field options: ' + tokens[0])
+        tokens.shift()
+        if (tokens[0] === ']') throw new Error('Unexpected ] in field option')
+
+        // for option (A).b.c
+        // path will be ['A', 'b'] and lastFieldName 'c'
+        var path = [name].concat(field)
+        var lastFieldName = path.pop()
+
+        // opt references opts.A.b
+        var opt = path.reduce(function (opt, n, index) {
+          if (opt[n] == null) {
+            opt[n] = {}
+          }
+          return opt[n]
+        }, opts)
+
+        // now set opt['c'] that references opts.A.b['c']
+        opt[lastFieldName] = onfieldoptionvalue(tokens)
+        break
+      }
+      case ']':
+        tokens.shift()
+        return opts
+
+      default:
+        throw new Error('Unexpected token in field options: ' + tokens[0])
+    }
+  }
+
+  throw new Error('No closing tag for field options')
+}
+
+var onfield = function (tokens) {
+  var field = {
+    name: null,
+    type: null,
+    tag: -1,
+    map: null,
+    oneof: null,
+    required: false,
+    repeated: false,
+    options: {}
+  }
+
+  while (tokens.length) {
+    switch (tokens[0]) {
+      case '=':
+        tokens.shift()
+        field.tag = Number(tokens.shift())
+        break
+
+      case 'map':
+        field.type = 'map'
+        field.map = { from: null, to: null }
+        tokens.shift()
+        if (tokens[0] !== '<') throw new Error('Unexpected token in map type: ' + tokens[0])
+        tokens.shift()
+        field.map.from = tokens.shift()
+        if (tokens[0] !== ',') throw new Error('Unexpected token in map type: ' + tokens[0])
+        tokens.shift()
+        field.map.to = tokens.shift()
+        if (tokens[0] !== '>') throw new Error('Unexpected token in map type: ' + tokens[0])
+        tokens.shift()
+        field.name = tokens.shift()
+        break
+
+      case 'repeated':
+      case 'required':
+      case 'optional':
+        var t = tokens.shift()
+        field.required = t === 'required'
+        field.repeated = t === 'repeated'
+        field.type = tokens.shift()
+        field.name = tokens.shift()
+        break
+
+      case '[':
+        field.options = onfieldoptions(tokens)
+        break
+
+      case ';':
+        if (field.name === null) throw new Error('Missing field name')
+        if (field.type === null) throw new Error('Missing type in message field: ' + field.name)
+        if (field.tag === -1) throw new Error('Missing tag number in message field: ' + field.name)
+        tokens.shift()
+        return field
+
+      default:
+        throw new Error('Unexpected token in message field: ' + tokens[0])
+    }
+  }
+
+  throw new Error('No ; found for message field')
+}
+
+var onmessagebody = function (tokens) {
+  var body = {
+    enums: [],
+    options: {},
+    messages: [],
+    fields: [],
+    extends: [],
+    extensions: null
+  }
+
+  while (tokens.length) {
+    switch (tokens[0]) {
+      case 'map':
+      case 'repeated':
+      case 'optional':
+      case 'required':
+        body.fields.push(onfield(tokens))
+        break
+
+      case 'enum':
+        body.enums.push(onenum(tokens))
+        break
+
+      case 'message':
+        body.messages.push(onmessage(tokens))
+        break
+
+      case 'extensions':
+        body.extensions = onextensions(tokens)
+        break
+
+      case 'oneof':
+        tokens.shift()
+        var name = tokens.shift()
+        if (tokens[0] !== '{') throw new Error('Unexpected token in oneof: ' + tokens[0])
+        tokens.shift()
+        while (tokens[0] !== '}') {
+          tokens.unshift('optional')
+          var field = onfield(tokens)
+          field.oneof = name
+          body.fields.push(field)
+        }
+        tokens.shift()
+        break
+
+      case 'extend':
+        body.extends.push(onextend(tokens))
+        break
+
+      case ';':
+        tokens.shift()
+        break
+
+      case 'reserved':
+        tokens.shift()
+        while (tokens[0] !== ';') {
+          tokens.shift()
+        }
+        break
+
+      case 'option':
+        var opt = onoption(tokens)
+        if (body.options[opt.name] !== undefined) throw new Error('Duplicate option ' + opt.name)
+        body.options[opt.name] = opt.value
+        break
+
+      default:
+        // proto3 does not require the use of optional/required, assumed as optional
+        // "singular: a well-formed message can have zero or one of this field (but not more than one)."
+        // https://developers.google.com/protocol-buffers/docs/proto3#specifying-field-rules
+        tokens.unshift('optional')
+        body.fields.push(onfield(tokens))
+    }
+  }
+
+  return body
+}
+
+var onextend = function (tokens) {
+  var out = {
+    name: tokens[1],
+    message: onmessage(tokens)
+  }
+  return out
+}
+
+var onextensions = function (tokens) {
+  tokens.shift()
+  var from = Number(tokens.shift())
+  if (isNaN(from)) throw new Error('Invalid from in extensions definition')
+  if (tokens.shift() !== 'to') throw new Error("Expected keyword 'to' in extensions definition")
+  var to = tokens.shift()
+  if (to === 'max') to = MAX_RANGE
+  to = Number(to)
+  if (isNaN(to)) throw new Error('Invalid to in extensions definition')
+  if (tokens.shift() !== ';') throw new Error('Missing ; in extensions definition')
+  return { from: from, to: to }
+}
+var onmessage = function (tokens) {
+  tokens.shift()
+
+  var lvl = 1
+  var body = []
+  var msg = {
+    name: tokens.shift(),
+    options: {},
+    enums: [],
+    extends: [],
+    messages: [],
+    fields: []
+  }
+
+  if (tokens[0] !== '{') throw new Error('Expected { but found ' + tokens[0])
+  tokens.shift()
+
+  while (tokens.length) {
+    if (tokens[0] === '{') lvl++
+    else if (tokens[0] === '}') lvl--
+
+    if (!lvl) {
+      tokens.shift()
+      body = onmessagebody(body)
+      msg.enums = body.enums
+      msg.messages = body.messages
+      msg.fields = body.fields
+      msg.extends = body.extends
+      msg.extensions = body.extensions
+      msg.options = body.options
+      return msg
+    }
+
+    body.push(tokens.shift())
+  }
+
+  if (lvl) throw new Error('No closing tag for message')
+}
+
+var onpackagename = function (tokens) {
+  tokens.shift()
+  var name = tokens.shift()
+  if (tokens[0] !== ';') throw new Error('Expected ; but found ' + tokens[0])
+  tokens.shift()
+  return name
+}
+
+var onsyntaxversion = function (tokens) {
+  tokens.shift()
+
+  if (tokens[0] !== '=') throw new Error('Expected = but found ' + tokens[0])
+  tokens.shift()
+
+  var version = tokens.shift()
+  switch (version) {
+    case '"proto2"':
+      version = 2
+      break
+
+    case '"proto3"':
+      version = 3
+      break
+
+    default:
+      throw new Error('Expected protobuf syntax version but found ' + version)
+  }
+
+  if (tokens[0] !== ';') throw new Error('Expected ; but found ' + tokens[0])
+  tokens.shift()
+
+  return version
+}
+
+var onenumvalue = function (tokens) {
+  if (tokens.length < 4) throw new Error('Invalid enum value: ' + tokens.slice(0, 3).join(' '))
+  if (tokens[0] === 'reserved') {
+    tokens.shift()
+    while (tokens[0] !== ';') {
+      tokens.shift()
+    }
+    tokens.shift()
+    return null
+  }
+  if (tokens[1] !== '=') throw new Error('Expected = but found ' + tokens[1])
+  if (tokens[3] !== ';' && tokens[3] !== '[') throw new Error('Expected ; or [ but found ' + tokens[1])
+
+  var name = tokens.shift()
+  tokens.shift()
+  var val = {
+    value: null,
+    options: {}
+  }
+  val.value = Number(tokens.shift())
+  if (tokens[0] === '[') {
+    val.options = onfieldoptions(tokens)
+  }
+  tokens.shift() // expecting the semicolon here
+
+  return {
+    name: name,
+    val: val
+  }
+}
+
+var onenum = function (tokens) {
+  tokens.shift()
+  var options = {}
+  var e = {
+    name: tokens.shift(),
+    values: {},
+    options: {}
+  }
+
+  if (tokens[0] !== '{') throw new Error('Expected { but found ' + tokens[0])
+  tokens.shift()
+
+  while (tokens.length) {
+    if (tokens[0] === '}') {
+      tokens.shift()
+      // there goes optional semicolon after the enclosing "}"
+      if (tokens[0] === ';') tokens.shift()
+      return e
+    }
+    if (tokens[0] === 'option') {
+      options = onoption(tokens)
+      e.options[options.name] = options.value
+      continue
+    }
+    var val = onenumvalue(tokens)
+    if (val !== null) {
+      e.values[val.name] = val.val
+    }
+  }
+
+  throw new Error('No closing tag for enum')
+}
+
+var onoption = function (tokens) {
+  var name = null
+  var value = null
+
+  var parse = function (value) {
+    if (value === 'true') return true
+    if (value === 'false') return false
+    return value.replace(/^"+|"+$/gm, '')
+  }
+
+  while (tokens.length) {
+    if (tokens[0] === ';') {
+      tokens.shift()
+      return { name: name, value: value }
+    }
+    switch (tokens[0]) {
+      case 'option':
+        tokens.shift()
+
+        var hasBracket = tokens[0] === '('
+        if (hasBracket) tokens.shift()
+
+        name = tokens.shift()
+
+        if (hasBracket) {
+          if (tokens[0] !== ')') throw new Error('Expected ) but found ' + tokens[0])
+          tokens.shift()
+        }
+
+        if (tokens[0][0] === '.') {
+          name += tokens.shift()
+        }
+
+        break
+
+      case '=':
+        tokens.shift()
+        if (name === null) throw new Error('Expected key for option with value: ' + tokens[0])
+        value = parse(tokens.shift())
+
+        if (name === 'optimize_for' && !/^(SPEED|CODE_SIZE|LITE_RUNTIME)$/.test(value)) {
+          throw new Error('Unexpected value for option optimize_for: ' + value)
+        } else if (value === '{') {
+          // option foo = {bar: baz}
+          value = onoptionMap(tokens)
+        }
+        break
+
+      default:
+        throw new Error('Unexpected token in option: ' + tokens[0])
+    }
+  }
+}
+
+var onoptionMap = function (tokens) {
+  var parse = function (value) {
+    if (value === 'true') return true
+    if (value === 'false') return false
+    return value.replace(/^"+|"+$/gm, '')
+  }
+
+  var map = {}
+
+  while (tokens.length) {
+    if (tokens[0] === '}') {
+      tokens.shift()
+      return map
+    }
+
+    var hasBracket = tokens[0] === '('
+    if (hasBracket) tokens.shift()
+
+    var key = tokens.shift()
+    if (hasBracket) {
+      if (tokens[0] !== ')') throw new Error('Expected ) but found ' + tokens[0])
+      tokens.shift()
+    }
+
+    var value = null
+
+    switch (tokens[0]) {
+      case ':':
+        if (map[key] !== undefined) throw new Error('Duplicate option map key ' + key)
+
+        tokens.shift()
+
+        value = parse(tokens.shift())
+
+        if (value === '{') {
+          // option foo = {bar: baz}
+          value = onoptionMap(tokens)
+        }
+
+        map[key] = value
+
+        if (tokens[0] === ';') {
+          tokens.shift()
+        }
+        break
+
+      case '{':
+        tokens.shift()
+        value = onoptionMap(tokens)
+
+        if (map[key] === undefined) map[key] = []
+        if (!Array.isArray(map[key])) throw new Error('Duplicate option map key ' + key)
+
+        map[key].push(value)
+        break
+
+      default:
+        throw new Error('Unexpected token in option map: ' + tokens[0])
+    }
+  }
+
+  throw new Error('No closing tag for option map')
+}
+
+var onimport = function (tokens) {
+  tokens.shift()
+  var file = tokens.shift().replace(/^"+|"+$/gm, '')
+
+  if (tokens[0] !== ';') throw new Error('Unexpected token: ' + tokens[0] + '. Expected ";"')
+
+  tokens.shift()
+  return file
+}
+
+var onservice = function (tokens) {
+  tokens.shift()
+
+  var service = {
+    name: tokens.shift(),
+    methods: [],
+    options: {}
+  }
+
+  if (tokens[0] !== '{') throw new Error('Expected { but found ' + tokens[0])
+  tokens.shift()
+
+  while (tokens.length) {
+    if (tokens[0] === '}') {
+      tokens.shift()
+      // there goes optional semicolon after the enclosing "}"
+      if (tokens[0] === ';') tokens.shift()
+      return service
+    }
+
+    switch (tokens[0]) {
+      case 'option':
+        var opt = onoption(tokens)
+        if (service.options[opt.name] !== undefined) throw new Error('Duplicate option ' + opt.name)
+        service.options[opt.name] = opt.value
+        break
+      case 'rpc':
+        service.methods.push(onrpc(tokens))
+        break
+      default:
+        throw new Error('Unexpected token in service: ' + tokens[0])
+    }
+  }
+
+  throw new Error('No closing tag for service')
+}
+
+var onrpc = function (tokens) {
+  tokens.shift()
+
+  var rpc = {
+    name: tokens.shift(),
+    input_type: null,
+    output_type: null,
+    client_streaming: false,
+    server_streaming: false,
+    options: {}
+  }
+
+  if (tokens[0] !== '(') throw new Error('Expected ( but found ' + tokens[0])
+  tokens.shift()
+
+  if (tokens[0] === 'stream') {
+    tokens.shift()
+    rpc.client_streaming = true
+  }
+
+  rpc.input_type = tokens.shift()
+
+  if (tokens[0] !== ')') throw new Error('Expected ) but found ' + tokens[0])
+  tokens.shift()
+
+  if (tokens[0] !== 'returns') throw new Error('Expected returns but found ' + tokens[0])
+  tokens.shift()
+
+  if (tokens[0] !== '(') throw new Error('Expected ( but found ' + tokens[0])
+  tokens.shift()
+
+  if (tokens[0] === 'stream') {
+    tokens.shift()
+    rpc.server_streaming = true
+  }
+
+  rpc.output_type = tokens.shift()
+
+  if (tokens[0] !== ')') throw new Error('Expected ) but found ' + tokens[0])
+  tokens.shift()
+
+  if (tokens[0] === ';') {
+    tokens.shift()
+    return rpc
+  }
+
+  if (tokens[0] !== '{') throw new Error('Expected { but found ' + tokens[0])
+  tokens.shift()
+
+  while (tokens.length) {
+    if (tokens[0] === '}') {
+      tokens.shift()
+      // there goes optional semicolon after the enclosing "}"
+      if (tokens[0] === ';') tokens.shift()
+      return rpc
+    }
+
+    if (tokens[0] === 'option') {
+      var opt = onoption(tokens)
+      if (rpc.options[opt.name] !== undefined) throw new Error('Duplicate option ' + opt.name)
+      rpc.options[opt.name] = opt.value
+    } else {
+      throw new Error('Unexpected token in rpc options: ' + tokens[0])
+    }
+  }
+
+  throw new Error('No closing tag for rpc')
+}
+
+var parse = function (buf) {
+  var tokens = tokenize(buf.toString())
+  // check for isolated strings in tokens by looking for opening quote
+  for (var i = 0; i < tokens.length; i++) {
+    if (/^("|')([^'"]*)$/.test(tokens[i])) {
+      var j
+      if (tokens[i].length === 1) {
+        j = i + 1
+      } else {
+        j = i
+      }
+      // look ahead for the closing quote and collapse all
+      // in-between tokens into a single token
+      for (j; j < tokens.length; j++) {
+        if (/^[^'"\\]*(?:\\.[^'"\\]*)*("|')$/.test(tokens[j])) {
+          tokens = tokens.slice(0, i).concat(tokens.slice(i, j + 1).join('')).concat(tokens.slice(j + 1))
+          break
+        }
+      }
+    }
+  }
+  var schema = {
+    syntax: 3,
+    package: null,
+    imports: [],
+    enums: [],
+    messages: [],
+    options: {},
+    extends: []
+  }
+
+  var firstline = true
+
+  while (tokens.length) {
+    switch (tokens[0]) {
+      case 'package':
+        schema.package = onpackagename(tokens)
+        break
+
+      case 'syntax':
+        if (!firstline) throw new Error('Protobuf syntax version should be first thing in file')
+        schema.syntax = onsyntaxversion(tokens)
+        break
+
+      case 'message':
+        schema.messages.push(onmessage(tokens))
+        break
+
+      case 'enum':
+        schema.enums.push(onenum(tokens))
+        break
+
+      case 'option':
+        var opt = onoption(tokens)
+        if (schema.options[opt.name]) throw new Error('Duplicate option ' + opt.name)
+        schema.options[opt.name] = opt.value
+        break
+
+      case 'import':
+        schema.imports.push(onimport(tokens))
+        break
+
+      case 'extend':
+        schema.extends.push(onextend(tokens))
+        break
+
+      case 'service':
+        if (!schema.services) schema.services = []
+        schema.services.push(onservice(tokens))
+        break
+
+      default:
+        throw new Error('Unexpected token: ' + tokens[0])
+    }
+    firstline = false
+  }
+
+  // now iterate over messages and propagate extends
+  schema.extends.forEach(function (ext) {
+    schema.messages.forEach(function (msg) {
+      if (msg.name === ext.name) {
+        ext.message.fields.forEach(function (field) {
+          if (!msg.extensions || field.tag < msg.extensions.from || field.tag > msg.extensions.to) {
+            throw new Error(msg.name + ' does not declare ' + field.tag + ' as an extension number')
+          }
+          msg.fields.push(field)
+        })
+      }
+    })
+  })
+
+  schema.messages.forEach(function (msg) {
+    msg.fields.forEach(function (field) {
+      var fieldSplit
+      var messageName
+      var nestedEnumName
+      var message
+
+      function enumNameIsFieldType (en) {
+        return en.name === field.type
+      }
+
+      function enumNameIsNestedEnumName (en) {
+        return en.name === nestedEnumName
+      }
+
+      if (field.options && field.options.packed === 'true') {
+        if (PACKABLE_TYPES.indexOf(field.type) === -1) {
+          // let's see if it's an enum
+          if (field.type.indexOf('.') === -1) {
+            if (msg.enums && msg.enums.some(enumNameIsFieldType)) {
+              return
+            }
+          } else {
+            fieldSplit = field.type.split('.')
+            if (fieldSplit.length > 2) {
+              throw new Error('what is this?')
+            }
+
+            messageName = fieldSplit[0]
+            nestedEnumName = fieldSplit[1]
+
+            schema.messages.some(function (msg) {
+              if (msg.name === messageName) {
+                message = msg
+                return msg
+              }
+            })
+
+            if (message && message.enums && message.enums.some(enumNameIsNestedEnumName)) {
+              return
+            }
+          }
+
+          throw new Error(
+            'Fields of type ' + field.type + ' cannot be declared [packed=true]. ' +
+            'Only repeated fields of primitive numeric types (types which use ' +
+            'the varint, 32-bit, or 64-bit wire types) can be declared "packed". ' +
+            'See https://developers.google.com/protocol-buffers/docs/encoding#optional'
+          )
+        }
+      }
+    })
+  })
+
+  return schema
+}
+
+module.exports = parse
+
+
+/***/ }),
+
+/***/ 2565:
+/***/ (function(module) {
+
+var onimport = function (i, result) {
+  result.push('import "' + i + '";', '')
+  return result
+}
+
+var onfield = function (f, result) {
+  var prefix = f.repeated ? 'repeated' : f.required ? 'required' : 'optional'
+  if (f.type === 'map') prefix = 'map<' + f.map.from + ',' + f.map.to + '>'
+  if (f.oneof) prefix = ''
+
+  var opts = Object.keys(f.options || {}).map(function (key) {
+    return key + ' = ' + f.options[key]
+  }).join(',')
+
+  if (opts) opts = ' [' + opts + ']'
+
+  result.push((prefix ? prefix + ' ' : '') + (f.map === 'map' ? '' : f.type + ' ') + f.name + ' = ' + f.tag + opts + ';')
+  return result
+}
+
+var onmessage = function (m, result) {
+  result.push('message ' + m.name + ' {')
+
+  if (!m.options) m.options = {}
+  onoption(m.options, result)
+
+  if (!m.enums) m.enums = []
+  m.enums.forEach(function (e) {
+    result.push(onenum(e, []))
+  })
+
+  if (!m.messages) m.messages = []
+  m.messages.forEach(function (m) {
+    result.push(onmessage(m, []))
+  })
+
+  var oneofs = {}
+
+  if (!m.fields) m.fields = []
+  m.fields.forEach(function (f) {
+    if (f.oneof) {
+      if (!oneofs[f.oneof]) oneofs[f.oneof] = []
+      oneofs[f.oneof].push(onfield(f, []))
+    } else {
+      result.push(onfield(f, []))
+    }
+  })
+
+  Object.keys(oneofs).forEach(function (n) {
+    oneofs[n].unshift('oneof ' + n + ' {')
+    oneofs[n].push('}')
+    result.push(oneofs[n])
+  })
+
+  result.push('}', '')
+  return result
+}
+
+var onenum = function (e, result) {
+  result.push('enum ' + e.name + ' {')
+  if (!e.options) e.options = {}
+  var options = onoption(e.options, [])
+  if (options.length > 1) {
+    result.push(options.slice(0, -1))
+  }
+  Object.keys(e.values).map(function (v) {
+    var val = onenumvalue(e.values[v])
+    result.push([v + ' = ' + val + ';'])
+  })
+  result.push('}', '')
+  return result
+}
+
+var onenumvalue = function (v, result) {
+  var opts = Object.keys(v.options || {}).map(function (key) {
+    return key + ' = ' + v.options[key]
+  }).join(',')
+
+  if (opts) opts = ' [' + opts + ']'
+  var val = v.value + opts
+  return val
+}
+
+var onoption = function (o, result) {
+  var keys = Object.keys(o)
+  keys.forEach(function (option) {
+    var v = o[option]
+    if (~option.indexOf('.')) option = '(' + option + ')'
+
+    var type = typeof v
+
+    if (type === 'object') {
+      v = onoptionMap(v, [])
+      if (v.length) result.push('option ' + option + ' = {', v, '};')
+    } else {
+      if (type === 'string' && option !== 'optimize_for') v = '"' + v + '"'
+      result.push('option ' + option + ' = ' + v + ';')
+    }
+  })
+  if (keys.length > 0) {
+    result.push('')
+  }
+
+  return result
+}
+
+var onoptionMap = function (o, result) {
+  var keys = Object.keys(o)
+  keys.forEach(function (k) {
+    var v = o[k]
+
+    var type = typeof v
+
+    if (type === 'object') {
+      if (Array.isArray(v)) {
+        v.forEach(function (v) {
+          v = onoptionMap(v, [])
+          if (v.length) result.push(k + ' {', v, '}')
+        })
+      } else {
+        v = onoptionMap(v, [])
+        if (v.length) result.push(k + ' {', v, '}')
+      }
+    } else {
+      if (type === 'string') v = '"' + v + '"'
+      result.push(k + ': ' + v)
+    }
+  })
+
+  return result
+}
+
+var onservices = function (s, result) {
+  result.push('service ' + s.name + ' {')
+
+  if (!s.options) s.options = {}
+  onoption(s.options, result)
+  if (!s.methods) s.methods = []
+  s.methods.forEach(function (m) {
+    result.push(onrpc(m, []))
+  })
+
+  result.push('}', '')
+  return result
+}
+
+var onrpc = function (rpc, result) {
+  var def = 'rpc ' + rpc.name + '('
+  if (rpc.client_streaming) def += 'stream '
+  def += rpc.input_type + ') returns ('
+  if (rpc.server_streaming) def += 'stream '
+  def += rpc.output_type + ')'
+
+  if (!rpc.options) rpc.options = {}
+
+  var options = onoption(rpc.options, [])
+  if (options.length > 1) {
+    result.push(def + ' {', options.slice(0, -1), '}')
+  } else {
+    result.push(def + ';')
+  }
+
+  return result
+}
+
+var indent = function (lvl) {
+  return function (line) {
+    if (Array.isArray(line)) return line.map(indent(lvl + '  ')).join('\n')
+    return lvl + line
+  }
+}
+
+module.exports = function (schema) {
+  var result = []
+
+  result.push('syntax = "proto' + schema.syntax + '";', '')
+
+  if (schema.package) result.push('package ' + schema.package + ';', '')
+
+  if (schema.imports) {
+    schema.imports.forEach(function (i) {
+      onimport(i, result)
+    })
+  }
+
+  if (!schema.options) schema.options = {}
+
+  onoption(schema.options, result)
+
+  if (!schema.enums) schema.enums = []
+  schema.enums.forEach(function (e) {
+    onenum(e, result)
+  })
+
+  if (!schema.messages) schema.messages = []
+  schema.messages.forEach(function (m) {
+    onmessage(m, result)
+  })
+
+  if (schema.services) {
+    schema.services.forEach(function (s) {
+      onservices(s, result)
+    })
+  }
+  return result.map(indent('')).join('\n')
+}
+
+
+/***/ }),
+
+/***/ 989:
+/***/ (function(module) {
+
+module.exports = function (sch) {
+  var noComments = function (line) {
+    var i = line.indexOf('//')
+    return i > -1 ? line.slice(0, i) : line
+  }
+
+  var noMultilineComments = function () {
+    var inside = false
+    return function (token) {
+      if (token === '/*') {
+        inside = true
+        return false
+      }
+      if (token === '*/') {
+        inside = false
+        return false
+      }
+      return !inside
+    }
+  }
+
+  var trim = function (line) {
+    return line.trim()
+  }
+
+  var removeQuotedLines = function (list) {
+    return function (str) {
+      var s = '$' + list.length + '$'
+      list.push(str)
+      return s
+    }
+  }
+
+  var restoreQuotedLines = function (list) {
+    var re = /^\$(\d+)\$$/
+    return function (line) {
+      var m = line.match(re)
+      return m ? list[+m[1]] : line
+    }
+  }
+
+  var replacements = []
+  return sch
+    .replace(/"(\\"|[^"\n])*?"|'(\\'|[^'\n])*?'/gm, removeQuotedLines(replacements))
+    .replace(/([;,{}()=:[\]<>]|\/\*|\*\/)/g, ' $1 ')
+    .split(/\n/)
+    .map(trim)
+    .filter(Boolean)
+    .map(noComments)
+    .map(trim)
+    .filter(Boolean)
+    .join('\n')
+    .split(/\s+|\n+/gm)
+    .filter(noMultilineComments())
+    .map(restoreQuotedLines(replacements))
+}
+
+
+/***/ }),
+
+/***/ 8853:
+/***/ (function(module) {
+
+module.exports = read
+
+var MSB = 0x80
+  , REST = 0x7F
+
+function read(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length
+
+  do {
+    if (counter >= l) {
+      read.bytes = 0
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++]
+    res += shift < 28
+      ? (b & REST) << shift
+      : (b & REST) * Math.pow(2, shift)
+    shift += 7
+  } while (b >= MSB)
+
+  read.bytes = counter - offset
+
+  return res
+}
+
+
+/***/ }),
+
+/***/ 7659:
+/***/ (function(module) {
+
+module.exports = encode
+
+var MSB = 0x80
+  , REST = 0x7F
+  , MSBALL = ~REST
+  , INT = Math.pow(2, 31)
+
+function encode(num, out, offset) {
+  out = out || []
+  offset = offset || 0
+  var oldOffset = offset
+
+  while(num >= INT) {
+    out[offset++] = (num & 0xFF) | MSB
+    num /= 128
+  }
+  while(num & MSBALL) {
+    out[offset++] = (num & 0xFF) | MSB
+    num >>>= 7
+  }
+  out[offset] = num | 0
+  
+  encode.bytes = offset - oldOffset + 1
+  
+  return out
+}
+
+
+/***/ }),
+
+/***/ 138:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+module.exports = {
+    encode: __webpack_require__(7659)
+  , decode: __webpack_require__(8853)
+  , encodingLength: __webpack_require__(184)
+}
+
+
+/***/ }),
+
+/***/ 184:
+/***/ (function(module) {
+
+
+var N1 = Math.pow(2,  7)
+var N2 = Math.pow(2, 14)
+var N3 = Math.pow(2, 21)
+var N4 = Math.pow(2, 28)
+var N5 = Math.pow(2, 35)
+var N6 = Math.pow(2, 42)
+var N7 = Math.pow(2, 49)
+var N8 = Math.pow(2, 56)
+var N9 = Math.pow(2, 63)
+
+module.exports = function (value) {
+  return (
+    value < N1 ? 1
+  : value < N2 ? 2
+  : value < N3 ? 3
+  : value < N4 ? 4
+  : value < N5 ? 5
+  : value < N6 ? 6
+  : value < N7 ? 7
+  : value < N8 ? 8
+  : value < N9 ? 9
+  :              10
+  )
+}
+
+
+/***/ }),
+
+/***/ 7986:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+/* eslint max-depth: 1 */
+
+
+const varint = __webpack_require__(138)
+const defined = (__webpack_require__(3864)/* .defined */ .r)
+
+function toSentenceCase (string) {
+  return `${string.substring(0, 1).toUpperCase()}${string.substring(1)}`
+}
+
+function addPropertyAccessors (obj, name, value, defaultValue) {
+  if (Object.prototype.hasOwnProperty.call(obj, name)) {
+    // have already added this property
+    return
+  }
+
+  const sentenceCaseName = toSentenceCase(name)
+
+  Object.defineProperties(obj, {
+    [name]: {
+      enumerable: true,
+      configurable: true,
+      set: (val) => {
+        value = val
+      },
+      get: () => {
+        if (value === undefined) {
+          return defaultValue
+        }
+
+        return value
+      }
+    },
+    [`has${sentenceCaseName}`]: {
+      configurable: true,
+      value: () => {
+        return value !== undefined
+      }
+    },
+    [`set${sentenceCaseName}`]: {
+      configurable: true,
+      value: (val) => {
+        value = val
+      }
+    },
+    [`get${sentenceCaseName}`]: {
+      configurable: true,
+      value: () => {
+        return value
+      }
+    },
+    [`clear${sentenceCaseName}`]: {
+      configurable: true,
+      value: () => {
+        value = undefined
+        obj[name] = undefined
+      }
+    }
+  })
+}
+
+function compileDecode (m, resolve, enc) {
+  const requiredFields = []
+  const fields = {}
+  const oneofFields = []
+  const vals = []
+
+  for (var i = 0; i < enc.length; i++) {
+    const field = m.fields[i]
+
+    fields[field.tag] = i
+
+    const def = field.options && field.options.default
+    const resolved = resolve(field.type, m.id, false)
+    vals[i] = [def, resolved && resolved.values]
+
+    m.fields[i].packed = field.repeated && field.options && field.options.packed && field.options.packed !== 'false'
+
+    if (field.required) {
+      requiredFields.push(field.name)
+    }
+
+    if (field.oneof) {
+      oneofFields.push(field.name)
+    }
+  }
+
+  function decodeField (e, field, obj, buf, dataView, offset, i) {
+    const name = field.name
+
+    if (field.oneof) {
+      // clear already defined oneof fields
+      const props = Object.keys(obj)
+      for (var j = 0; j < props.length; j++) {
+        if (oneofFields.indexOf(props[j]) > -1) {
+          const sentenceCase = toSentenceCase(props[j])
+          delete obj[`has${sentenceCase}`]
+          delete obj[`get${sentenceCase}`]
+          delete obj[`set${sentenceCase}`]
+          delete obj[`clear${sentenceCase}`]
+          delete obj[props[j]]
+        }
+      }
+    }
+
+    let value
+
+    if (e.message) {
+      const len = varint.decode(buf, offset)
+      offset += varint.decode.bytes
+
+      const decoded = e.decode(buf, dataView, offset, offset + len)
+
+      if (field.map) {
+        value = obj[name] || {}
+        value[decoded.key] = decoded.value
+      } else if (field.repeated) {
+        value = obj[name] || []
+        value.push(decoded)
+      } else {
+        value = decoded
+      }
+    } else {
+      if (field.repeated) {
+        value = obj[name] || []
+        value.push(e.decode(buf, dataView, offset))
+      } else {
+        value = e.decode(buf, dataView, offset)
+      }
+    }
+
+    addPropertyAccessors(obj, name, value)
+
+    offset += e.decode.bytes
+
+    return offset
+  }
+
+  return function decode (buf, view, offset, end) {
+    if (offset == null) {
+      offset = 0
+    }
+
+    if (end == null) {
+      end = buf.length
+    }
+
+    if (!(end <= buf.length && offset <= buf.length)) {
+      throw new Error('Decoded message is not valid')
+    }
+
+    if (!view) {
+      view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+    }
+
+    var oldOffset = offset
+    var obj = {}
+    var field
+
+    while (true) {
+      if (end <= offset) {
+        // finished
+
+        // check required methods
+        var name = ''
+        var j = 0
+        for (j = 0; j < requiredFields.length; j++) {
+          name = requiredFields[j]
+          if (!defined(obj[name])) {
+            throw new Error('Decoded message is not valid, missing required field: ' + name)
+          }
+        }
+
+        // fill out missing defaults
+        var val
+        var def
+        for (j = 0; j < enc.length; j++) {
+          field = m.fields[j]
+          def = vals[j][0]
+          val = vals[j][1]
+          name = field.name
+          let defaultVal
+
+          if (Object.prototype.hasOwnProperty.call(obj, name)) {
+            continue
+          }
+
+          var done = false
+
+          if (field.oneof) {
+            var props = Object.keys(obj)
+
+            for (var k = 0; k < props.length; k++) {
+              if (oneofFields.indexOf(props[k]) > -1) {
+                done = true
+                break
+              }
+            }
+          }
+
+          if (done) {
+            continue
+          }
+
+          if (val) { // is enum
+            if (field.repeated) {
+              def = []
+            } else {
+              def = (def && val[def]) ? val[def].value : val[Object.keys(val)[0]].value
+              def = parseInt(def || 0, 10)
+            }
+          } else {
+            defaultVal = defaultValue(field)
+            def = coerceValue(field, def)
+          }
+
+          addPropertyAccessors(obj, name, def, defaultVal)
+        }
+
+        decode.bytes = offset - oldOffset
+        return obj
+      }
+
+      var prefix = varint.decode(buf, offset)
+      offset += varint.decode.bytes
+      var tag = prefix >> 3
+
+      var i = fields[tag]
+
+      if (i == null) {
+        offset = skip(prefix & 7, buf, view, offset)
+        continue
+      }
+
+      var e = enc[i]
+      field = m.fields[i]
+
+      if (field.packed) {
+        var packedEnd = varint.decode(buf, offset)
+        offset += varint.decode.bytes
+        packedEnd += offset
+
+        while (offset < packedEnd) {
+          offset = decodeField(e, field, obj, buf, view, offset, i)
+        }
+      } else {
+        offset = decodeField(e, field, obj, buf, view, offset, i)
+      }
+    }
+  }
+}
+
+var skip = function (type, buffer, view, offset) {
+  switch (type) {
+    case 0:
+      varint.decode(buffer, offset)
+      return offset + varint.decode.bytes
+
+    case 1:
+      return offset + 8
+
+    case 2:
+      var len = varint.decode(buffer, offset)
+      return offset + varint.decode.bytes + len
+
+    case 3:
+    case 4:
+      throw new Error('Groups are not supported')
+
+    case 5:
+      return offset + 4
+    default:
+      throw new Error('Unknown wire type: ' + type)
+  }
+}
+
+var defaultValue = function (f) {
+  if (f.map) return {}
+  if (f.repeated) return []
+
+  switch (f.type) {
+    case 'string':
+      return ''
+    case 'bool':
+      return false
+    case 'float':
+    case 'double':
+    case 'sfixed32':
+    case 'fixed32':
+    case 'varint':
+    case 'enum':
+    case 'uint64':
+    case 'uint32':
+    case 'int64':
+    case 'int32':
+    case 'sint64':
+    case 'sint32':
+      return 0
+    default:
+      return null
+  }
+}
+
+var coerceValue = function (f, def) {
+  if (def === undefined) {
+    return def
+  }
+
+  switch (f.type) {
+    case 'bool':
+      return def === 'true'
+    case 'float':
+    case 'double':
+    case 'sfixed32':
+    case 'fixed32':
+    case 'varint':
+    case 'enum':
+    case 'uint64':
+    case 'uint32':
+    case 'int64':
+    case 'int32':
+    case 'sint64':
+    case 'sint32':
+      return parseInt(def, 10)
+    default:
+      return def
+  }
+}
+
+module.exports = compileDecode
+
+
+/***/ }),
+
+/***/ 9611:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+var defined = (__webpack_require__(3864)/* .defined */ .r)
+var varint = __webpack_require__(138)
+
+function compileEncode (m, resolve, enc, oneofs, encodingLength) {
+  const oneofsKeys = Object.keys(oneofs)
+  const encLength = enc.length
+  const ints = {}
+  for (let i = 0; i < encLength; i++) {
+    ints[i] = {
+      p: varint.encode(m.fields[i].tag << 3 | 2),
+      h: varint.encode(m.fields[i].tag << 3 | enc[i].type)
+    }
+
+    const field = m.fields[i]
+    m.fields[i].packed = field.repeated && field.options && field.options.packed && field.options.packed !== 'false'
+  }
+
+  function encodeField (buf, view, offset, h, e, packed, innerVal) {
+    let j = 0
+    if (!packed) {
+      for (j = 0; j < h.length; j++) {
+        buf[offset++] = h[j]
+      }
+    }
+
+    if (e.message) {
+      varint.encode(e.encodingLength(innerVal), buf, offset)
+      offset += varint.encode.bytes
+    }
+
+    e.encode(innerVal, buf, view, offset)
+
+    return offset + e.encode.bytes
+  }
+
+  return function encode (obj, buf, view, offset = 0) {
+    if (buf == null) {
+      buf = new Uint8Array(encodingLength(obj))
+    }
+
+    if (view == null) {
+      view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+    }
+
+    const oldOffset = offset
+    const objKeys = Object.keys(obj)
+    let i = 0
+
+    // oneof checks
+
+    let match = false
+    for (i = 0; i < oneofsKeys.length; i++) {
+      const name = oneofsKeys[i]
+      const prop = oneofs[i]
+      if (objKeys.indexOf(prop) > -1) {
+        if (match) {
+          throw new Error('only one of the properties defined in oneof ' + name + ' can be set')
+        }
+
+        match = true
+      }
+    }
+
+    for (i = 0; i < encLength; i++) {
+      const e = enc[i]
+      const field = m.fields[i] // was f
+      let val = obj[field.name]
+      let j = 0
+
+      if (!defined(val)) {
+        if (field.required) {
+          throw new Error(field.name + ' is required')
+        }
+        continue
+      }
+      const p = ints[i].p
+      const h = ints[i].h
+
+      const packed = field.packed
+
+      if (field.map) {
+        const tmp = Object.keys(val)
+        for (j = 0; j < tmp.length; j++) {
+          tmp[j] = {
+            key: tmp[j],
+            value: val[tmp[j]]
+          }
+        }
+        val = tmp
+      }
+
+      if (packed) {
+        let packedLen = 0
+        for (j = 0; j < val.length; j++) {
+          if (!Object.prototype.hasOwnProperty.call(val, j)) {
+            continue
+          }
+
+          packedLen += e.encodingLength(val[j])
+        }
+
+        if (packedLen) {
+          for (j = 0; j < h.length; j++) {
+            buf[offset++] = p[j]
+          }
+          varint.encode(packedLen, buf, offset)
+          offset += varint.encode.bytes
+        }
+      }
+
+      if (field.repeated) {
+        let innerVal
+        for (j = 0; j < val.length; j++) {
+          innerVal = val[j]
+          if (!defined(innerVal)) {
+            continue
+          }
+
+          offset = encodeField(buf, view, offset, h, e, packed, innerVal)
+        }
+      } else {
+        offset = encodeField(buf, view, offset, h, e, packed, val)
+      }
+    }
+
+    encode.bytes = offset - oldOffset
+    return buf
+  }
+}
+
+module.exports = compileEncode
+
+
+/***/ }),
+
+/***/ 1216:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+var defined = (__webpack_require__(3864)/* .defined */ .r)
+var varint = __webpack_require__(138)
+
+function compileEncodingLength (m, enc, oneofs) {
+  const oneofsKeys = Object.keys(oneofs)
+  const encLength = enc.length
+
+  const hls = new Array(encLength)
+
+  for (let i = 0; i < m.fields.length; i++) {
+    hls[i] = varint.encodingLength(m.fields[i].tag << 3 | enc[i].type)
+
+    const field = m.fields[i]
+    m.fields[i].packed = field.repeated && field.options && field.options.packed && field.options.packed !== 'false'
+  }
+
+  return function encodingLength (obj) {
+    let length = 0
+    let i = 0
+    let j = 0
+
+    for (i = 0; i < oneofsKeys.length; i++) {
+      const name = oneofsKeys[i]
+      const props = oneofs[name]
+
+      let match = false
+      for (j = 0; j < props.length; j++) {
+        if (defined(obj[props[j]])) {
+          if (match) {
+            throw new Error('only one of the properties defined in oneof ' + name + ' can be set')
+          }
+          match = true
+        }
+      }
+    }
+
+    for (i = 0; i < encLength; i++) {
+      const e = enc[i]
+      const field = m.fields[i]
+      let val = obj[field.name]
+      const hl = hls[i]
+      let len
+
+      if (!defined(val)) {
+        if (field.required) {
+          throw new Error(field.name + ' is required')
+        }
+
+        continue
+      }
+
+      if (field.map) {
+        const tmp = Object.keys(val)
+        for (j = 0; j < tmp.length; j++) {
+          tmp[j] = {
+            key: tmp[j],
+            value: val[tmp[j]]
+          }
+        }
+
+        val = tmp
+      }
+
+      if (field.packed) {
+        let packedLen = 0
+        for (j = 0; j < val.length; j++) {
+          if (!defined(val[j])) {
+            continue
+          }
+          len = e.encodingLength(val[j])
+          packedLen += len
+
+          if (e.message) {
+            packedLen += varint.encodingLength(len)
+          }
+        }
+
+        if (packedLen) {
+          length += hl + packedLen + varint.encodingLength(packedLen)
+        }
+      } else if (field.repeated) {
+        for (j = 0; j < val.length; j++) {
+          if (!defined(val[j])) {
+            continue
+          }
+
+          len = e.encodingLength(val[j])
+          length += hl + len + (e.message ? varint.encodingLength(len) : 0)
+        }
+      } else {
+        len = e.encodingLength(val)
+        length += hl + len + (e.message ? varint.encodingLength(len) : 0)
+      }
+    }
+
+    return length
+  }
+}
+
+module.exports = compileEncodingLength
+
+
+/***/ }),
+
+/***/ 104:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const encoder = __webpack_require__(9851)
+
+function boolEncodingLength () {
+  return 1
+}
+
+function boolEncode (value, buffer, dataView, offset) {
+  buffer[offset] = value ? 1 : 0
+  boolEncode.bytes = 1
+}
+
+function boolDecode (buffer, dataView, offset) {
+  const bool = buffer[offset] > 0
+  boolDecode.bytes = 1
+
+  return bool
+}
+
+module.exports = encoder(0, boolEncode, boolDecode, boolEncodingLength)
+
+
+/***/ }),
+
+/***/ 1092:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const varint = __webpack_require__(138)
+const encoder = __webpack_require__(9851)
+
+function bytesBufferLength (val) {
+  return val.byteLength
+}
+
+function bytesEncodingLength (val) {
+  const len = bytesBufferLength(val)
+  return varint.encodingLength(len) + len
+}
+
+function bytesEncode (val, buffer, dataView, offset) {
+  const oldOffset = offset
+  const len = bytesBufferLength(val)
+
+  varint.encode(len, buffer, offset)
+  offset += varint.encode.bytes
+
+  buffer.set(val, offset)
+  offset += len
+
+  bytesEncode.bytes = offset - oldOffset
+}
+
+function bytesDecode (buffer, dataView, offset) {
+  const oldOffset = offset
+
+  const len = varint.decode(buffer, offset)
+  offset += varint.decode.bytes
+
+  const val = buffer.slice(offset, offset + len)
+  offset += val.length
+
+  bytesDecode.bytes = offset - oldOffset
+
+  return val
+}
+
+module.exports = encoder(2, bytesEncode, bytesDecode, bytesEncodingLength)
+
+
+/***/ }),
+
+/***/ 9620:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const encoder = __webpack_require__(9851)
+
+function doubleEncodingLength () {
+  return 8
+}
+
+function doubleEncode (val, buffer, dataView, offset) {
+  dataView.setFloat64(offset, val, true)
+  doubleEncode.bytes = 8
+}
+
+function doubleDecode (buffer, dataView, offset) {
+  const val = dataView.getFloat64(offset, true)
+  doubleDecode.bytes = 8
+
+  return val
+}
+
+module.exports = encoder(1, doubleEncode, doubleDecode, doubleEncodingLength)
+
+
+/***/ }),
+
+/***/ 9851:
+/***/ (function(module) {
+
+"use strict";
+
+
+function encoder (type, encode, decode, encodingLength) {
+  encode.bytes = decode.bytes = 0
+
+  return {
+    type: type,
+    encode: encode,
+    decode: decode,
+    encodingLength: encodingLength
+  }
+}
+
+module.exports = encoder
+
+
+/***/ }),
+
+/***/ 9018:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const encoder = __webpack_require__(9851)
+
+function fixed32EncodingLength (val) {
+  return 4
+}
+
+function fixed32Encode (val, buffer, dataView, offset) {
+  dataView.setUint32(offset, val, true)
+  fixed32Encode.bytes = 4
+}
+
+function fixed32Decode (buffer, dataView, offset) {
+  const val = dataView.getUint32(offset, true)
+  fixed32Decode.bytes = 4
+
+  return val
+}
+
+module.exports = encoder(5, fixed32Encode, fixed32Decode, fixed32EncodingLength)
+
+
+/***/ }),
+
+/***/ 3334:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const encoder = __webpack_require__(9851)
+
+function fixed64EncodingLength () {
+  return 8
+}
+
+function fixed64Encode (val, buffer, dataView, offset) {
+  for (const byte of val) {
+    buffer[offset] = byte
+    offset++
+  }
+
+  fixed64Encode.bytes = 8
+}
+
+function fixed64Decode (buffer, dataView, offset) {
+  const val = buffer.slice(offset, offset + 8)
+  fixed64Decode.bytes = 8
+
+  return val
+}
+
+module.exports = encoder(1, fixed64Encode, fixed64Decode, fixed64EncodingLength)
+
+
+/***/ }),
+
+/***/ 4606:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const encoder = __webpack_require__(9851)
+
+function floatEncodingLength () {
+  return 4
+}
+
+function floatEncode (val, buffer, dataView, offset) {
+  dataView.setFloat32(offset, val, true)
+  floatEncode.bytes = 4
+}
+
+function floatDecode (buffer, dataView, offset) {
+  const val = dataView.getFloat32(offset, true)
+  floatDecode.bytes = 4
+
+  return val
+}
+
+module.exports = encoder(5, floatEncode, floatDecode, floatEncodingLength)
+
+
+/***/ }),
+
+/***/ 119:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+"use strict";
+
+
+exports.make = __webpack_require__(9851)
+exports.bytes = __webpack_require__(1092)
+exports.string = __webpack_require__(6626)
+exports.bool = __webpack_require__(104)
+exports.int32 = __webpack_require__(5282)
+exports.int64 = __webpack_require__(4291)
+exports.sint32 =
+exports.sint64 = __webpack_require__(2407)
+exports.uint32 =
+exports.uint64 =
+exports["enum"] =
+exports.varint = __webpack_require__(3083)
+
+// we cannot represent these in javascript so we just use buffers
+exports.fixed64 =
+exports.sfixed64 = __webpack_require__(3334)
+exports.double = __webpack_require__(9620)
+exports.fixed32 = __webpack_require__(9018)
+exports.sfixed32 = __webpack_require__(2730)
+exports.float = __webpack_require__(4606)
+
+
+/***/ }),
+
+/***/ 5282:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const varint = __webpack_require__(138)
+const encoder = __webpack_require__(9851)
+
+function in32Encode (val, buffer, dataView, offset) {
+  varint.encode(val < 0 ? val + 4294967296 : val, buffer, offset)
+  in32Encode.bytes = varint.encode.bytes
+}
+
+function int32Decode (buffer, dataView, offset) {
+  const val = varint.decode(buffer, offset)
+  int32Decode.bytes = varint.decode.bytes
+
+  return val > 2147483647 ? val - 4294967296 : val
+}
+
+function int32EncodingLength (val) {
+  return varint.encodingLength(val < 0 ? val + 4294967296 : val)
+}
+
+module.exports = encoder(0, in32Encode, int32Decode, int32EncodingLength)
+
+
+/***/ }),
+
+/***/ 4291:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const varint = __webpack_require__(138)
+const encoder = __webpack_require__(9851)
+
+function int64Encode (val, buffer, dataView, offset) {
+  if (val < 0) {
+    const last = offset + 9
+    varint.encode(val * -1, buffer, offset)
+
+    offset += varint.encode.bytes - 1
+    buffer[offset] = buffer[offset] | 0x80
+
+    while (offset < last - 1) {
+      offset++
+      buffer[offset] = 0xff
+    }
+    buffer[last] = 0x01
+
+    int64Encode.bytes = 10
+  } else {
+    varint.encode(val, buffer, offset)
+    int64Encode.bytes = varint.encode.bytes
+  }
+}
+
+function int64Decode (buffer, dataView, offset) {
+  let val = varint.decode(buffer, offset)
+
+  if (val >= Math.pow(2, 63)) {
+    let limit = 9
+    while (buffer[offset + limit - 1] === 0xff) limit--
+    limit = limit || 9
+    const subset = buffer.subarray(offset, offset + limit)
+    subset[limit - 1] = subset[limit - 1] & 0x7f
+    val = -1 * varint.decode(subset, 0)
+    int64Decode.bytes = 10
+  } else {
+    int64Decode.bytes = varint.decode.bytes
+  }
+
+  return val
+}
+
+function int64EncodingLength (val) {
+  return val < 0 ? 10 : varint.encodingLength(val)
+}
+
+module.exports = encoder(0, int64Encode, int64Decode, int64EncodingLength)
+
+
+/***/ }),
+
+/***/ 2730:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const encoder = __webpack_require__(9851)
+
+function sfixed32EncodingLength (val) {
+  return 4
+}
+
+function sfixed32Encode (val, buffer, dataView, offset) {
+  dataView.setInt32(offset, val, true)
+  sfixed32Encode.bytes = 4
+}
+
+function sfixed32Decode (buffer, dataView, offset) {
+  const val = dataView.getInt32(offset, true)
+  sfixed32Decode.bytes = 4
+
+  return val
+}
+
+module.exports = encoder(5, sfixed32Encode, sfixed32Decode, sfixed32EncodingLength)
+
+
+/***/ }),
+
+/***/ 2407:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const svarint = __webpack_require__(1842)
+const encoder = __webpack_require__(9851)
+
+function svarintEncode (val, buffer, dataView, offset) {
+  svarint.encode(val, buffer, offset)
+
+  svarintEncode.bytes = svarint.encode.bytes
+}
+
+function svarintDecode (buffer, dataView, offset) {
+  const val = svarint.decode(buffer, offset)
+  svarintDecode.bytes = svarint.decode.bytes
+
+  return val
+}
+
+module.exports = encoder(0, svarintEncode, svarintDecode, svarint.encodingLength)
+
+
+/***/ }),
+
+/***/ 6626:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const varint = __webpack_require__(138)
+const { fromString: uint8ArrayFromString } = __webpack_require__(2217)
+const { toString: uint8ArrayToString } = __webpack_require__(2263)
+const encoder = __webpack_require__(9851)
+
+function stringEncodingLength (val) {
+  const len = uint8ArrayFromString(val).byteLength
+  return varint.encodingLength(len) + len
+}
+
+function stringEncode (val, buffer, dataView, offset) {
+  const oldOffset = offset
+  const len = uint8ArrayFromString(val).byteLength
+
+  varint.encode(len, buffer, offset, 'utf-8')
+  offset += varint.encode.bytes
+
+  const arr = uint8ArrayFromString(val)
+  buffer.set(arr, offset)
+  offset += arr.length
+
+  stringEncode.bytes = offset - oldOffset
+}
+
+function stringDecode (buffer, dataView, offset) {
+  const oldOffset = offset
+
+  const len = varint.decode(buffer, offset)
+  offset += varint.decode.bytes
+
+  const val = uint8ArrayToString(buffer.subarray(offset, offset + len))
+  offset += len
+
+  stringDecode.bytes = offset - oldOffset
+
+  return val
+}
+
+module.exports = encoder(2, stringEncode, stringDecode, stringEncodingLength)
+
+
+/***/ }),
+
+/***/ 3083:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const varint = __webpack_require__(138)
+const encoder = __webpack_require__(9851)
+
+function varintEncode (val, buffer, dataView, offset) {
+  varint.encode(val, buffer, offset)
+
+  varintEncode.bytes = varint.encode.bytes
+}
+
+function varintDecode (buffer, dataView, offset) {
+  const val = varint.decode(buffer, offset)
+  varintDecode.bytes = varint.decode.bytes
+
+  return val
+}
+
+module.exports = encoder(0, varintEncode, varintDecode, varint.encodingLength)
+
+
+/***/ }),
+
+/***/ 7961:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+const encodings = __webpack_require__(119)
+const compileDecode = __webpack_require__(7986)
+const compileEncode = __webpack_require__(9611)
+const compileEncodingLength = __webpack_require__(1216)
+const varint = __webpack_require__(138)
+
+const flatten = function (values) {
+  if (!values) return null
+  const result = {}
+  Object.keys(values).forEach(function (k) {
+    result[k] = values[k].value
+  })
+  return result
+}
+
+module.exports = function (schema, extraEncodings) {
+  const messages = {}
+  const enums = {}
+  const cache = {}
+
+  const visit = function (schema, prefix) {
+    if (schema.enums) {
+      schema.enums.forEach(function (e) {
+        e.id = prefix + (prefix ? '.' : '') + e.name
+        enums[e.id] = e
+        visit(e, e.id)
+      })
+    }
+    if (schema.messages) {
+      schema.messages.forEach(function (m) {
+        m.id = prefix + (prefix ? '.' : '') + m.name
+        messages[m.id] = m
+        m.fields.forEach(function (f) {
+          if (!f.map) return
+
+          const name = 'Map_' + f.map.from + '_' + f.map.to
+          const map = {
+            name: name,
+            enums: [],
+            messages: [],
+            fields: [{
+              name: 'key',
+              type: f.map.from,
+              tag: 1,
+              repeated: false,
+              required: true
+            }, {
+              name: 'value',
+              type: f.map.to,
+              tag: 2,
+              repeated: false,
+              required: false
+            }],
+            extensions: null,
+            id: prefix + (prefix ? '.' : '') + name
+          }
+
+          if (!messages[map.id]) {
+            messages[map.id] = map
+            schema.messages.push(map)
+          }
+          f.type = name
+          f.repeated = true
+        })
+        visit(m, m.id)
+      })
+    }
+  }
+
+  visit(schema, '')
+
+  const compileEnum = function (e) {
+    const values = Object.keys(e.values || []).map(function (k) {
+      return parseInt(e.values[k].value, 10)
+    })
+
+    const encode = function enumEncode (val, buf, view, offset) {
+      if (!values.length || values.indexOf(val) === -1) {
+        throw new Error('Invalid enum value: ' + val)
+      }
+      varint.encode(val, buf, offset)
+      enumEncode.bytes = varint.encode.bytes
+      return buf
+    }
+
+    const decode = function enumDecode (buf, view, offset) {
+      var val = varint.decode(buf, offset)
+      if (!values.length || values.indexOf(val) === -1) {
+        throw new Error('Invalid enum value: ' + val)
+      }
+      enumDecode.bytes = varint.decode.bytes
+      return val
+    }
+
+    return encodings.make(0, encode, decode, varint.encodingLength)
+  }
+
+  const compileMessage = function (m, exports) {
+    m.messages.forEach(function (nested) {
+      exports[nested.name] = resolve(nested.name, m.id)
+    })
+
+    m.enums.forEach(function (val) {
+      exports[val.name] = flatten(val.values)
+    })
+
+    exports.type = 2
+    exports.message = true
+    exports.name = m.name
+
+    const oneofs = {}
+
+    m.fields.forEach(function (f) {
+      if (!f.oneof) return
+      if (!oneofs[f.oneof]) oneofs[f.oneof] = []
+      oneofs[f.oneof].push(f.name)
+    })
+
+    const enc = m.fields.map(function (f) {
+      return resolve(f.type, m.id)
+    })
+
+    const encodingLength = compileEncodingLength(m, enc, oneofs)
+    const encode = compileEncode(m, resolve, enc, oneofs, encodingLength)
+    const decode = compileDecode(m, resolve, enc)
+
+    // end of compilation - return all the things
+
+    encode.bytes = decode.bytes = 0
+
+    exports.buffer = true
+    exports.encode = encode
+    exports.decode = decode
+    exports.encodingLength = encodingLength
+
+    return exports
+  }
+
+  const resolve = function (name, from, compile) {
+    if (extraEncodings && extraEncodings[name]) return extraEncodings[name]
+    if (encodings[name]) return encodings[name]
+
+    const m = (from ? from + '.' + name : name).split('.')
+      .map(function (part, i, list) {
+        return list.slice(0, i).concat(name).join('.')
+      })
+      .reverse()
+      .reduce(function (result, id) {
+        return result || messages[id] || enums[id]
+      }, null)
+
+    if (compile === false) return m
+    if (!m) throw new Error('Could not resolve ' + name)
+
+    if (m.values) return compileEnum(m)
+    const res = cache[m.id] || compileMessage(m, cache[m.id] = {})
+    return res
+  }
+
+  return (schema.enums || []).concat((schema.messages || []).map(function (message) {
+    return resolve(message.id)
+  }))
+}
+
+
+/***/ }),
+
+/***/ 3864:
+/***/ (function(__unused_webpack_module, exports) {
+
+"use strict";
+
+
+exports.r = function (val) {
+  return val !== null && val !== undefined && (typeof val !== 'number' || !isNaN(val))
+}
+
+
+/***/ }),
+
+/***/ 7160:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+"use strict";
+
+
+var schema = __webpack_require__(1626)
+var compile = __webpack_require__(7961)
+
+var flatten = function (values) {
+  if (!values) return null
+  var result = {}
+  Object.keys(values).forEach(function (k) {
+    result[k] = values[k].value
+  })
+  return result
+}
+
+module.exports = function (proto, opts) {
+  if (!opts) opts = {}
+  if (!proto) throw new Error('Pass in a .proto string or a protobuf-schema parsed object')
+
+  var sch = (typeof proto === 'object' && !(proto instanceof Uint8Array)) ? proto : schema.parse(proto)
+
+  // to not make toString,toJSON enumarable we make a fire-and-forget prototype
+  var Messages = function () {
+    var self = this
+
+    compile(sch, opts.encodings || {}).forEach(function (m) {
+      self[m.name] = flatten(m.values) || m
+    })
+  }
+
+  Messages.prototype.toString = function () {
+    return schema.stringify(sch)
+  }
+
+  Messages.prototype.toJSON = function () {
+    return sch
+  }
+
+  return new Messages()
+}
+
+
+/***/ }),
+
+/***/ 1842:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+var varint = __webpack_require__(9365)
+exports.encode = function encode (v, b, o) {
+  v = v >= 0 ? v*2 : v*-2 - 1
+  var r = varint.encode(v, b, o)
+  encode.bytes = varint.encode.bytes
+  return r
+}
+exports.decode = function decode (b, o) {
+  var v = varint.decode(b, o)
+  decode.bytes = varint.decode.bytes
+  return v & 1 ? (v+1) / -2 : v / 2
+}
+
+exports.encodingLength = function (v) {
+  return varint.encodingLength(v >= 0 ? v*2 : v*-2 - 1)
+}
+
+
+/***/ }),
+
+/***/ 7721:
+/***/ (function(module) {
+
+module.exports = read
+
+var MSB = 0x80
+  , REST = 0x7F
+
+function read(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length
+
+  do {
+    if (counter >= l) {
+      read.bytes = 0
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++]
+    res += shift < 28
+      ? (b & REST) << shift
+      : (b & REST) * Math.pow(2, shift)
+    shift += 7
+  } while (b >= MSB)
+
+  read.bytes = counter - offset
+
+  return res
+}
+
+
+/***/ }),
+
+/***/ 508:
+/***/ (function(module) {
+
+module.exports = encode
+
+var MSB = 0x80
+  , REST = 0x7F
+  , MSBALL = ~REST
+  , INT = Math.pow(2, 31)
+
+function encode(num, out, offset) {
+  out = out || []
+  offset = offset || 0
+  var oldOffset = offset
+
+  while(num >= INT) {
+    out[offset++] = (num & 0xFF) | MSB
+    num /= 128
+  }
+  while(num & MSBALL) {
+    out[offset++] = (num & 0xFF) | MSB
+    num >>>= 7
+  }
+  out[offset] = num | 0
+  
+  encode.bytes = offset - oldOffset + 1
+  
+  return out
+}
+
+
+/***/ }),
+
+/***/ 9365:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+module.exports = {
+    encode: __webpack_require__(508)
+  , decode: __webpack_require__(7721)
+  , encodingLength: __webpack_require__(8184)
+}
+
+
+/***/ }),
+
+/***/ 8184:
+/***/ (function(module) {
+
+
+var N1 = Math.pow(2,  7)
+var N2 = Math.pow(2, 14)
+var N3 = Math.pow(2, 21)
+var N4 = Math.pow(2, 28)
+var N5 = Math.pow(2, 35)
+var N6 = Math.pow(2, 42)
+var N7 = Math.pow(2, 49)
+var N8 = Math.pow(2, 56)
+var N9 = Math.pow(2, 63)
+
+module.exports = function (value) {
+  return (
+    value < N1 ? 1
+  : value < N2 ? 2
+  : value < N3 ? 3
+  : value < N4 ? 4
+  : value < N5 ? 5
+  : value < N6 ? 6
+  : value < N7 ? 7
+  : value < N8 ? 8
+  : value < N9 ? 9
+  :              10
+  )
+}
+
+
+/***/ }),
+
+/***/ 2217:
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "fromString": function() { return /* binding */ fromString; }
+/* harmony export */ });
+/* harmony import */ var _util_bases_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(660);
+
+function fromString(string, encoding = 'utf8') {
+  const base = _util_bases_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z[encoding];
+  if (!base) {
+    throw new Error(`Unsupported encoding "${ encoding }"`);
+  }
+  return base.decoder.decode(`${ base.prefix }${ string }`);
+}
+
+/***/ }),
+
+/***/ 2263:
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   "toString": function() { return /* binding */ toString; }
+/* harmony export */ });
+/* harmony import */ var _util_bases_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(660);
+
+function toString(array, encoding = 'utf8') {
+  const base = _util_bases_js__WEBPACK_IMPORTED_MODULE_0__/* ["default"] */ .Z[encoding];
+  if (!base) {
+    throw new Error(`Unsupported encoding "${ encoding }"`);
+  }
+  return base.encoder.encode(array).substring(1);
+}
+
+/***/ }),
+
+/***/ 660:
+/***/ (function(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "Z": function() { return /* binding */ util_bases; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/identity.js
+var identity_namespaceObject = {};
+__webpack_require__.r(identity_namespaceObject);
+__webpack_require__.d(identity_namespaceObject, {
+  "identity": function() { return identity; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/base2.js
+var base2_namespaceObject = {};
+__webpack_require__.r(base2_namespaceObject);
+__webpack_require__.d(base2_namespaceObject, {
+  "base2": function() { return base2; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/base8.js
+var base8_namespaceObject = {};
+__webpack_require__.r(base8_namespaceObject);
+__webpack_require__.d(base8_namespaceObject, {
+  "base8": function() { return base8; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/base10.js
+var base10_namespaceObject = {};
+__webpack_require__.r(base10_namespaceObject);
+__webpack_require__.d(base10_namespaceObject, {
+  "base10": function() { return base10; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/base16.js
+var base16_namespaceObject = {};
+__webpack_require__.r(base16_namespaceObject);
+__webpack_require__.d(base16_namespaceObject, {
+  "base16": function() { return base16; },
+  "base16upper": function() { return base16upper; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/base32.js
+var base32_namespaceObject = {};
+__webpack_require__.r(base32_namespaceObject);
+__webpack_require__.d(base32_namespaceObject, {
+  "base32": function() { return base32_base32; },
+  "base32hex": function() { return base32hex; },
+  "base32hexpad": function() { return base32hexpad; },
+  "base32hexpadupper": function() { return base32hexpadupper; },
+  "base32hexupper": function() { return base32hexupper; },
+  "base32pad": function() { return base32pad; },
+  "base32padupper": function() { return base32padupper; },
+  "base32upper": function() { return base32upper; },
+  "base32z": function() { return base32z; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/base36.js
+var base36_namespaceObject = {};
+__webpack_require__.r(base36_namespaceObject);
+__webpack_require__.d(base36_namespaceObject, {
+  "base36": function() { return base36; },
+  "base36upper": function() { return base36upper; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/base58.js
+var base58_namespaceObject = {};
+__webpack_require__.r(base58_namespaceObject);
+__webpack_require__.d(base58_namespaceObject, {
+  "base58btc": function() { return base58_base58btc; },
+  "base58flickr": function() { return base58flickr; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/bases/base64.js
+var base64_namespaceObject = {};
+__webpack_require__.r(base64_namespaceObject);
+__webpack_require__.d(base64_namespaceObject, {
+  "base64": function() { return base64; },
+  "base64pad": function() { return base64pad; },
+  "base64url": function() { return base64url; },
+  "base64urlpad": function() { return base64urlpad; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/hashes/sha2-browser.js
+var sha2_browser_namespaceObject = {};
+__webpack_require__.r(sha2_browser_namespaceObject);
+__webpack_require__.d(sha2_browser_namespaceObject, {
+  "sha256": function() { return sha256; },
+  "sha512": function() { return sha512; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/hashes/identity.js
+var hashes_identity_namespaceObject = {};
+__webpack_require__.r(hashes_identity_namespaceObject);
+__webpack_require__.d(hashes_identity_namespaceObject, {
+  "identity": function() { return identity_identity; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/codecs/raw.js
+var raw_namespaceObject = {};
+__webpack_require__.r(raw_namespaceObject);
+__webpack_require__.d(raw_namespaceObject, {
+  "code": function() { return raw_code; },
+  "decode": function() { return raw_decode; },
+  "encode": function() { return raw_encode; },
+  "name": function() { return raw_name; }
+});
+
+// NAMESPACE OBJECT: ./node_modules/multiformats/esm/src/codecs/json.js
+var json_namespaceObject = {};
+__webpack_require__.r(json_namespaceObject);
+__webpack_require__.d(json_namespaceObject, {
+  "code": function() { return json_code; },
+  "decode": function() { return json_decode; },
+  "encode": function() { return json_encode; },
+  "name": function() { return json_name; }
+});
+
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/vendor/base-x.js
+function base(ALPHABET, name) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError('Alphabet too long');
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + ' is ambiguous');
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source) {
+    if (source instanceof Uint8Array);
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError('Expected Uint8Array');
+    }
+    if (source.length === 0) {
+      return '';
+    }
+    var zeroes = 0;
+    var length = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i = 0;
+      for (var it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error('Non-zero carry');
+      }
+      length = i;
+      pbegin++;
+    }
+    var it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== 'string') {
+      throw new TypeError('Expected String');
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === ' ') {
+      return;
+    }
+    var zeroes = 0;
+    var length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i = 0;
+      for (var it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error('Non-zero carry');
+      }
+      length = i;
+      psz++;
+    }
+    if (source[psz] === ' ') {
+      return;
+    }
+    var it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j = zeroes;
+    while (it4 !== size) {
+      vch[j++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode(string) {
+    var buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${ name } character`);
+  }
+  return {
+    encode: encode,
+    decodeUnsafe: decodeUnsafe,
+    decode: decode
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+/* harmony default export */ var base_x = (_brrp__multiformats_scope_baseX);
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bytes.js
+const empty = new Uint8Array(0);
+const toHex = d => d.reduce((hex, byte) => hex + byte.toString(16).padStart(2, '0'), '');
+const fromHex = hex => {
+  const hexes = hex.match(/../g);
+  return hexes ? new Uint8Array(hexes.map(b => parseInt(b, 16))) : empty;
+};
+const equals = (aa, bb) => {
+  if (aa === bb)
+    return true;
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+};
+const bytes_coerce = o => {
+  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
+    return o;
+  if (o instanceof ArrayBuffer)
+    return new Uint8Array(o);
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error('Unknown type, must be binary type');
+};
+const isBinary = o => o instanceof ArrayBuffer || ArrayBuffer.isView(o);
+const fromString = str => new TextEncoder().encode(str);
+const bytes_toString = b => new TextDecoder().decode(b);
+
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base.js
+
+
+class Encoder {
+  constructor(name, prefix, baseEncode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${ this.prefix }${ this.baseEncode(bytes) }`;
+    } else {
+      throw Error('Unknown type, must be binary type');
+    }
+  }
+}
+class Decoder {
+  constructor(name, prefix, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === 'string') {
+      switch (text[0]) {
+      case this.prefix: {
+          return this.baseDecode(text.slice(1));
+        }
+      default: {
+          throw Error(`Unable to decode multibase string ${ JSON.stringify(text) }, ${ this.name } decoder only supports inputs prefixed with ${ this.prefix }`);
+        }
+      }
+    } else {
+      throw Error('Can only multibase decode strings');
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+}
+class ComposedDecoder {
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${ JSON.stringify(input) }, only inputs prefixed with ${ Object.keys(this.decoders) } are supported`);
+    }
+  }
+}
+const or = (left, right) => new ComposedDecoder({
+  ...left.decoders || { [left.prefix]: left },
+  ...right.decoders || { [right.prefix]: right }
+});
+class Codec {
+  constructor(name, prefix, baseEncode, baseDecode) {
+    this.name = name;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name, prefix, baseEncode);
+    this.decoder = new Decoder(name, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+}
+const from = ({name, prefix, encode, decode}) => new Codec(name, prefix, encode, decode);
+const baseX = ({prefix, name, alphabet}) => {
+  const {encode, decode} = base_x(alphabet, name);
+  return from({
+    prefix,
+    name,
+    encode,
+    decode: text => bytes_coerce(decode(text))
+  });
+};
+const decode = (string, alphabet, bitsPerChar, name) => {
+  const codes = {};
+  for (let i = 0; i < alphabet.length; ++i) {
+    codes[alphabet[i]] = i;
+  }
+  let end = string.length;
+  while (string[end - 1] === '=') {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = codes[string[i]];
+    if (value === undefined) {
+      throw new SyntaxError(`Non-${ name } character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || 255 & buffer << 8 - bits) {
+    throw new SyntaxError('Unexpected end of data');
+  }
+  return out;
+};
+const encode = (data, alphabet, bitsPerChar) => {
+  const pad = alphabet[alphabet.length - 1] === '=';
+  const mask = (1 << bitsPerChar) - 1;
+  let out = '';
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0; i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet[mask & buffer >> bits];
+    }
+  }
+  if (bits) {
+    out += alphabet[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while (out.length * bitsPerChar & 7) {
+      out += '=';
+    }
+  }
+  return out;
+};
+const rfc4648 = ({name, prefix, bitsPerChar, alphabet}) => {
+  return from({
+    prefix,
+    name,
+    encode(input) {
+      return encode(input, alphabet, bitsPerChar);
+    },
+    decode(input) {
+      return decode(input, alphabet, bitsPerChar, name);
+    }
+  });
+};
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/identity.js
+
+
+const identity = from({
+  prefix: '\0',
+  name: 'identity',
+  encode: buf => bytes_toString(buf),
+  decode: str => fromString(str)
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base2.js
+
+const base2 = rfc4648({
+  prefix: '0',
+  name: 'base2',
+  alphabet: '01',
+  bitsPerChar: 1
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base8.js
+
+const base8 = rfc4648({
+  prefix: '7',
+  name: 'base8',
+  alphabet: '01234567',
+  bitsPerChar: 3
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base10.js
+
+const base10 = baseX({
+  prefix: '9',
+  name: 'base10',
+  alphabet: '0123456789'
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base16.js
+
+const base16 = rfc4648({
+  prefix: 'f',
+  name: 'base16',
+  alphabet: '0123456789abcdef',
+  bitsPerChar: 4
+});
+const base16upper = rfc4648({
+  prefix: 'F',
+  name: 'base16upper',
+  alphabet: '0123456789ABCDEF',
+  bitsPerChar: 4
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base32.js
+
+const base32_base32 = rfc4648({
+  prefix: 'b',
+  name: 'base32',
+  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
+  bitsPerChar: 5
+});
+const base32upper = rfc4648({
+  prefix: 'B',
+  name: 'base32upper',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+  bitsPerChar: 5
+});
+const base32pad = rfc4648({
+  prefix: 'c',
+  name: 'base32pad',
+  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
+  bitsPerChar: 5
+});
+const base32padupper = rfc4648({
+  prefix: 'C',
+  name: 'base32padupper',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
+  bitsPerChar: 5
+});
+const base32hex = rfc4648({
+  prefix: 'v',
+  name: 'base32hex',
+  alphabet: '0123456789abcdefghijklmnopqrstuv',
+  bitsPerChar: 5
+});
+const base32hexupper = rfc4648({
+  prefix: 'V',
+  name: 'base32hexupper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+  bitsPerChar: 5
+});
+const base32hexpad = rfc4648({
+  prefix: 't',
+  name: 'base32hexpad',
+  alphabet: '0123456789abcdefghijklmnopqrstuv=',
+  bitsPerChar: 5
+});
+const base32hexpadupper = rfc4648({
+  prefix: 'T',
+  name: 'base32hexpadupper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
+  bitsPerChar: 5
+});
+const base32z = rfc4648({
+  prefix: 'h',
+  name: 'base32z',
+  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+  bitsPerChar: 5
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base36.js
+
+const base36 = baseX({
+  prefix: 'k',
+  name: 'base36',
+  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+});
+const base36upper = baseX({
+  prefix: 'K',
+  name: 'base36upper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base58.js
+
+const base58_base58btc = baseX({
+  name: 'base58btc',
+  prefix: 'z',
+  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+});
+const base58flickr = baseX({
+  name: 'base58flickr',
+  prefix: 'Z',
+  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/bases/base64.js
+
+const base64 = rfc4648({
+  prefix: 'm',
+  name: 'base64',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+  bitsPerChar: 6
+});
+const base64pad = rfc4648({
+  prefix: 'M',
+  name: 'base64pad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+  bitsPerChar: 6
+});
+const base64url = rfc4648({
+  prefix: 'u',
+  name: 'base64url',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+  bitsPerChar: 6
+});
+const base64urlpad = rfc4648({
+  prefix: 'U',
+  name: 'base64urlpad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
+  bitsPerChar: 6
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/vendor/varint.js
+var encode_1 = varint_encode;
+var MSB = 128, REST = 127, MSBALL = ~REST, INT = Math.pow(2, 31);
+function varint_encode(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  varint_encode.bytes = offset - oldOffset + 1;
+  return out;
+}
+var varint_decode = read;
+var MSB$1 = 128, REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError('Could not decode varint');
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var varint_length = function (value) {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+var varint_varint = {
+  encode: encode_1,
+  decode: varint_decode,
+  encodingLength: varint_length
+};
+var _brrp_varint = varint_varint;
+/* harmony default export */ var vendor_varint = (_brrp_varint);
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/varint.js
+
+const src_varint_decode = data => {
+  const code = varint.decode(data);
+  return [
+    code,
+    varint.decode.bytes
+  ];
+};
+const encodeTo = (int, target, offset = 0) => {
+  vendor_varint.encode(int, target, offset);
+  return target;
+};
+const encodingLength = int => {
+  return vendor_varint.encodingLength(int);
+};
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/hashes/digest.js
+
+
+const create = (code, digest) => {
+  const size = digest.byteLength;
+  const sizeOffset = encodingLength(code);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new digest_Digest(code, size, digest, bytes);
+};
+const digest_decode = multihash => {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = varint.decode(bytes);
+  const [size, digestOffset] = varint.decode(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error('Incorrect length');
+  }
+  return new digest_Digest(code, size, digest, bytes);
+};
+const digest_equals = (a, b) => {
+  if (a === b) {
+    return true;
+  } else {
+    return a.code === b.code && a.size === b.size && equalBytes(a.bytes, b.bytes);
+  }
+};
+class digest_Digest {
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+}
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/hashes/hasher.js
+
+const hasher_from = ({name, code, encode}) => new Hasher(name, code, encode);
+class Hasher {
+  constructor(name, code, encode) {
+    this.name = name;
+    this.code = code;
+    this.encode = encode;
+  }
+  digest(input) {
+    if (input instanceof Uint8Array) {
+      const result = this.encode(input);
+      return result instanceof Uint8Array ? create(this.code, result) : result.then(digest => create(this.code, digest));
+    } else {
+      throw Error('Unknown type, must be binary type');
+    }
+  }
+}
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/hashes/sha2-browser.js
+
+const sha = name => async data => new Uint8Array(await crypto.subtle.digest(name, data));
+const sha256 = hasher_from({
+  name: 'sha2-256',
+  code: 18,
+  encode: sha('SHA-256')
+});
+const sha512 = hasher_from({
+  name: 'sha2-512',
+  code: 19,
+  encode: sha('SHA-512')
+});
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/hashes/identity.js
+
+
+const code = 0;
+const identity_name = 'identity';
+const identity_encode = bytes_coerce;
+const digest = input => create(code, identity_encode(input));
+const identity_identity = {
+  code,
+  name: identity_name,
+  encode: identity_encode,
+  digest
+};
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/codecs/raw.js
+
+const raw_name = 'raw';
+const raw_code = 85;
+const raw_encode = node => bytes_coerce(node);
+const raw_decode = data => bytes_coerce(data);
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/codecs/json.js
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+const json_name = 'json';
+const json_code = 512;
+const json_encode = node => textEncoder.encode(JSON.stringify(node));
+const json_decode = data => JSON.parse(textDecoder.decode(data));
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/cid.js
+
+
+
+
+
+class CID {
+  constructor(version, code, multihash, bytes) {
+    this.code = code;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this.byteOffset = bytes.byteOffset;
+    this.byteLength = bytes.byteLength;
+    this.asCID = this;
+    this._baseCache = new Map();
+    Object.defineProperties(this, {
+      byteOffset: cid_hidden,
+      byteLength: cid_hidden,
+      code: readonly,
+      version: readonly,
+      multihash: readonly,
+      bytes: readonly,
+      _baseCache: cid_hidden,
+      asCID: cid_hidden
+    });
+  }
+  toV0() {
+    switch (this.version) {
+    case 0: {
+        return this;
+      }
+    default: {
+        const {code, multihash} = this;
+        if (code !== DAG_PB_CODE) {
+          throw new Error('Cannot convert a non dag-pb CID to CIDv0');
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0');
+        }
+        return CID.createV0(multihash);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+    case 0: {
+        const {code, digest} = this.multihash;
+        const multihash = Digest.create(code, digest);
+        return CID.createV1(this.code, multihash);
+      }
+    case 1: {
+        return this;
+      }
+    default: {
+        throw Error(`Can not convert CID version ${ this.version } to version 0. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return other && this.code === other.code && this.version === other.version && Digest.equals(this.multihash, other.multihash);
+  }
+  toString(base) {
+    const {bytes, version, _baseCache} = this;
+    switch (version) {
+    case 0:
+      return toStringV0(bytes, _baseCache, base || base58btc.encoder);
+    default:
+      return toStringV1(bytes, _baseCache, base || base32.encoder);
+    }
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      version: this.version,
+      hash: this.multihash.bytes
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return 'CID';
+  }
+  [Symbol.for('nodejs.util.inspect.custom')]() {
+    return 'CID(' + this.toString() + ')';
+  }
+  static isCID(value) {
+    deprecate(/^0\.0/, IS_CID_DEPRECATION);
+    return !!(value && (value[cidSymbol] || value.asCID === value));
+  }
+  get toBaseEncodedString() {
+    throw new Error('Deprecated, use .toString()');
+  }
+  get codec() {
+    throw new Error('"codec" property is deprecated, use integer "code" property instead');
+  }
+  get buffer() {
+    throw new Error('Deprecated .buffer property, use .bytes to get Uint8Array instead');
+  }
+  get multibaseName() {
+    throw new Error('"multibaseName" property is deprecated');
+  }
+  get prefix() {
+    throw new Error('"prefix" property is deprecated');
+  }
+  static asCID(value) {
+    if (value instanceof CID) {
+      return value;
+    } else if (value != null && value.asCID === value) {
+      const {version, code, multihash, bytes} = value;
+      return new CID(version, code, multihash, bytes || encodeCID(version, code, multihash.bytes));
+    } else if (value != null && value[cidSymbol] === true) {
+      const {version, multihash, code} = value;
+      const digest = Digest.decode(multihash);
+      return CID.create(version, code, digest);
+    } else {
+      return null;
+    }
+  }
+  static create(version, code, digest) {
+    if (typeof code !== 'number') {
+      throw new Error('String codecs are no longer supported');
+    }
+    switch (version) {
+    case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${ DAG_PB_CODE }) block encoding`);
+        } else {
+          return new CID(version, code, digest, digest.bytes);
+        }
+      }
+    case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new CID(version, code, digest, bytes);
+      }
+    default: {
+        throw new Error('Invalid version');
+      }
+    }
+  }
+  static createV0(digest) {
+    return CID.create(0, DAG_PB_CODE, digest);
+  }
+  static createV1(code, digest) {
+    return CID.create(1, code, digest);
+  }
+  static decode(bytes) {
+    const [cid, remainder] = CID.decodeFirst(bytes);
+    if (remainder.length) {
+      throw new Error('Incorrect length');
+    }
+    return cid;
+  }
+  static decodeFirst(bytes) {
+    const specs = CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error('Incorrect length');
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest = new Digest.Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? CID.createV0(digest) : CID.createV1(specs.codec, digest);
+    return [
+      cid,
+      bytes.subarray(specs.size)
+    ];
+  }
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length] = varint.decode(initialBytes.subarray(offset));
+      offset += length;
+      return i;
+    };
+    let version = next();
+    let codec = DAG_PB_CODE;
+    if (version === 18) {
+      version = 0;
+      offset = 0;
+    } else if (version === 1) {
+      codec = next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${ version }`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return {
+      version,
+      codec,
+      multihashCode,
+      digestSize,
+      multihashSize,
+      size
+    };
+  }
+  static parse(source, base) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base);
+    const cid = CID.decode(bytes);
+    cid._baseCache.set(prefix, source);
+    return cid;
+  }
+}
+const parseCIDtoBytes = (source, base) => {
+  switch (source[0]) {
+  case 'Q': {
+      const decoder = base || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${ base58btc.prefix }${ source }`)
+      ];
+    }
+  case base58btc.prefix: {
+      const decoder = base || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(source)
+      ];
+    }
+  case base32.prefix: {
+      const decoder = base || base32;
+      return [
+        base32.prefix,
+        decoder.decode(source)
+      ];
+    }
+  default: {
+      if (base == null) {
+        throw Error('To parse non base32 or base58btc encoded CID multibase decoder must be provided');
+      }
+      return [
+        source[0],
+        base.decode(source)
+      ];
+    }
+  }
+};
+const toStringV0 = (bytes, cache, base) => {
+  const {prefix} = base;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${ base.name } encoding`);
+  }
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid = base.encode(bytes).slice(1);
+    cache.set(prefix, cid);
+    return cid;
+  } else {
+    return cid;
+  }
+};
+const toStringV1 = (bytes, cache, base) => {
+  const {prefix} = base;
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid = base.encode(bytes);
+    cache.set(prefix, cid);
+    return cid;
+  } else {
+    return cid;
+  }
+};
+const DAG_PB_CODE = 112;
+const SHA_256_CODE = 18;
+const encodeCID = (version, code, multihash) => {
+  const codeOffset = varint.encodingLength(version);
+  const hashOffset = codeOffset + varint.encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  varint.encodeTo(version, bytes, 0);
+  varint.encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+};
+const cidSymbol = Symbol.for('@ipld/js-cid/CID');
+const readonly = {
+  writable: false,
+  configurable: false,
+  enumerable: true
+};
+const cid_hidden = {
+  writable: false,
+  enumerable: false,
+  configurable: false
+};
+const version = '0.0.0-dev';
+const deprecate = (range, message) => {
+  if (range.test(version)) {
+    console.warn(message);
+  } else {
+    throw new Error(message);
+  }
+};
+const IS_CID_DEPRECATION = (/* unused pure expression or super */ null && (`CID.isCID(v) is deprecated and will be removed in the next major release.
+Following code pattern:
+
+if (CID.isCID(value)) {
+  doSomethingWithCID(value)
+}
+
+Is replaced with:
+
+const cid = CID.asCID(value)
+if (cid) {
+  // Make sure to use cid instead of value
+  doSomethingWithCID(cid)
+}
+`));
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/index.js
+
+
+
+
+
+
+;// CONCATENATED MODULE: ./node_modules/multiformats/esm/src/basics.js
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+const bases = {
+  ...identity_namespaceObject,
+  ...base2_namespaceObject,
+  ...base8_namespaceObject,
+  ...base10_namespaceObject,
+  ...base16_namespaceObject,
+  ...base32_namespaceObject,
+  ...base36_namespaceObject,
+  ...base58_namespaceObject,
+  ...base64_namespaceObject
+};
+const hashes = {
+  ...sha2_browser_namespaceObject,
+  ...hashes_identity_namespaceObject
+};
+const codecs = {
+  raw: raw_namespaceObject,
+  json: json_namespaceObject
+};
+
+;// CONCATENATED MODULE: ./node_modules/uint8arrays/esm/src/util/bases.js
+
+function createCodec(name, prefix, encode, decode) {
+  return {
+    name,
+    prefix,
+    encoder: {
+      name,
+      prefix,
+      encode
+    },
+    decoder: { decode }
+  };
+}
+const string = createCodec('utf8', 'u', buf => {
+  const decoder = new TextDecoder('utf8');
+  return 'u' + decoder.decode(buf);
+}, str => {
+  const encoder = new TextEncoder();
+  return encoder.encode(str.substring(1));
+});
+const ascii = createCodec('ascii', 'a', buf => {
+  let string = 'a';
+  for (let i = 0; i < buf.length; i++) {
+    string += String.fromCharCode(buf[i]);
+  }
+  return string;
+}, str => {
+  str = str.substring(1);
+  const buf = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    buf[i] = str.charCodeAt(i);
+  }
+  return buf;
+});
+const BASES = {
+  utf8: string,
+  'utf-8': string,
+  hex: bases.base16,
+  latin1: ascii,
+  ascii: ascii,
+  binary: ascii,
+  ...bases
+};
+/* harmony default export */ var util_bases = (BASES);
+
+/***/ })
+
+}]);