web-dc-api 0.0.61 → 0.0.62

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

@@ -0,0 +1,137 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+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;
+
+exports.default = _brrp__multiformats_scope_baseX;

package/dist/cjs/node_modules/multiaddr/node_modules/multiformats/esm/vendor/varint.js

@@ -0,0 +1,66 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var encode_1 = encode;
+var MSB = 128,
+  MSBALL = -128,
+  INT = Math.pow(2, 31);
+function 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;
+  encode.bytes = offset - oldOffset + 1;
+  return out;
+}
+var 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 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 = {
+  encode: encode_1,
+  decode: decode,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+
+exports.default = _brrp_varint;

package/dist/cjs/node_modules/multiaddr/node_modules/uint8arrays/esm/src/alloc.js

@@ -0,0 +1,13 @@
+'use strict';
+
+var asUint8array = require('./util/as-uint8array.js');
+
+function allocUnsafe() {
+  let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  if (globalThis.Buffer != null && globalThis.Buffer.allocUnsafe != null) {
+    return asUint8array.asUint8Array(globalThis.Buffer.allocUnsafe(size));
+  }
+  return new Uint8Array(size);
+}
+
+exports.allocUnsafe = allocUnsafe;

package/dist/cjs/node_modules/multiaddr/node_modules/uint8arrays/esm/src/concat.js

@@ -0,0 +1,19 @@
+'use strict';
+
+var alloc = require('./alloc.js');
+var asUint8array = require('./util/as-uint8array.js');
+
+function concat(arrays, length) {
+  if (!length) {
+    length = arrays.reduce((acc, curr) => acc + curr.length, 0);
+  }
+  const output = alloc.allocUnsafe(length);
+  let offset = 0;
+  for (const arr of arrays) {
+    output.set(arr, offset);
+    offset += arr.length;
+  }
+  return asUint8array.asUint8Array(output);
+}
+
+exports.concat = concat;

package/dist/cjs/node_modules/multiaddr/node_modules/uint8arrays/esm/src/equals.js

@@ -0,0 +1,18 @@
+'use strict';
+
+function equals(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+exports.equals = equals;

package/dist/cjs/node_modules/multiaddr/node_modules/uint8arrays/esm/src/from-string.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var bases = require('./util/bases.js');
+var asUint8array = require('./util/as-uint8array.js');
+
+function fromString(string) {
+  let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'utf8';
+  const base = bases.default[encoding];
+  if (!base) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
+    return asUint8array.asUint8Array(globalThis.Buffer.from(string, 'utf-8'));
+  }
+  return base.decoder.decode(`${base.prefix}${string}`);
+}
+
+exports.fromString = fromString;

package/dist/cjs/node_modules/multiaddr/node_modules/uint8arrays/esm/src/to-string.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var bases = require('./util/bases.js');
+
+function toString(array) {
+  let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'utf8';
+  const base = bases.default[encoding];
+  if (!base) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
+    return globalThis.Buffer.from(array.buffer, array.byteOffset, array.byteLength).toString('utf8');
+  }
+  return base.encoder.encode(array).substring(1);
+}
+
+exports.toString = toString;

package/dist/cjs/node_modules/multiaddr/node_modules/uint8arrays/esm/src/util/as-uint8array.js

@@ -0,0 +1,10 @@
+'use strict';
+
+function asUint8Array(buf) {
+  if (globalThis.Buffer != null) {
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+  }
+  return buf;
+}
+
+exports.asUint8Array = asUint8Array;

package/dist/cjs/node_modules/multiaddr/node_modules/uint8arrays/esm/src/util/bases.js

@@ -0,0 +1,53 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var basics = require('../../../../multiformats/esm/src/basics.js');
+var alloc = require('../alloc.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 = alloc.allocUnsafe(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: basics.bases.base16,
+  latin1: ascii,
+  ascii: ascii,
+  binary: ascii,
+  ...basics.bases
+};
+
+exports.default = BASES;

package/dist/cjs/node_modules/multiaddr/src/codec.js

@@ -0,0 +1,278 @@
+'use strict';
+
+var convert = require('./convert.js');
+var protocolsTable = require('./protocols-table.js');
+var index = require('../../varint/index.js');
+var concat = require('../../../_virtual/concat.js');
+var toString = require('../../../_virtual/to-string.js');
+
+var codec;
+var hasRequiredCodec;
+function requireCodec() {
+  if (hasRequiredCodec) return codec;
+  hasRequiredCodec = 1;
+  const convert$1 = convert.__require();
+  const protocols = protocolsTable.__require();
+  const varint = index.__require();
+  const {
+    concat: uint8ArrayConcat
+  } = concat.default;
+  const {
+    toString: uint8ArrayToString
+  } = toString.default;
+
+  // export codec
+  codec = {
+    stringToStringTuples,
+    stringTuplesToString,
+    tuplesToStringTuples,
+    stringTuplesToTuples,
+    bytesToTuples,
+    tuplesToBytes,
+    bytesToString,
+    stringToBytes,
+    fromString,
+    fromBytes,
+    validateBytes,
+    isValidBytes,
+    cleanPath,
+    ParseError,
+    protoFromTuple,
+    sizeForAddr
+  };
+
+  // string -> [[str name, str addr]... ]
+  /**
+   * @param {string} str
+   */
+  function stringToStringTuples(str) {
+    const tuples = [];
+    const parts = str.split('/').slice(1); // skip first empty elem
+    if (parts.length === 1 && parts[0] === '') {
+      return [];
+    }
+    for (let p = 0; p < parts.length; p++) {
+      const part = parts[p];
+      const proto = protocols(part);
+      if (proto.size === 0) {
+        tuples.push([part]);
+        continue;
+      }
+      p++; // advance addr part
+      if (p >= parts.length) {
+        throw ParseError('invalid address: ' + str);
+      }
+
+      // if it's a path proto, take the rest
+      if (proto.path) {
+        tuples.push([part,
+        // TODO: should we need to check each path part to see if it's a proto?
+        // This would allow for other protocols to be added after a unix path,
+        // however it would have issues if the path had a protocol name in the path
+        cleanPath(parts.slice(p).join('/'))]);
+        break;
+      }
+      tuples.push([part, parts[p]]);
+    }
+    return tuples;
+  }
+
+  // [[str name, str addr]... ] -> string
+  /**
+   * @param {[number, string?][]} tuples
+   */
+  function stringTuplesToString(tuples) {
+    /** @type {Array<string | undefined>} */
+    const parts = [];
+    tuples.map(tup => {
+      const proto = protoFromTuple(tup);
+      parts.push(proto.name);
+      if (tup.length > 1) {
+        parts.push(tup[1]);
+      }
+      return null;
+    });
+    return cleanPath(parts.join('/'));
+  }
+
+  // [[str name, str addr]... ] -> [[int code, Uint8Array]... ]
+  /**
+   * @param {Array<string[] | string >} tuples
+   * @returns {[number , Uint8Array?][]}
+   */
+  function stringTuplesToTuples(tuples) {
+    return tuples.map(tup => {
+      if (!Array.isArray(tup)) {
+        tup = [tup];
+      }
+      const proto = protoFromTuple(tup);
+      if (tup.length > 1) {
+        return [proto.code, convert$1.toBytes(proto.code, tup[1])];
+      }
+      return [proto.code];
+    });
+  }
+
+  /**
+   * Convert tuples to string tuples
+   *
+   * [[int code, Uint8Array]... ] -> [[int code, str addr]... ]
+   *
+   * @param {Array<[number, Uint8Array?]>} tuples
+   * @returns {Array<[number, string?]>}
+   */
+
+  function tuplesToStringTuples(tuples) {
+    return tuples.map(tup => {
+      const proto = protoFromTuple(tup);
+      if (tup[1]) {
+        return [proto.code, convert$1.toString(proto.code, tup[1])];
+      }
+      return [proto.code];
+    });
+  }
+
+  // [[int code, Uint8Array ]... ] -> Uint8Array
+  /**
+   * @param {[number, Uint8Array?][]} tuples
+   */
+  function tuplesToBytes(tuples) {
+    return fromBytes(uint8ArrayConcat(tuples.map((/** @type {any[]} */tup) => {
+      const proto = protoFromTuple(tup);
+      let buf = Uint8Array.from(varint.encode(proto.code));
+      if (tup.length > 1) {
+        buf = uint8ArrayConcat([buf, tup[1]]); // add address buffer
+      }
+      return buf;
+    })));
+  }
+
+  /**
+   * @param {import("./types").Protocol} p
+   * @param {Uint8Array | number[]} addr
+   */
+  function sizeForAddr(p, addr) {
+    if (p.size > 0) {
+      return p.size / 8;
+    } else if (p.size === 0) {
+      return 0;
+    } else {
+      const size = varint.decode(addr);
+      return size + varint.decode.bytes;
+    }
+  }
+
+  /**
+   *
+   * @param {Uint8Array} buf
+   * @returns {Array<[number, Uint8Array?]>}
+   */
+  function bytesToTuples(buf) {
+    /** @type {Array<[number, Uint8Array?]>} */
+    const tuples = [];
+    let i = 0;
+    while (i < buf.length) {
+      const code = varint.decode(buf, i);
+      const n = varint.decode.bytes;
+      const p = protocols(code);
+      const size = sizeForAddr(p, buf.slice(i + n));
+      if (size === 0) {
+        tuples.push([code]);
+        i += n;
+        continue;
+      }
+      const addr = buf.slice(i + n, i + n + size);
+      i += size + n;
+      if (i > buf.length) {
+        // did not end _exactly_ at buffer.length
+        throw ParseError('Invalid address Uint8Array: ' + uint8ArrayToString(buf, 'base16'));
+      }
+
+      // ok, tuple seems good.
+      tuples.push([code, addr]);
+    }
+    return tuples;
+  }
+
+  // Uint8Array -> String
+  /**
+   * @param {Uint8Array} buf
+   */
+  function bytesToString(buf) {
+    const a = bytesToTuples(buf);
+    const b = tuplesToStringTuples(a);
+    return stringTuplesToString(b);
+  }
+
+  // String -> Uint8Array
+  /**
+   * @param {string} str
+   */
+  function stringToBytes(str) {
+    str = cleanPath(str);
+    const a = stringToStringTuples(str);
+    const b = stringTuplesToTuples(a);
+    return tuplesToBytes(b);
+  }
+
+  // String -> Uint8Array
+  /**
+   * @param {string} str
+   */
+  function fromString(str) {
+    return stringToBytes(str);
+  }
+
+  // Uint8Array -> Uint8Array
+  /**
+   * @param {Uint8Array} buf
+   */
+  function fromBytes(buf) {
+    const err = validateBytes(buf);
+    if (err) throw err;
+    return Uint8Array.from(buf); // copy
+  }
+
+  /**
+   * @param {Uint8Array} buf
+   */
+  function validateBytes(buf) {
+    try {
+      bytesToTuples(buf); // try to parse. will throw if breaks
+    } catch (err) {
+      return err;
+    }
+  }
+
+  /**
+   * @param {Uint8Array} buf
+   */
+  function isValidBytes(buf) {
+    return validateBytes(buf) === undefined;
+  }
+
+  /**
+   * @param {string} str
+   */
+  function cleanPath(str) {
+    return '/' + str.trim().split('/').filter((/** @type {any} */a) => a).join('/');
+  }
+
+  /**
+   * @param {string} str
+   */
+  function ParseError(str) {
+    return new Error('Error parsing address: ' + str);
+  }
+
+  /**
+   * @param {any[]} tup
+   */
+  function protoFromTuple(tup) {
+    const proto = protocols(tup[0]);
+    return proto;
+  }
+  return codec;
+}
+
+exports.__require = requireCodec;