web-dc-api 0.0.62 → 0.0.64

package/dist/esm/node_modules/@libp2p/webrtc/dist/src/util.js

@@ -1,65 +0,0 @@
-import { detect } from '../../../../detect-browser/es/index.js';
-import pDefer from '../../../../p-defer/index.js';
-import pTimeout from '../../../../p-timeout/index.js';
-import { UFRAG_PREFIX, UFRAG_ALPHABET, DEFAULT_ICE_SERVERS, DATA_CHANNEL_DRAIN_TIMEOUT } from './constants.js';
-
-const browser = detect();
-const isFirefox = browser != null && browser.name === 'firefox';
-const nopSource = async function* nop() {};
-const nopSink = async _ => {};
-function drainAndClose(channel, direction) {
-  let drainTimeout = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : DATA_CHANNEL_DRAIN_TIMEOUT;
-  let options = arguments.length > 3 ? arguments[3] : undefined;
-  if (channel.readyState !== 'open') {
-    return;
-  }
-  void Promise.resolve().then(async () => {
-    // wait for bufferedAmount to become zero
-    if (channel.bufferedAmount > 0) {
-      options.log('%s drain channel with %d buffered bytes', direction, channel.bufferedAmount);
-      const deferred = pDefer();
-      let drained = false;
-      channel.bufferedAmountLowThreshold = 0;
-      const closeListener = () => {
-        if (!drained) {
-          options.log('%s drain channel closed before drain', direction);
-          deferred.resolve();
-        }
-      };
-      channel.addEventListener('close', closeListener, {
-        once: true
-      });
-      channel.addEventListener('bufferedamountlow', () => {
-        drained = true;
-        channel.removeEventListener('close', closeListener);
-        deferred.resolve();
-      });
-      await pTimeout(deferred.promise, {
-        milliseconds: drainTimeout
-      });
-    }
-  }).then(async () => {
-    // only close if the channel is still open
-    if (channel.readyState === 'open') {
-      channel.close();
-    }
-  }).catch(err => {
-    options.log.error('error closing outbound stream', err);
-  });
-}
-async function getRtcConfiguration(config) {
-  config = config ?? {};
-  if (typeof config === 'function') {
-    config = await config();
-  }
-  config.iceServers = config.iceServers ?? DEFAULT_ICE_SERVERS.map(url => ({
-    urls: [url]
-  }));
-  return config;
-}
-const genUfrag = function () {
-  let len = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 32;
-  return UFRAG_PREFIX + [...Array(len)].map(() => UFRAG_ALPHABET.at(Math.floor(Math.random() * UFRAG_ALPHABET.length))).join('');
-};
-
-export { drainAndClose, genUfrag, getRtcConfiguration, isFirefox, nopSink, nopSource };

package/dist/esm/node_modules/@libp2p/webrtc/dist/src/webrtc/index.browser.js

@@ -1,5 +0,0 @@
-const RTCPeerConnection = globalThis.RTCPeerConnection;
-const RTCSessionDescription = globalThis.RTCSessionDescription;
-const RTCIceCandidate = globalThis.RTCIceCandidate;
-
-export { RTCIceCandidate, RTCPeerConnection, RTCSessionDescription };

package/dist/esm/node_modules/@libp2p/websockets/dist/src/constants.js

@@ -1,4 +0,0 @@
-// Time to wait for a connection to close gracefully before destroying it manually
-const CLOSE_TIMEOUT = 500;
-
-export { CLOSE_TIMEOUT };

package/dist/esm/node_modules/@libp2p/websockets/dist/src/filters.js

@@ -1,12 +0,0 @@
-import { WebSocketsSecure, WebSockets } from '../../../../@multiformats/multiaddr-matcher/dist/src/index.js';
-
-/**
- * @deprecated Configure this globally by passing a `connectionGater` to `createLibp2p` with a `denyDialMultiaddr` method that returns `false`
- */
-function all(multiaddrs) {
-  return multiaddrs.filter(ma => {
-    return WebSocketsSecure.exactMatch(ma) || WebSockets.exactMatch(ma);
-  });
-}
-
-export { all };

package/dist/esm/node_modules/@libp2p/websockets/dist/src/index.js

@@ -1,152 +0,0 @@
-import { serviceCapabilities } from '../../../interface/dist/src/index.js';
-import { multiaddrToUri } from '../../../../@multiformats/multiaddr-to-uri/dist/src/index.js';
-import { connect } from '../../../../it-ws/dist/src/client.js';
-import pDefer from '../../../../p-defer/index.js';
-import { CustomProgressEvent } from '../../../../progress-events/dist/src/index.js';
-import { raceSignal } from '../../../../race-signal/dist/src/index.js';
-import { all } from './filters.js';
-import { createListener } from './listener.browser.js';
-import { socketToMaConn } from './socket-to-conn.js';
-import { transportSymbol } from '../../../interface/dist/src/transport.js';
-import { ConnectionFailedError } from '../../../interface/dist/src/errors.js';
-
-/**
- * @packageDocumentation
- *
- * A [libp2p transport](https://docs.libp2p.io/concepts/transports/overview/) based on [WebSockets](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API).
- *
- * @example
- *
- * ```TypeScript
- * import { createLibp2p } from 'libp2p'
- * import { webSockets } from '@libp2p/websockets'
- * import { multiaddr } from '@multiformats/multiaddr'
- *
- * const node = await createLibp2p({
- *   transports: [
- *     webSockets()
- *   ]
- * //... other config
- * })
- * await node.start()
- *
- * const ma = multiaddr('/dns4/example.com/tcp/9090/tls/ws')
- * await node.dial(ma)
- * ```
- */
-class WebSockets {
-  log;
-  init;
-  logger;
-  metrics;
-  components;
-  constructor(components) {
-    let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    this.log = components.logger.forComponent('libp2p:websockets');
-    this.logger = components.logger;
-    this.components = components;
-    this.init = init;
-    if (components.metrics != null) {
-      this.metrics = {
-        dialerEvents: components.metrics.registerCounterGroup('libp2p_websockets_dialer_events_total', {
-          label: 'event',
-          help: 'Total count of WebSockets dialer events by type'
-        })
-      };
-    }
-  }
-  [transportSymbol] = true;
-  [Symbol.toStringTag] = '@libp2p/websockets';
-  [serviceCapabilities] = ['@libp2p/transport'];
-  async dial(ma, options) {
-    this.log('dialing %s', ma);
-    options = options ?? {};
-    const socket = await this._connect(ma, options);
-    const maConn = socketToMaConn(socket, ma, {
-      logger: this.logger,
-      metrics: this.metrics?.dialerEvents
-    });
-    this.log('new outbound connection %s', maConn.remoteAddr);
-    const conn = await options.upgrader.upgradeOutbound(maConn, options);
-    this.log('outbound connection %s upgraded', maConn.remoteAddr);
-    return conn;
-  }
-  async _connect(ma, options) {
-    options?.signal?.throwIfAborted();
-    const cOpts = ma.toOptions();
-    this.log('dialing %s:%s', cOpts.host, cOpts.port);
-    const errorPromise = pDefer();
-    const rawSocket = connect(multiaddrToUri(ma), this.init);
-    rawSocket.socket.addEventListener('error', () => {
-      // the WebSocket.ErrorEvent type doesn't actually give us any useful
-      // information about what happened
-      // https://developer.mozilla.org/en-US/docs/Web/API/WebSocket/error_event
-      const err = new ConnectionFailedError(`Could not connect to ${ma.toString()}`);
-      this.log.error('connection error:', err);
-      this.metrics?.dialerEvents.increment({
-        error: true
-      });
-      errorPromise.reject(err);
-    });
-    try {
-      options.onProgress?.(new CustomProgressEvent('websockets:open-connection'));
-      await raceSignal(Promise.race([rawSocket.connected(), errorPromise.promise]), options.signal);
-    } catch (err) {
-      if (options.signal?.aborted) {
-        this.metrics?.dialerEvents.increment({
-          abort: true
-        });
-      }
-      rawSocket.close().catch(err => {
-        this.log.error('error closing raw socket', err);
-      });
-      throw err;
-    }
-    this.log('connected %s', ma);
-    this.metrics?.dialerEvents.increment({
-      connect: true
-    });
-    return rawSocket;
-  }
-  /**
-   * Creates a WebSockets listener. The provided `handler` function will be called
-   * anytime a new incoming Connection has been successfully upgraded via
-   * `upgrader.upgradeInbound`
-   */
-  createListener(options) {
-    return createListener({
-      logger: this.logger,
-      events: this.components.events,
-      metrics: this.components.metrics
-    }, {
-      ...this.init,
-      ...options
-    });
-  }
-  /**
-   * Takes a list of `Multiaddr`s and returns only valid WebSockets addresses.
-   * By default, in a browser environment only DNS+WSS multiaddr is accepted,
-   * while in a Node.js environment DNS+{WS, WSS} multiaddrs are accepted.
-   */
-  listenFilter(multiaddrs) {
-    multiaddrs = Array.isArray(multiaddrs) ? multiaddrs : [multiaddrs];
-    if (this.init?.filter != null) {
-      return this.init?.filter(multiaddrs);
-    }
-    return all(multiaddrs);
-  }
-  /**
-   * Filter check for all Multiaddrs that this transport can dial
-   */
-  dialFilter(multiaddrs) {
-    return this.listenFilter(multiaddrs);
-  }
-}
-function webSockets() {
-  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  return components => {
-    return new WebSockets(components, init);
-  };
-}
-
-export { webSockets };

package/dist/esm/node_modules/@libp2p/websockets/dist/src/listener.browser.js

@@ -1,5 +0,0 @@
-function createListener() {
-  throw new Error('WebSocket Servers can not be created in the browser!');
-}
-
-export { createListener };

package/dist/esm/node_modules/@libp2p/websockets/dist/src/socket-to-conn.js

@@ -1,96 +0,0 @@
-import { CLOSE_TIMEOUT } from './constants.js';
-import { AbortError } from '../../../interface/dist/src/errors.js';
-
-// Convert a stream into a MultiaddrConnection
-// https://github.com/libp2p/interface-transport#multiaddrconnection
-function socketToMaConn(stream, remoteAddr, options) {
-  const log = options.logger.forComponent('libp2p:websockets:maconn');
-  const metrics = options.metrics;
-  const metricPrefix = options.metricPrefix ?? '';
-  const maConn = {
-    log,
-    async sink(source) {
-      try {
-        await stream.sink(async function* () {
-          for await (const buf of source) {
-            if (buf instanceof Uint8Array) {
-              yield buf;
-            } else {
-              yield buf.subarray();
-            }
-          }
-        }());
-      } catch (err) {
-        if (err.type !== 'aborted') {
-          log.error(err);
-        }
-      }
-    },
-    source: stream.source,
-    remoteAddr,
-    timeline: {
-      open: Date.now()
-    },
-    async close() {
-      let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      const start = Date.now();
-      if (options.signal == null) {
-        const signal = AbortSignal.timeout(CLOSE_TIMEOUT);
-        options = {
-          ...options,
-          signal
-        };
-      }
-      const listener = () => {
-        const {
-          host,
-          port
-        } = maConn.remoteAddr.toOptions();
-        log('timeout closing stream to %s:%s after %dms, destroying it manually', host, port, Date.now() - start);
-        this.abort(new AbortError('Socket close timeout'));
-      };
-      options.signal?.addEventListener('abort', listener);
-      try {
-        await stream.close();
-      } catch (err) {
-        log.error('error closing WebSocket gracefully', err);
-        this.abort(err);
-      } finally {
-        options.signal?.removeEventListener('abort', listener);
-        maConn.timeline.close = Date.now();
-      }
-    },
-    abort(err) {
-      const {
-        host,
-        port
-      } = maConn.remoteAddr.toOptions();
-      log('timeout closing stream to %s:%s due to error', host, port, err);
-      stream.destroy();
-      maConn.timeline.close = Date.now();
-      // ws WebSocket.terminate does not accept an Error arg to emit an 'error'
-      // event on destroy like other node streams so we can't update a metric
-      // with an event listener
-      // https://github.com/websockets/ws/issues/1752#issuecomment-622380981
-      metrics?.increment({
-        [`${metricPrefix}error`]: true
-      });
-    }
-  };
-  stream.socket.addEventListener('close', () => {
-    metrics?.increment({
-      [`${metricPrefix}close`]: true
-    });
-    // In instances where `close` was not explicitly called,
-    // such as an iterable stream ending, ensure we have set the close
-    // timeline
-    if (maConn.timeline.close == null) {
-      maConn.timeline.close = Date.now();
-    }
-  }, {
-    once: true
-  });
-  return maConn;
-}
-
-export { socketToMaConn };

package/dist/esm/node_modules/@multiformats/base-x/src/index.js

@@ -1,158 +0,0 @@
-var src;
-var hasRequiredSrc;
-function requireSrc() {
-  if (hasRequiredSrc) return src;
-  hasRequiredSrc = 1;
-  // 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.
-  function base(ALPHABET) {
-    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
-    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 '';
-      }
-      // 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;
-    }
-    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;
-    }
-    function decode(string) {
-      var buffer = decodeUnsafe(string);
-      if (buffer) {
-        return buffer;
-      }
-      throw new Error('Non-base' + BASE + ' character');
-    }
-    return {
-      encode: encode,
-      decodeUnsafe: decodeUnsafe,
-      decode: decode
-    };
-  }
-  src = base;
-  return src;
-}
-
-export { requireSrc as __require };

package/dist/esm/node_modules/@multiformats/dns/dist/src/dns.js

@@ -1,80 +0,0 @@
-import { CustomProgressEvent } from '../../../../progress-events/dist/src/index.js';
-import { defaultResolver } from './resolvers/default.browser.js';
-import { cache } from './utils/cache.js';
-import { getTypes } from './utils/get-types.js';
-
-const DEFAULT_ANSWER_CACHE_SIZE = 1000;
-class DNS {
-  resolvers;
-  cache;
-  constructor(init) {
-    this.resolvers = {};
-    this.cache = cache(init.cacheSize ?? DEFAULT_ANSWER_CACHE_SIZE);
-    Object.entries(init.resolvers ?? {}).forEach(_ref => {
-      let [tld, resolver] = _ref;
-      if (!Array.isArray(resolver)) {
-        resolver = [resolver];
-      }
-      // convert `com` -> `com.`
-      if (!tld.endsWith('.')) {
-        tld = `${tld}.`;
-      }
-      this.resolvers[tld] = resolver;
-    });
-    // configure default resolver if none specified
-    if (this.resolvers['.'] == null) {
-      this.resolvers['.'] = defaultResolver();
-    }
-  }
-  /**
-   * Queries DNS resolvers for the passed record types for the passed domain.
-   *
-   * If cached records exist for all desired types they will be returned
-   * instead.
-   *
-   * Any new responses will be added to the cache for subsequent requests.
-   */
-  async query(domain) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const types = getTypes(options.types);
-    const cached = options.cached !== false ? this.cache.get(domain, types) : undefined;
-    if (cached != null) {
-      options.onProgress?.(new CustomProgressEvent('dns:cache', {
-        detail: cached
-      }));
-      return cached;
-    }
-    const tld = `${domain.split('.').pop()}.`;
-    const resolvers = (this.resolvers[tld] ?? this.resolvers['.']).sort(() => {
-      return Math.random() > 0.5 ? -1 : 1;
-    });
-    const errors = [];
-    for (const resolver of resolvers) {
-      // skip further resolutions if the user aborted the signal
-      if (options.signal?.aborted === true) {
-        break;
-      }
-      try {
-        const result = await resolver(domain, {
-          ...options,
-          types
-        });
-        for (const answer of result.Answer) {
-          this.cache.add(domain, answer);
-        }
-        return result;
-      } catch (err) {
-        errors.push(err);
-        options.onProgress?.(new CustomProgressEvent('dns:error', {
-          detail: err
-        }));
-      }
-    }
-    if (errors.length === 1) {
-      throw errors[0];
-    }
-    throw new AggregateError(errors, `DNS lookup of ${domain} ${types} failed`);
-  }
-}
-
-export { DNS };

package/dist/esm/node_modules/@multiformats/dns/dist/src/index.js

@@ -1,101 +0,0 @@
-import { DNS } from './dns.js';
-
-/**
- * @packageDocumentation
- *
- * Query DNS records using `node:dns`, DNS over HTTP and/or DNSJSON over HTTP.
- *
- * A list of publicly accessible servers can be found [here](https://github.com/curl/curl/wiki/DNS-over-HTTPS#publicly-available-servers).
- *
- * @example Using the default resolver
- *
- * ```TypeScript
- * import { dns } from '@multiformats/dns'
- *
- * const resolver = dns()
- *
- * // resolve A records with a 5s timeout
- * const result = await dns.query('google.com', {
- *   signal: AbortSignal.timeout(5000)
- * })
- * ```
- *
- * @example Using per-TLD resolvers
- *
- * ```TypeScript
- * import { dns } from '@multiformats/dns'
- * import { dnsJsonOverHttps } from '@multiformats/dns/resolvers'
- *
- * const resolver = dns({
- *   resolvers: {
- *     // will only be used to resolve `.com` addresses
- *     'com.': dnsJsonOverHttps('https://cloudflare-dns.com/dns-query'),
- *
- *     // this can also be an array, resolvers will be shuffled and tried in
- *     // series
- *     'net.': [
- *       dnsJsonOverHttps('https://dns.google/resolve'),
- *       dnsJsonOverHttps('https://dns.pub/dns-query')
- *     ],
- *
- *     // will only be used to resolve all other addresses
- *     '.': dnsJsonOverHttps('https://dnsforge.de/dns-query'),
- *   }
- * })
- * ```
- *
- * @example Query for specific record types
- *
- * ```TypeScript
- * import { dns, RecordType } from '@multiformats/dns'
- *
- * const resolver = dns()
- *
- * // resolve only TXT records
- * const result = await dns.query('google.com', {
- *   types: [
- *     RecordType.TXT
- *   ]
- * })
- * ```
- *
- * ## Caching
- *
- * Individual Aanswers are cached so. If you make a request, for which all
- * record types are cached, all values will be pulled from the cache.
- *
- * If any of the record types are not cached, a new request will be resolved as
- * if none of the records were cached, and the cache will be updated to include
- * the new results.
- *
- * @example Ignoring the cache
- *
- * ```TypeScript
- * import { dns, RecordType } from '@multiformats/dns'
- *
- * const resolver = dns()
- *
- * // do not used cached results, always resolve a new query
- * const result = await dns.query('google.com', {
- *   cached: false
- * })
- * ```
- */
-/**
- * A subset of DNS Record Types
- *
- * @see https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-4.
- */
-var RecordType;
-(function (RecordType) {
-  RecordType[RecordType["A"] = 1] = "A";
-  RecordType[RecordType["CNAME"] = 5] = "CNAME";
-  RecordType[RecordType["TXT"] = 16] = "TXT";
-  RecordType[RecordType["AAAA"] = 28] = "AAAA";
-})(RecordType || (RecordType = {}));
-function dns() {
-  let init = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-  return new DNS(init);
-}
-
-export { RecordType, dns };

package/dist/esm/node_modules/@multiformats/dns/dist/src/resolvers/default.browser.js

@@ -1,7 +0,0 @@
-import { dnsJsonOverHttps } from './dns-json-over-https.js';
-
-function defaultResolver() {
-  return [dnsJsonOverHttps('https://cloudflare-dns.com/dns-query'), dnsJsonOverHttps('https://dns.google/resolve')];
-}
-
-export { defaultResolver };