web-dc-api 0.0.61 → 0.0.62

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

@@ -1,4 +1,3 @@
-import { StreamStateError, TimeoutError } from '@libp2p/interface';
 import { AbstractStream } from '../../../utils/dist/src/abstract-stream.js';
 import { anySignal } from '../../../../any-signal/dist/src/index.js';
 import { encode } from '../../../../it-length-prefixed/dist/src/encode.js';
@@ -11,6 +10,7 @@ import { raceSignal } from '../../../../race-signal/dist/src/index.js';
 import { Uint8ArrayList } from '../../../../uint8arraylist/dist/src/index.js';
 import { BUFFERED_AMOUNT_LOW_TIMEOUT, MAX_BUFFERED_AMOUNT, MAX_MESSAGE_SIZE, PROTOBUF_OVERHEAD, FIN_ACK_TIMEOUT, OPEN_TIMEOUT } from './constants.js';
 import { Message } from './private-to-public/pb/message.js';
+import { StreamStateError, TimeoutError } from '../../../interface/dist/src/errors.js';
 
 class WebRTCStream extends AbstractStream {
   /**

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

@@ -0,0 +1,4 @@
+// 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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,96 @@
+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/dns/dist/src/dns.js

@@ -0,0 +1,80 @@
+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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,7 @@
+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 };

package/dist/esm/node_modules/@multiformats/dns/dist/src/resolvers/dns-json-over-https.js

@@ -0,0 +1,71 @@
+import PQueue from '../../../../../p-queue/dist/index.js';
+import { CustomProgressEvent } from '../../../../../progress-events/dist/src/index.js';
+import { RecordType } from '../index.js';
+import { getTypes } from '../utils/get-types.js';
+import { toDNSResponse } from '../utils/to-dns-response.js';
+
+/* eslint-env browser */
+/**
+ * Browsers limit concurrent connections per host (~6), we don't want to exhaust
+ * the limit so this value controls how many DNS queries can be in flight at
+ * once.
+ */
+const DEFAULT_QUERY_CONCURRENCY = 4;
+/**
+ * Uses the RFC 8427 'application/dns-json' content-type to resolve DNS queries.
+ *
+ * Supports and server that uses the same schema as Google's DNS over HTTPS
+ * resolver.
+ *
+ * This resolver needs fewer dependencies than the regular DNS-over-HTTPS
+ * resolver so can result in a smaller bundle size and consequently is preferred
+ * for browser use.
+ *
+ * @see https://developers.cloudflare.com/1.1.1.1/encryption/dns-over-https/make-api-requests/dns-json/
+ * @see https://github.com/curl/curl/wiki/DNS-over-HTTPS#publicly-available-servers
+ * @see https://dnsprivacy.org/public_resolvers/
+ * @see https://datatracker.ietf.org/doc/html/rfc8427
+ */
+function dnsJsonOverHttps(url) {
+  let init = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const httpQueue = new PQueue({
+    concurrency: init.queryConcurrency ?? DEFAULT_QUERY_CONCURRENCY
+  });
+  return async function (fqdn) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const searchParams = new URLSearchParams();
+    searchParams.set('name', fqdn);
+    getTypes(options.types).forEach(type => {
+      // We pass record type as a string to the server because cloudflare DNS bug. see https://github.com/ipfs/helia/issues/474
+      searchParams.append('type', RecordType[type]);
+    });
+    options.onProgress?.(new CustomProgressEvent('dns:query', {
+      detail: fqdn
+    }));
+    // query DNS-JSON over HTTPS server
+    const response = await httpQueue.add(async () => {
+      const res = await fetch(`${url}?${searchParams}`, {
+        headers: {
+          accept: 'application/dns-json'
+        },
+        signal: options?.signal
+      });
+      if (res.status !== 200) {
+        throw new Error(`Unexpected HTTP status: ${res.status} - ${res.statusText}`);
+      }
+      const response = toDNSResponse(await res.json());
+      options.onProgress?.(new CustomProgressEvent('dns:response', {
+        detail: response
+      }));
+      return response;
+    }, {
+      signal: options.signal
+    });
+    if (response == null) {
+      throw new Error('No DNS response received');
+    }
+    return response;
+  };
+}
+
+export { DEFAULT_QUERY_CONCURRENCY, dnsJsonOverHttps };

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

@@ -0,0 +1,82 @@
+import hashlru from '../../../../../../_virtual/index34.js';
+import { RecordType } from '../index.js';
+import { toDNSResponse, DEFAULT_TTL } from './to-dns-response.js';
+
+/**
+ * Time Aware Least Recent Used Cache
+ *
+ * @see https://arxiv.org/pdf/1801.00390
+ */
+class CachedAnswers {
+  lru;
+  constructor(maxSize) {
+    this.lru = hashlru(maxSize);
+  }
+  get(fqdn, types) {
+    let foundAllAnswers = true;
+    const answers = [];
+    for (const type of types) {
+      const cached = this.getAnswers(fqdn, type);
+      if (cached.length === 0) {
+        foundAllAnswers = false;
+        break;
+      }
+      answers.push(...cached);
+    }
+    if (foundAllAnswers) {
+      return toDNSResponse({
+        answers
+      });
+    }
+  }
+  getAnswers(domain, type) {
+    const key = `${domain.toLowerCase()}-${type}`;
+    const answers = this.lru.get(key);
+    if (answers != null) {
+      const cachedAnswers = answers.filter(entry => {
+        return entry.expires > Date.now();
+      }).map(_ref => {
+        let {
+          expires,
+          value
+        } = _ref;
+        return {
+          ...value,
+          TTL: Math.round((expires - Date.now()) / 1000),
+          type: RecordType[value.type]
+        };
+      });
+      if (cachedAnswers.length === 0) {
+        this.lru.remove(key);
+      }
+      // @ts-expect-error hashlru stringifies stored types which turns enums
+      // into strings, we convert back into enums above but tsc doesn't know
+      return cachedAnswers;
+    }
+    return [];
+  }
+  add(domain, answer) {
+    const key = `${domain.toLowerCase()}-${answer.type}`;
+    const answers = this.lru.get(key) ?? [];
+    answers.push({
+      expires: Date.now() + (answer.TTL ?? DEFAULT_TTL) * 1000,
+      value: answer
+    });
+    this.lru.set(key, answers);
+  }
+  remove(domain, type) {
+    const key = `${domain.toLowerCase()}-${type}`;
+    this.lru.remove(key);
+  }
+  clear() {
+    this.lru.clear();
+  }
+}
+/**
+ * Avoid sending multiple queries for the same hostname by caching results
+ */
+function cache(size) {
+  return new CachedAnswers(size);
+}
+
+export { cache };

package/dist/esm/node_modules/@multiformats/dns/dist/src/utils/get-types.js

@@ -0,0 +1,17 @@
+import { RecordType } from '../index.js';
+
+function getTypes(types) {
+  const DEFAULT_TYPES = [RecordType.A];
+  if (types == null) {
+    return DEFAULT_TYPES;
+  }
+  if (Array.isArray(types)) {
+    if (types.length === 0) {
+      return DEFAULT_TYPES;
+    }
+    return types;
+  }
+  return [types];
+}
+
+export { getTypes };

package/dist/esm/node_modules/@multiformats/dns/dist/src/utils/to-dns-response.js

@@ -0,0 +1,33 @@
+import { toString } from '../../../../../uint8arrays/dist/src/to-string.js';
+import { RecordType } from '../index.js';
+
+/**
+ * This TTL will be used if the remote service does not return one
+ */
+const DEFAULT_TTL = 60;
+function toDNSResponse(obj) {
+  return {
+    Status: obj.Status ?? 0,
+    TC: obj.TC ?? obj.flag_tc ?? false,
+    RD: obj.RD ?? obj.flag_rd ?? false,
+    RA: obj.RA ?? obj.flag_ra ?? false,
+    AD: obj.AD ?? obj.flag_ad ?? false,
+    CD: obj.CD ?? obj.flag_cd ?? false,
+    Question: (obj.Question ?? obj.questions ?? []).map(question => {
+      return {
+        name: question.name,
+        type: RecordType[question.type]
+      };
+    }),
+    Answer: (obj.Answer ?? obj.answers ?? []).map(answer => {
+      return {
+        name: answer.name,
+        type: RecordType[answer.type],
+        TTL: answer.TTL ?? answer.ttl ?? DEFAULT_TTL,
+        data: answer.data instanceof Uint8Array ? toString(answer.data) : answer.data
+      };
+    })
+  };
+}
+
+export { DEFAULT_TTL, toDNSResponse };