web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/multiformats/dist/src/hashes/digest.js

@@ -0,0 +1,63 @@
+'use strict';
+
+var bytes = require('../bytes.js');
+var varint = require('../varint.js');
+
+/**
+ * Creates a multihash digest.
+ */
+function create(code, digest) {
+  const size = digest.byteLength;
+  const sizeOffset = varint.encodingLength(code);
+  const digestOffset = sizeOffset + varint.encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  varint.encodeTo(code, bytes, 0);
+  varint.encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code, size, digest, bytes);
+}
+/**
+ * Turns bytes representation of multihash digest into an instance.
+ */
+function decode(multihash) {
+  const bytes$1 = bytes.coerce(multihash);
+  const [code, sizeOffset] = varint.decode(bytes$1);
+  const [size, digestOffset] = varint.decode(bytes$1.subarray(sizeOffset));
+  const digest = bytes$1.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size) {
+    throw new Error('Incorrect length');
+  }
+  return new Digest(code, size, digest, bytes$1);
+}
+function equals(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && bytes.equals(a.bytes, data.bytes);
+  }
+}
+/**
+ * Represents a multihash digest which carries information about the
+ * hashing algorithm and an actual hash digest.
+ */
+class Digest {
+  code;
+  size;
+  digest;
+  bytes;
+  /**
+   * Creates a multihash digest.
+   */
+  constructor(code, size, digest, bytes) {
+    this.code = code;
+    this.size = size;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+}
+
+exports.Digest = Digest;
+exports.create = create;
+exports.decode = decode;
+exports.equals = equals;

package/dist/cjs/node_modules/multiformats/dist/src/hashes/hasher.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var digest = require('./digest.js');
+
+function from(_ref) {
+  let {
+    name,
+    code,
+    encode
+  } = _ref;
+  return new Hasher(name, code, encode);
+}
+/**
+ * Hasher represents a hashing algorithm implementation that produces as
+ * `MultihashDigest`.
+ */
+class Hasher {
+  name;
+  code;
+  encode;
+  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 ? digest.create(this.code, result)
+      /* c8 ignore next 1 */ : result.then(digest$1 => digest.create(this.code, digest$1));
+    } else {
+      throw Error('Unknown type, must be binary type');
+      /* c8 ignore next 1 */
+    }
+  }
+}
+
+exports.Hasher = Hasher;
+exports.from = from;

package/dist/cjs/node_modules/multiformats/dist/src/hashes/identity.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var bytes = require('../bytes.js');
+var digest$1 = require('./digest.js');
+
+const code = 0x0;
+const name = 'identity';
+const encode = bytes.coerce;
+function digest(input) {
+  return digest$1.create(code, encode(input));
+}
+const identity = {
+  code,
+  name,
+  encode,
+  digest
+};
+
+exports.identity = identity;

package/dist/cjs/node_modules/multiformats/dist/src/hashes/sha2-browser.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var hasher = require('./hasher.js');
+
+/* global crypto */
+function sha(name) {
+  return async data => new Uint8Array(await crypto.subtle.digest(name, data));
+}
+const sha256 = hasher.from({
+  name: 'sha2-256',
+  code: 0x12,
+  encode: sha('SHA-256')
+});
+hasher.from({
+  name: 'sha2-512',
+  code: 0x13,
+  encode: sha('SHA-512')
+});
+
+exports.sha256 = sha256;

package/dist/cjs/node_modules/multiformats/dist/src/varint.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var varint = require('./vendor/varint.js');
+
+function decode(data) {
+  let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  const code = varint.default.decode(data, offset);
+  return [code, varint.default.decode.bytes];
+}
+function encodeTo(int, target) {
+  let offset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+  varint.default.encode(int, target, offset);
+  return target;
+}
+function encodingLength(int) {
+  return varint.default.encodingLength(int);
+}
+
+exports.decode = decode;
+exports.encodeTo = encodeTo;
+exports.encodingLength = encodingLength;

package/dist/cjs/node_modules/multiformats/dist/src/vendor/base-x.js

@@ -0,0 +1,171 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable */
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+/**
+ * @param {string} ALPHABET
+ * @param {any} name
+ */
+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); // log(BASE) / log(256), rounded up
+  var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
+  /**
+   * @param {any[] | Iterable<number>} source
+   */
+  function encode(source) {
+    // @ts-ignore
+    if (source instanceof Uint8Array) ;else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError('Expected Uint8Array');
+    }
+    if (source.length === 0) {
+      return '';
+    }
+    // Skip & count leading zeroes.
+    var zeroes = 0;
+    var length = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    // Allocate enough space in big-endian base58 representation.
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    // Process the bytes.
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      // Apply "b58 = b58 * 256 + ch".
+      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++;
+    }
+    // Skip leading zeroes in base58 result.
+    var it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    // Translate the result into a string.
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  /**
+   * @param {string | string[]} source
+   */
+  function decodeUnsafe(source) {
+    if (typeof source !== 'string') {
+      throw new TypeError('Expected String');
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    // Skip leading spaces.
+    if (source[psz] === ' ') {
+      return;
+    }
+    // Skip and count leading '1's.
+    var zeroes = 0;
+    var length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    // Allocate enough space in big-endian base256 representation.
+    var size = (source.length - psz) * FACTOR + 1 >>> 0; // log(58) / log(256), rounded up.
+    var b256 = new Uint8Array(size);
+    // Process the characters.
+    while (source[psz]) {
+      // Decode character
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      // Invalid character
+      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++;
+    }
+    // Skip trailing spaces.
+    if (source[psz] === ' ') {
+      return;
+    }
+    // Skip leading zeroes in b256.
+    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;
+  }
+  /**
+   * @param {string | string[]} string
+   */
+  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;
+
+exports.default = _brrp__multiformats_scope_baseX;

package/dist/cjs/node_modules/multiformats/dist/src/vendor/varint.js

@@ -0,0 +1,79 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/* eslint-disable */
+var encode_1 = encode;
+var MSB = 0x80,
+  MSBALL = -128,
+  INT = Math.pow(2, 31);
+/**
+ * @param {number} num
+ * @param {number[]} out
+ * @param {number} offset
+ */
+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;
+  // @ts-ignore
+  encode.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode = read;
+var MSB$1 = 0x80,
+  REST$1 = 0x7F;
+/**
+ * @param {string | any[]} buf
+ * @param {number} offset
+ */
+function read(buf, offset) {
+  var res = 0,
+    offset = offset || 0,
+    shift = 0,
+    counter = offset,
+    b,
+    l = buf.length;
+  do {
+    if (counter >= l) {
+      // @ts-ignore
+      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);
+  // @ts-ignore
+  read.bytes = counter - offset;
+  return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = function (/** @type {number} */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 = {
+  encode: encode_1,
+  decode: decode,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+
+exports.default = _brrp_varint;

package/dist/cjs/node_modules/nanoid/index.browser.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var index = require('./url-alphabet/index.js');
+
+/* @ts-self-types="./index.d.ts" */
+let nanoid = function () {
+  let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 21;
+  let id = '';
+  let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
+  while (size--) {
+    id += index.urlAlphabet[bytes[size] & 63];
+  }
+  return id;
+};
+
+exports.urlAlphabet = index.urlAlphabet;
+exports.nanoid = nanoid;

package/dist/cjs/node_modules/nanoid/url-alphabet/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const urlAlphabet = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+
+exports.urlAlphabet = urlAlphabet;

package/dist/cjs/node_modules/netmask/lib/netmask.js

@@ -0,0 +1,200 @@
+'use strict';
+
+var netmask = require('../../../_virtual/netmask2.js');
+
+var hasRequiredNetmask;
+function requireNetmask() {
+  if (hasRequiredNetmask) return netmask.__exports;
+  hasRequiredNetmask = 1;
+  // Generated by CoffeeScript 1.12.7
+  (function () {
+    var Netmask, atob, chr, chr0, chrA, chra, ip2long, long2ip;
+    long2ip = function (long) {
+      var a, b, c, d;
+      a = (long & 0xff << 24) >>> 24;
+      b = (long & 0xff << 16) >>> 16;
+      c = (long & 0xff << 8) >>> 8;
+      d = long & 0xff;
+      return [a, b, c, d].join('.');
+    };
+    ip2long = function (ip) {
+      var b, c, i, j, n, ref;
+      b = [];
+      for (i = j = 0; j <= 3; i = ++j) {
+        if (ip.length === 0) {
+          break;
+        }
+        if (i > 0) {
+          if (ip[0] !== '.') {
+            throw new Error('Invalid IP');
+          }
+          ip = ip.substring(1);
+        }
+        ref = atob(ip), n = ref[0], c = ref[1];
+        ip = ip.substring(c);
+        b.push(n);
+      }
+      if (ip.length !== 0) {
+        throw new Error('Invalid IP');
+      }
+      switch (b.length) {
+        case 1:
+          if (b[0] > 0xFFFFFFFF) {
+            throw new Error('Invalid IP');
+          }
+          return b[0] >>> 0;
+        case 2:
+          if (b[0] > 0xFF || b[1] > 0xFFFFFF) {
+            throw new Error('Invalid IP');
+          }
+          return (b[0] << 24 | b[1]) >>> 0;
+        case 3:
+          if (b[0] > 0xFF || b[1] > 0xFF || b[2] > 0xFFFF) {
+            throw new Error('Invalid IP');
+          }
+          return (b[0] << 24 | b[1] << 16 | b[2]) >>> 0;
+        case 4:
+          if (b[0] > 0xFF || b[1] > 0xFF || b[2] > 0xFF || b[3] > 0xFF) {
+            throw new Error('Invalid IP');
+          }
+          return (b[0] << 24 | b[1] << 16 | b[2] << 8 | b[3]) >>> 0;
+        default:
+          throw new Error('Invalid IP');
+      }
+    };
+    chr = function (b) {
+      return b.charCodeAt(0);
+    };
+    chr0 = chr('0');
+    chra = chr('a');
+    chrA = chr('A');
+    atob = function (s) {
+      var base, dmax, i, n, start;
+      n = 0;
+      base = 10;
+      dmax = '9';
+      i = 0;
+      if (s.length > 1 && s[i] === '0') {
+        if (s[i + 1] === 'x' || s[i + 1] === 'X') {
+          i += 2;
+          base = 16;
+        } else if ('0' <= s[i + 1] && s[i + 1] <= '9') {
+          i++;
+          base = 8;
+          dmax = '7';
+        }
+      }
+      start = i;
+      while (i < s.length) {
+        if ('0' <= s[i] && s[i] <= dmax) {
+          n = n * base + (chr(s[i]) - chr0) >>> 0;
+        } else if (base === 16) {
+          if ('a' <= s[i] && s[i] <= 'f') {
+            n = n * base + (10 + chr(s[i]) - chra) >>> 0;
+          } else if ('A' <= s[i] && s[i] <= 'F') {
+            n = n * base + (10 + chr(s[i]) - chrA) >>> 0;
+          } else {
+            break;
+          }
+        } else {
+          break;
+        }
+        if (n > 0xFFFFFFFF) {
+          throw new Error('too large');
+        }
+        i++;
+      }
+      if (i === start) {
+        throw new Error('empty octet');
+      }
+      return [n, i];
+    };
+    Netmask = function () {
+      function Netmask(net, mask) {
+        var i, j, ref;
+        if (typeof net !== 'string') {
+          throw new Error("Missing `net' parameter");
+        }
+        if (!mask) {
+          ref = net.split('/', 2), net = ref[0], mask = ref[1];
+        }
+        if (!mask) {
+          mask = 32;
+        }
+        if (typeof mask === 'string' && mask.indexOf('.') > -1) {
+          try {
+            this.maskLong = ip2long(mask);
+          } catch (error1) {
+            throw new Error("Invalid mask: " + mask);
+          }
+          for (i = j = 32; j >= 0; i = --j) {
+            if (this.maskLong === 0xffffffff << 32 - i >>> 0) {
+              this.bitmask = i;
+              break;
+            }
+          }
+        } else if (mask || mask === 0) {
+          this.bitmask = parseInt(mask, 10);
+          this.maskLong = 0;
+          if (this.bitmask > 0) {
+            this.maskLong = 0xffffffff << 32 - this.bitmask >>> 0;
+          }
+        } else {
+          throw new Error("Invalid mask: empty");
+        }
+        try {
+          this.netLong = (ip2long(net) & this.maskLong) >>> 0;
+        } catch (error1) {
+          throw new Error("Invalid net address: " + net);
+        }
+        if (!(this.bitmask <= 32)) {
+          throw new Error("Invalid mask for ip4: " + mask);
+        }
+        this.size = Math.pow(2, 32 - this.bitmask);
+        this.base = long2ip(this.netLong);
+        this.mask = long2ip(this.maskLong);
+        this.hostmask = long2ip(~this.maskLong);
+        this.first = this.bitmask <= 30 ? long2ip(this.netLong + 1) : this.base;
+        this.last = this.bitmask <= 30 ? long2ip(this.netLong + this.size - 2) : long2ip(this.netLong + this.size - 1);
+        this.broadcast = this.bitmask <= 30 ? long2ip(this.netLong + this.size - 1) : void 0;
+      }
+      Netmask.prototype.contains = function (ip) {
+        if (typeof ip === 'string' && (ip.indexOf('/') > 0 || ip.split('.').length !== 4)) {
+          ip = new Netmask(ip);
+        }
+        if (ip instanceof Netmask) {
+          return this.contains(ip.base) && this.contains(ip.broadcast || ip.last);
+        } else {
+          return (ip2long(ip) & this.maskLong) >>> 0 === (this.netLong & this.maskLong) >>> 0;
+        }
+      };
+      Netmask.prototype.next = function (count) {
+        if (count == null) {
+          count = 1;
+        }
+        return new Netmask(long2ip(this.netLong + this.size * count), this.mask);
+      };
+      Netmask.prototype.forEach = function (fn) {
+        var index, lastLong, long;
+        long = ip2long(this.first);
+        lastLong = ip2long(this.last);
+        index = 0;
+        while (long <= lastLong) {
+          fn(long2ip(long), long, index);
+          index++;
+          long++;
+        }
+      };
+      Netmask.prototype.toString = function () {
+        return this.base + "/" + this.bitmask;
+      };
+      return Netmask;
+    }();
+    netmask.__exports.ip2long = ip2long;
+    netmask.__exports.long2ip = long2ip;
+    netmask.__exports.Netmask = Netmask;
+  }).call(netmask.__exports);
+  return netmask.__exports;
+}
+
+exports.__require = requireNetmask;

package/dist/cjs/node_modules/p-defer/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function pDefer() {
+  const deferred = {};
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.resolve = resolve;
+    deferred.reject = reject;
+  });
+  return deferred;
+}
+
+exports.default = pDefer;