@helia/ipns 2.0.3 → 3.0.1

package/src/dns-resolvers/dns-over-https.ts

@@ -0,0 +1,146 @@
+/* eslint-env browser */
+
+import { Buffer } from 'buffer'
+import dnsPacket, { type DecodedPacket } from 'dns-packet'
+import { base64url } from 'multiformats/bases/base64'
+import PQueue from 'p-queue'
+import { CustomProgressEvent } from 'progress-events'
+import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
+import { type DNSResponse, MAX_RECURSIVE_DEPTH, recursiveResolveDnslink, ipfsPathAndAnswer } from '../utils/dns.js'
+import { TLRU } from '../utils/tlru.js'
+import type { ResolveDnsLinkOptions, DNSResolver } from '../index.js'
+
+// Avoid sending multiple queries for the same hostname by caching results
+const cache = new TLRU<string>(1000)
+// This TTL will be used if the remote service does not return one
+const ttl = 60 * 1000
+
+/**
+ * Uses the RFC 1035 'application/dns-message' content-type to resolve DNS
+ * queries.
+ *
+ * This resolver needs more dependencies than the non-standard
+ * DNS-JSON-over-HTTPS resolver so can result in a larger bundle size and
+ * consequently is not preferred for browser use.
+ *
+ * @see https://datatracker.ietf.org/doc/html/rfc1035
+ * @see https://developers.cloudflare.com/1.1.1.1/encryption/dns-over-https/make-api-requests/dns-wireformat/
+ * @see https://github.com/curl/curl/wiki/DNS-over-HTTPS#publicly-available-servers
+ * @see https://dnsprivacy.org/public_resolvers/
+ */
+export function dnsOverHttps (url: string): DNSResolver {
+  // browsers limit concurrent connections per host,
+  // we don't want preload calls to exhaust the limit (~6)
+  const httpQueue = new PQueue({ concurrency: 4 })
+
+  const resolve = async (fqdn: string, options: ResolveDnsLinkOptions = {}): Promise<string> => {
+    const dnsQuery = dnsPacket.encode({
+      type: 'query',
+      id: 0,
+      flags: dnsPacket.RECURSION_DESIRED,
+      questions: [{
+        type: 'TXT',
+        name: fqdn
+      }]
+    })
+
+    const searchParams = new URLSearchParams()
+    searchParams.set('dns', base64url.encode(dnsQuery).substring(1))
+
+    const query = searchParams.toString()
+
+    // try cache first
+    if (options.nocache !== true && cache.has(query)) {
+      const response = cache.get(query)
+
+      if (response != null) {
+        options.onProgress?.(new CustomProgressEvent<string>('dnslink:cache', { detail: response }))
+        return response
+      }
+    }
+
+    options.onProgress?.(new CustomProgressEvent<string>('dnslink:query', { detail: fqdn }))
+
+    // query DNS over HTTPS server
+    const response = await httpQueue.add(async () => {
+      const res = await fetch(`${url}?${searchParams}`, {
+        headers: {
+          accept: 'application/dns-message'
+        },
+        signal: options.signal
+      })
+
+      if (res.status !== 200) {
+        throw new Error(`Unexpected HTTP status: ${res.status} - ${res.statusText}`)
+      }
+
+      const query = new URL(res.url).search.slice(1)
+      const buf = await res.arrayBuffer()
+      // map to expected response format
+      const json = toDNSResponse(dnsPacket.decode(Buffer.from(buf)))
+
+      options.onProgress?.(new CustomProgressEvent<DNSResponse>('dnslink:answer', { detail: json }))
+
+      const { ipfsPath, answer } = ipfsPathAndAnswer(fqdn, json)
+
+      cache.set(query, ipfsPath, answer.TTL ?? ttl)
+
+      return ipfsPath
+    }, {
+      signal: options.signal
+    })
+
+    if (response == null) {
+      throw new Error('No DNS response received')
+    }
+
+    return response
+  }
+
+  return async (domain: string, options: ResolveDnsLinkOptions = {}) => {
+    return recursiveResolveDnslink(domain, MAX_RECURSIVE_DEPTH, resolve, options)
+  }
+}
+
+function toDNSResponse (response: DecodedPacket): DNSResponse {
+  const txtType = 16
+
+  return {
+    Status: 0,
+    TC: response.flag_tc ?? false,
+    RD: response.flag_rd ?? false,
+    RA: response.flag_ra ?? false,
+    AD: response.flag_ad ?? false,
+    CD: response.flag_cd ?? false,
+    Question: response.questions?.map(q => ({
+      name: q.name,
+      type: txtType
+    })) ?? [],
+    Answer: response.answers?.map(a => {
+      if (a.type !== 'TXT' || a.data.length < 1) {
+        return {
+          name: a.name,
+          type: txtType,
+          TTL: 0,
+          data: 'invalid'
+        }
+      }
+
+      if (!Buffer.isBuffer(a.data[0])) {
+        return {
+          name: a.name,
+          type: txtType,
+          TTL: a.ttl ?? ttl,
+          data: String(a.data[0])
+        }
+      }
+
+      return {
+        name: a.name,
+        type: txtType,
+        TTL: a.ttl ?? ttl,
+        data: uint8ArrayToString(a.data[0])
+      }
+    }) ?? []
+  }
+}

package/src/dns-resolvers/index.ts

@@ -0,0 +1,2 @@
+export { dnsOverHttps } from './dns-over-https.js'
+export { dnsJsonOverHttps } from './dns-json-over-https.js'

package/src/dns-resolvers/resolver.browser.ts

@@ -0,0 +1,50 @@
+import Resolver from 'dns-over-http-resolver'
+import PQueue from 'p-queue'
+import { CustomProgressEvent } from 'progress-events'
+import { resolveFn, type DNSResponse } from '../utils/dns.js'
+import { TLRU } from '../utils/tlru.js'
+import type { DNSResolver } from '../index.js'
+
+const cache = new TLRU<string>(1000)
+// We know browsers themselves cache DNS records for at least 1 minute,
+// which acts a provisional default ttl: https://stackoverflow.com/a/36917902/11518426
+const ttl = 60 * 1000
+
+// browsers limit concurrent connections per host,
+// we don't want to exhaust the limit (~6)
+const httpQueue = new PQueue({ concurrency: 4 })
+
+const resolve: DNSResolver = async function resolve (domain, options = {}) {
+  const resolver = new Resolver({ maxCache: 0 })
+  // try cache first
+  if (options.nocache !== true && cache.has(domain)) {
+    const response = cache.get(domain)
+
+    if (response != null) {
+      options?.onProgress?.(new CustomProgressEvent<string>('dnslink:cache', { detail: response }))
+      return response
+    }
+  }
+
+  options.onProgress?.(new CustomProgressEvent<string>('dnslink:query', { detail: domain }))
+
+  // Add the query to the queue
+  const response = await httpQueue.add(async () => {
+    const dnslinkRecord = await resolveFn(resolver, domain)
+
+    options.onProgress?.(new CustomProgressEvent<DNSResponse>('dnslink:answer', { detail: dnslinkRecord }))
+    cache.set(domain, dnslinkRecord, ttl)
+
+    return dnslinkRecord
+  }, {
+    signal: options?.signal
+  })
+
+  if (response == null) {
+    throw new Error('No DNS response received')
+  }
+
+  return response
+}
+
+export default resolve

package/src/dns-resolvers/resolver.ts

@@ -0,0 +1,25 @@
+import { Resolver } from 'dns/promises'
+import { CustomProgressEvent } from 'progress-events'
+import { resolveFn, type DNSResponse } from '../utils/dns.js'
+import type { DNSResolver } from '../index.js'
+
+const resolve: DNSResolver = async function resolve (domain, options = {}) {
+  const resolver = new Resolver()
+  const listener = (): void => {
+    resolver.cancel()
+  }
+
+  options.signal?.addEventListener('abort', listener)
+
+  try {
+    options.onProgress?.(new CustomProgressEvent<string>('dnslink:query', { detail: domain }))
+    const dnslinkRecord = await resolveFn(resolver, domain)
+
+    options.onProgress?.(new CustomProgressEvent<DNSResponse>('dnslink:answer', { detail: dnslinkRecord }))
+    return dnslinkRecord
+  } finally {
+    options.signal?.removeEventListener('abort', listener)
+  }
+}
+
+export default resolve

package/src/index.ts

@@ -5,16 +5,21 @@
  *
  * @example
  *
+ * With {@link IPNSRouting} routers:
+ *
  * ```typescript
  * import { createHelia } from 'helia'
+ * import { ipns } from '@helia/ipns'
  * import { dht, pubsub } from '@helia/ipns/routing'
  * import { unixfs } from '@helia/unixfs'
  *
  * const helia = await createHelia()
- * const name = ipns(helia, [
- *   dht(helia),
- *   pubsub(helia)
- * ])
+ * const name = ipns(helia, {
+ *  routers: [
+ *    dht(helia),
+ *    pubsub(helia)
+ *  ]
+ * })
  *
  * // create a public key to publish as an IPNS name
  * const keyInfo = await helia.libp2p.keychain.createKey('my-key')
@@ -33,13 +38,77 @@
  *
  * @example
  *
+ * With default {@link DNSResolver} resolvers:
+ *
+ * ```typescript
+ * import { createHelia } from 'helia'
+ * import { ipns } from '@helia/ipns'
+ * import { unixfs } from '@helia/unixfs'
+ * import { dnsOverHttps } from '@helia/ipns/dns-resolvers'
+ *
+ * const helia = await createHelia()
+ * const name = ipns(helia, {
+ *  resolvers: [
+ *    dnsOverHttps('https://private-dns-server.me/dns-query'),
+ *  ]
+ * })
+ *
+ * const cid = name.resolveDns('some-domain-with-dnslink-entry.com')
+ * ```
+ *
+ * @example
+ *
+ * Calling `resolveDns` with the `@helia/ipns` instance:
+ *
  * ```typescript
- * // resolve a CID from a TXT record in a DNS zone file, eg:
- * // > dig ipfs.io TXT
+ * // resolve a CID from a TXT record in a DNS zone file, using the default
+ * // resolver for the current platform eg:
+ * // > dig _dnslink.ipfs.io TXT
  * // ;; ANSWER SECTION:
- * // ipfs.io.           435     IN      TXT     "dnslink=/ipfs/Qmfoo"
+ * // _dnslink.ipfs.io.          60     IN      TXT     "dnslink=/ipns/website.ipfs.io"
+ * // > dig _dnslink.website.ipfs.io TXT
+ * // ;; ANSWER SECTION:
+ * // _dnslink.website.ipfs.io.  60     IN      TXT     "dnslink=/ipfs/QmWebsite"
  *
  * const cid = name.resolveDns('ipfs.io')
+ *
+ * console.info(cid)
+ * // QmWebsite
+ * ```
+ *
+ * @example
+ *
+ * This example uses the Mozilla provided RFC 1035 DNS over HTTPS service. This
+ * uses binary DNS records so requires extra dependencies to process the
+ * response which can increase browser bundle sizes.
+ *
+ * If this is a concern, use the DNS-JSON-Over-HTTPS resolver instead.
+ *
+ * ```typescript
+ * // use DNS-Over-HTTPS
+ * import { dnsOverHttps } from '@helia/ipns/dns-resolvers'
+ *
+ * const cid = name.resolveDns('ipfs.io', {
+ *   resolvers: [
+ *     dnsOverHttps('https://mozilla.cloudflare-dns.com/dns-query')
+ *   ]
+ * })
+ * ```
+ *
+ * @example
+ *
+ * DNS-JSON-Over-HTTPS resolvers use the RFC 8427 `application/dns-json` and can
+ * result in a smaller browser bundle due to the response being plain JSON.
+ *
+ * ```typescript
+ * // use DNS-JSON-Over-HTTPS
+ * import { dnsJsonOverHttps } from '@helia/ipns/dns-resolvers'
+ *
+ * const cid = name.resolveDns('ipfs.io', {
+ *   resolvers: [
+ *     dnsJsonOverHttps('https://mozilla.cloudflare-dns.com/dns-query')
+ *   ]
+ * })
  * ```
  */
 
@@ -51,9 +120,10 @@ import { ipnsSelector } from 'ipns/selector'
 import { ipnsValidator } from 'ipns/validator'
 import { CID } from 'multiformats/cid'
 import { CustomProgressEvent } from 'progress-events'
+import { defaultResolver } from './dns-resolvers/default.js'
 import { localStore, type LocalStore } from './routing/local-store.js'
-import { resolveDnslink } from './utils/resolve-dns-link.js'
 import type { IPNSRouting, IPNSRoutingEvents } from './routing/index.js'
+import type { DNSResponse } from './utils/dns.js'
 import type { AbortOptions } from '@libp2p/interface'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Datastore } from 'interface-datastore'
@@ -83,6 +153,11 @@ export type RepublishProgressEvents =
   ProgressEvent<'ipns:republish:success', IPNSRecord> |
   ProgressEvent<'ipns:republish:error', { record: IPNSRecord, err: Error }>
 
+export type ResolveDnsLinkProgressEvents =
+  ProgressEvent<'dnslink:cache', string> |
+  ProgressEvent<'dnslink:query', string> |
+  ProgressEvent<'dnslink:answer', DNSResponse>
+
 export interface PublishOptions extends AbortOptions, ProgressOptions<PublishProgressEvents | IPNSRoutingEvents> {
   /**
    * Time duration of the record in ms (default: 24hrs)
@@ -108,11 +183,35 @@ export interface ResolveOptions extends AbortOptions, ProgressOptions<ResolvePro
   offline?: boolean
 }
 
-export interface ResolveDNSOptions extends ResolveOptions {
+export interface ResolveDnsLinkOptions extends AbortOptions, ProgressOptions<ResolveDnsLinkProgressEvents> {
+  /**
+   * Do not use cached DNS entries (default: false)
+   */
+  nocache?: boolean
+}
+
+export interface DNSResolver {
+  (domain: string, options?: ResolveDnsLinkOptions): Promise<string>
+}
+
+export interface ResolveDNSOptions extends AbortOptions, ProgressOptions<ResolveProgressEvents | IPNSRoutingEvents | ResolveDnsLinkProgressEvents> {
+  /**
+   * Do not query the network for the IPNS record (default: false)
+   */
+  offline?: boolean
+
   /**
    * Do not use cached DNS entries (default: false)
    */
   nocache?: boolean
+
+  /**
+   * These resolvers will be used to resolve the dnslink entries, if unspecified node will
+   * fall back to the `dns` module and browsers fall back to querying google/cloudflare DoH
+   *
+   * @see https://github.com/ipfs/helia-ipns/pull/55#discussion_r1270096881
+   */
+  resolvers?: DNSResolver[]
 }
 
 export interface RepublishOptions extends AbortOptions, ProgressOptions<RepublishProgressEvents | IPNSRoutingEvents> {
@@ -126,7 +225,7 @@ export interface IPNS {
   /**
    * Creates an IPNS record signed by the passed PeerId that will resolve to the passed value
    *
-   * If the valid is a PeerId, a recursive IPNS record will be created.
+   * If the value is a PeerId, a recursive IPNS record will be created.
    */
   publish(key: PeerId, value: CID | PeerId, options?: PublishOptions): Promise<IPNSRecord>
 
@@ -157,10 +256,12 @@ class DefaultIPNS implements IPNS {
   private readonly routers: IPNSRouting[]
   private readonly localStore: LocalStore
   private timeout?: ReturnType<typeof setTimeout>
+  private readonly defaultResolvers: DNSResolver[]
 
-  constructor (components: IPNSComponents, routers: IPNSRouting[] = []) {
+  constructor (components: IPNSComponents, routers: IPNSRouting[] = [], resolvers: DNSResolver[] = []) {
     this.routers = routers
     this.localStore = localStore(components.datastore)
+    this.defaultResolvers = resolvers.length > 0 ? resolvers : [defaultResolver()]
   }
 
   async publish (key: PeerId, value: CID | PeerId, options: PublishOptions = {}): Promise<IPNSRecord> {
@@ -201,7 +302,11 @@ class DefaultIPNS implements IPNS {
   }
 
   async resolveDns (domain: string, options: ResolveDNSOptions = {}): Promise<CID> {
-    const dnslink = await resolveDnslink(domain, options)
+    const resolvers = options.resolvers ?? this.defaultResolvers
+
+    const dnslink = await Promise.any(
+      resolvers.map(async resolver => resolver(domain, options))
+    )
 
     return this.#resolve(dnslink, options)
   }
@@ -298,8 +403,13 @@ class DefaultIPNS implements IPNS {
   }
 }
 
-export function ipns (components: IPNSComponents, routers: IPNSRouting[] = []): IPNS {
-  return new DefaultIPNS(components, routers)
+export interface IPNSOptions {
+  routers?: IPNSRouting[]
+  resolvers?: DNSResolver[]
+}
+
+export function ipns (components: IPNSComponents, { routers = [], resolvers = [] }: IPNSOptions): IPNS {
+  return new DefaultIPNS(components, routers, resolvers)
 }
 
 export { ipnsValidator }

package/src/utils/dns.ts

@@ -0,0 +1,126 @@
+import { CodeError } from '@libp2p/interface/errors'
+import * as isIPFS from 'is-ipfs'
+import type { DNSResolver, ResolveDnsLinkOptions } from '../index.js'
+
+export interface Question {
+  name: string
+  type: number
+}
+
+export interface Answer {
+  name: string
+  type: number
+  TTL: number
+  data: string
+}
+
+export interface DNSResponse {
+  Status: number
+  TC: boolean
+  RD: boolean
+  RA: boolean
+  AD: boolean
+  CD: boolean
+  Question: Question[]
+  Answer?: Answer[]
+}
+
+export const ipfsPathForAnswer = (answer: Answer): string => {
+  let data = answer.data
+
+  if (data.startsWith('"')) {
+    data = data.substring(1)
+  }
+
+  if (data.endsWith('"')) {
+    data = data.substring(0, data.length - 1)
+  }
+
+  return data.replace('dnslink=', '')
+}
+
+export const ipfsPathAndAnswer = (domain: string, response: DNSResponse): { ipfsPath: string, answer: Answer } => {
+  const answer = findDNSLinkAnswer(domain, response)
+
+  return {
+    ipfsPath: ipfsPathForAnswer(answer),
+    answer
+  }
+}
+
+export const findDNSLinkAnswer = (domain: string, response: DNSResponse): Answer => {
+  const answer = response.Answer?.filter(a => a.data.includes('dnslink=/ipfs') || a.data.includes('dnslink=/ipns')).pop()
+
+  if (answer == null) {
+    throw new CodeError(`No dnslink records found for domain: ${domain}`, 'ERR_DNSLINK_NOT_FOUND')
+  }
+
+  return answer
+}
+
+export const MAX_RECURSIVE_DEPTH = 32
+
+export const recursiveResolveDnslink = async (domain: string, depth: number, resolve: DNSResolver, options: ResolveDnsLinkOptions = {}): Promise<string> => {
+  if (depth === 0) {
+    throw new Error('recursion limit exceeded')
+  }
+
+  let dnslinkRecord: string
+
+  try {
+    dnslinkRecord = await resolve(domain, options)
+  } catch (err: any) {
+    // If the code is not ENOTFOUND or ERR_DNSLINK_NOT_FOUND or ENODATA then throw the error
+    if (err.code !== 'ENOTFOUND' && err.code !== 'ERR_DNSLINK_NOT_FOUND' && err.code !== 'ENODATA') {
+      throw err
+    }
+
+    if (domain.startsWith('_dnslink.')) {
+      // The supplied domain contains a _dnslink component
+      // Check the non-_dnslink domain
+      domain = domain.replace('_dnslink.', '')
+    } else {
+      // Check the _dnslink subdomain
+      domain = `_dnslink.${domain}`
+    }
+
+    // If this throws then we propagate the error
+    dnslinkRecord = await resolve(domain, options)
+  }
+
+  const result = dnslinkRecord.replace('dnslink=', '')
+  // result is now a `/ipfs/<cid>` or `/ipns/<cid>` string
+  const domainOrCID = result.split('/')[2] // e.g. ["", "ipfs", "<cid>"]
+  const isIPFSCID = isIPFS.cid(domainOrCID)
+
+  // if the result is a CID, or depth is 1, we've reached the end of the recursion
+  // if depth is 1, another recursive call will be made, but it would throw.
+  // we could return if depth is 1 and allow users to handle, but that may be a breaking change
+  if (isIPFSCID) {
+    return result
+  }
+
+  return recursiveResolveDnslink(domainOrCID, depth - 1, resolve, options)
+}
+
+interface DnsResolver {
+  resolveTxt(domain: string): Promise<string[][]>
+}
+
+const DNSLINK_REGEX = /^dnslink=.+$/
+export const resolveFn = async (resolver: DnsResolver, domain: string): Promise<string> => {
+  const records = await resolver.resolveTxt(domain)
+  const dnslinkRecords = records.flat()
+    .filter(record => DNSLINK_REGEX.test(record))
+
+  // we now have dns text entries as an array of strings
+  // only records passing the DNSLINK_REGEX text are included
+  // TODO: support multiple dnslink records
+  const dnslinkRecord = dnslinkRecords[0]
+
+  if (dnslinkRecord == null) {
+    throw new CodeError(`No dnslink records found for domain: ${domain}`, 'ERR_DNSLINK_NOT_FOUND')
+  }
+
+  return dnslinkRecord
+}

package/dist/src/utils/resolve-dns-link.browser.d.ts

@@ -1,6 +0,0 @@
-import type { AbortOptions } from '@libp2p/interface';
-export interface ResolveDnsLinkOptions extends AbortOptions {
-    nocache?: boolean;
-}
-export declare function resolveDnslink(fqdn: string, opts?: ResolveDnsLinkOptions): Promise<string>;
-//# sourceMappingURL=resolve-dns-link.browser.d.ts.map

package/dist/src/utils/resolve-dns-link.browser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-dns-link.browser.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve-dns-link.browser.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAoBrD,MAAM,WAAW,qBAAsB,SAAQ,YAAY;IACzD,OAAO,CAAC,EAAE,OAAO,CAAA;CAClB;AAED,wBAAsB,cAAc,CAAE,IAAI,EAAE,MAAM,EAAE,IAAI,GAAE,qBAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CAgCrG"}

package/dist/src/utils/resolve-dns-link.browser.js

@@ -1,46 +0,0 @@
-/* eslint-env browser */
-import PQueue from 'p-queue';
-import { TLRU } from './tlru.js';
-// Avoid sending multiple queries for the same hostname by caching results
-const cache = new TLRU(1000);
-// TODO: /api/v0/dns does not return TTL yet: https://github.com/ipfs/go-ipfs/issues/5884
-// However we know browsers themselves cache DNS records for at least 1 minute,
-// which acts a provisional default ttl: https://stackoverflow.com/a/36917902/11518426
-const ttl = 60 * 1000;
-// browsers limit concurrent connections per host,
-// we don't want preload calls to exhaust the limit (~6)
-const httpQueue = new PQueue({ concurrency: 4 });
-const ipfsPath = (response) => {
-    if (response.Path != null) {
-        return response.Path;
-    }
-    throw new Error(response.Message);
-};
-export async function resolveDnslink(fqdn, opts = {}) {
-    const resolve = async (fqdn, opts = {}) => {
-        // @ts-expect-error - URLSearchParams does not take boolean options, only strings
-        const searchParams = new URLSearchParams(opts);
-        searchParams.set('arg', fqdn);
-        // try cache first
-        const query = searchParams.toString();
-        if (opts.nocache !== true && cache.has(query)) {
-            const response = cache.get(query);
-            if (response != null) {
-                return ipfsPath(response);
-            }
-        }
-        // fallback to delegated DNS resolver
-        const response = await httpQueue.add(async () => {
-            // Delegated HTTP resolver sending DNSLink queries to ipfs.io
-            // TODO: replace hardcoded host with configurable DNS over HTTPS: https://github.com/ipfs/js-ipfs/issues/2212
-            const res = await fetch(`https://ipfs.io/api/v0/dns?${searchParams}`);
-            const query = new URL(res.url).search.slice(1);
-            const json = await res.json();
-            cache.set(query, json, ttl);
-            return json;
-        });
-        return ipfsPath(response);
-    };
-    return resolve(fqdn, opts);
-}
-//# sourceMappingURL=resolve-dns-link.browser.js.map

package/dist/src/utils/resolve-dns-link.browser.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-dns-link.browser.js","sourceRoot":"","sources":["../../../src/utils/resolve-dns-link.browser.ts"],"names":[],"mappings":"AAAA,wBAAwB;AAExB,OAAO,MAAM,MAAM,SAAS,CAAA;AAC5B,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAGhC,0EAA0E;AAC1E,MAAM,KAAK,GAAG,IAAI,IAAI,CAAoC,IAAI,CAAC,CAAA;AAC/D,yFAAyF;AACzF,+EAA+E;AAC/E,sFAAsF;AACtF,MAAM,GAAG,GAAG,EAAE,GAAG,IAAI,CAAA;AAErB,kDAAkD;AAClD,wDAAwD;AACxD,MAAM,SAAS,GAAG,IAAI,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,EAAE,CAAC,CAAA;AAEhD,MAAM,QAAQ,GAAG,CAAC,QAA2C,EAAU,EAAE;IACvE,IAAI,QAAQ,CAAC,IAAI,IAAI,IAAI,EAAE;QACzB,OAAO,QAAQ,CAAC,IAAI,CAAA;KACrB;IACD,MAAM,IAAI,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAA;AACnC,CAAC,CAAA;AAMD,MAAM,CAAC,KAAK,UAAU,cAAc,CAAE,IAAY,EAAE,OAA8B,EAAE;IAClF,MAAM,OAAO,GAAG,KAAK,EAAE,IAAY,EAAE,OAA8B,EAAE,EAAmB,EAAE;QACxF,iFAAiF;QACjF,MAAM,YAAY,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,CAAA;QAC9C,YAAY,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;QAE7B,kBAAkB;QAClB,MAAM,KAAK,GAAG,YAAY,CAAC,QAAQ,EAAE,CAAA;QACrC,IAAI,IAAI,CAAC,OAAO,KAAK,IAAI,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,EAAE;YAC7C,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAA;YAEjC,IAAI,QAAQ,IAAI,IAAI,EAAE;gBACpB,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAA;aAC1B;SACF;QAED,qCAAqC;QACrC,MAAM,QAAQ,GAAG,MAAM,SAAS,CAAC,GAAG,CAAC,KAAK,IAAI,EAAE;YAC9C,6DAA6D;YAC7D,6GAA6G;YAC7G,MAAM,GAAG,GAAG,MAAM,KAAK,CAAC,8BAA8B,YAAY,EAAE,CAAC,CAAA;YACrE,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;YAC9C,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAA;YAC7B,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC,CAAA;YAE3B,OAAO,IAAI,CAAA;QACb,CAAC,CAAC,CAAA;QAEF,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAA;IAC3B,CAAC,CAAA;IAED,OAAO,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;AAC5B,CAAC"}

package/dist/src/utils/resolve-dns-link.d.ts

@@ -1,3 +0,0 @@
-import type { AbortOptions } from '@libp2p/interface';
-export declare function resolveDnslink(domain: string, options?: AbortOptions): Promise<string>;
-//# sourceMappingURL=resolve-dns-link.d.ts.map

package/dist/src/utils/resolve-dns-link.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"resolve-dns-link.d.ts","sourceRoot":"","sources":["../../../src/utils/resolve-dns-link.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAIrD,wBAAsB,cAAc,CAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,YAAiB,GAAG,OAAO,CAAC,MAAM,CAAC,CAEjG"}