@waku/core 0.0.1

package/bundle/lib/peer_discovery_dns.js

@@ -0,0 +1,5018 @@
+import { m as multiaddrsToPeerInfo, s as symbol } from '../multiaddr_to_peer_info-fd1de516.js';
+import { E as EventEmitter, C as CustomEvent } from '../events-fcbda4dc.js';
+import { d as debug } from '../browser-1e1a2f27.js';
+import { d as ENR } from '../enr-9fc5eed8.js';
+import { e as verifySignature, k as keccak256 } from '../crypto-b00764b7.js';
+import '../index-2ae915be.js';
+import { g as bytesToUtf8, e as utf8ToBytes, f as fromString } from '../utils-9a3221f2.js';
+import { g as commonjsGlobal } from '../index-ba42b4fc.js';
+import '../index-0a4bdddc.js';
+import '../index-64ce43f0.js';
+
+const v4Regex$1 = /^(\d{1,3}\.){3,3}\d{1,3}$/;
+const v4Size = 4;
+const v6Regex$1 = /^(::)?(((\d{1,3}\.){3}(\d{1,3}){1})?([0-9a-f]){0,4}:{0,2}){1,8}(::)?$/i;
+const v6Size = 16;
+
+const v4 = {
+  name: 'v4',
+  size: v4Size,
+  isFormat: ip => v4Regex$1.test(ip),
+  encode (ip, buff, offset) {
+    offset = ~~offset;
+    buff = buff || new Uint8Array(offset + v4Size);
+    const max = ip.length;
+    let n = 0;
+    for (let i = 0; i < max;) {
+      const c = ip.charCodeAt(i++);
+      if (c === 46) { // "."
+        buff[offset++] = n;
+        n = 0;
+      } else {
+        n = n * 10 + (c - 48);
+      }
+    }
+    buff[offset] = n;
+    return buff
+  },
+  decode (buff, offset) {
+    offset = ~~offset;
+    return `${buff[offset++]}.${buff[offset++]}.${buff[offset++]}.${buff[offset]}`
+  }
+};
+
+const v6 = {
+  name: 'v6',
+  size: v6Size,
+  isFormat: ip => ip.length > 0 && v6Regex$1.test(ip),
+  encode (ip, buff, offset) {
+    offset = ~~offset;
+    let end = offset + v6Size;
+    let fill = -1;
+    let hexN = 0;
+    let decN = 0;
+    let prevColon = true;
+    let useDec = false;
+    buff = buff || new Uint8Array(offset + v6Size);
+    // Note: This algorithm needs to check if the offset
+    // could exceed the buffer boundaries as it supports
+    // non-standard compliant encodings that may go beyond
+    // the boundary limits. if (offset < end) checks should
+    // not be necessary...
+    for (let i = 0; i < ip.length; i++) {
+      let c = ip.charCodeAt(i);
+      if (c === 58) { // :
+        if (prevColon) {
+          if (fill !== -1) {
+            // Not Standard! (standard doesn't allow multiple ::)
+            // We need to treat
+            if (offset < end) buff[offset] = 0;
+            if (offset < end - 1) buff[offset + 1] = 0;
+            offset += 2;
+          } else if (offset < end) {
+            // :: in the middle
+            fill = offset;
+          }
+        } else {
+          // : ends the previous number
+          if (useDec === true) {
+            // Non-standard! (ipv4 should be at end only)
+            // A ipv4 address should not be found anywhere else but at
+            // the end. This codec also support putting characters
+            // after the ipv4 address..
+            if (offset < end) buff[offset] = decN;
+            offset++;
+          } else {
+            if (offset < end) buff[offset] = hexN >> 8;
+            if (offset < end - 1) buff[offset + 1] = hexN & 0xff;
+            offset += 2;
+          }
+          hexN = 0;
+          decN = 0;
+        }
+        prevColon = true;
+        useDec = false;
+      } else if (c === 46) { // . indicates IPV4 notation
+        if (offset < end) buff[offset] = decN;
+        offset++;
+        decN = 0;
+        hexN = 0;
+        prevColon = false;
+        useDec = true;
+      } else {
+        prevColon = false;
+        if (c >= 97) {
+          c -= 87; // a-f ... 97~102 -87 => 10~15
+        } else if (c >= 65) {
+          c -= 55; // A-F ... 65~70 -55 => 10~15
+        } else {
+          c -= 48; // 0-9 ... starting from charCode 48
+          decN = decN * 10 + c;
+        }
+        // We don't know yet if its a dec or hex number
+        hexN = (hexN << 4) + c;
+      }
+    }
+    if (prevColon === false) {
+      // Commiting last number
+      if (useDec === true) {
+        if (offset < end) buff[offset] = decN;
+        offset++;
+      } else {
+        if (offset < end) buff[offset] = hexN >> 8;
+        if (offset < end - 1) buff[offset + 1] = hexN & 0xff;
+        offset += 2;
+      }
+    } else if (fill === 0) {
+      // Not Standard! (standard doesn't allow multiple ::)
+      // This means that a : was found at the start AND end which means the
+      // end needs to be treated as 0 entry...
+      if (offset < end) buff[offset] = 0;
+      if (offset < end - 1) buff[offset + 1] = 0;
+      offset += 2;
+    } else if (fill !== -1) {
+      // Non-standard! (standard doens't allow multiple ::)
+      // Here we find that there has been a :: somewhere in the middle
+      // and the end. To treat the end with priority we need to move all
+      // written data two bytes to the right.
+      offset += 2;
+      for (let i = Math.min(offset - 1, end - 1); i >= fill + 2; i--) {
+        buff[i] = buff[i - 2];
+      }
+      buff[fill] = 0;
+      buff[fill + 1] = 0;
+      fill = offset;
+    }
+    if (fill !== offset && fill !== -1) {
+      // Move the written numbers to the end while filling the everything
+      // "fill" to the bytes with zeros.
+      if (offset > end - 2) {
+        // Non Standard support, when the cursor exceeds bounds.
+        offset = end - 2;
+      }
+      while (end > fill) {
+        buff[--end] = offset < end && offset > fill ? buff[--offset] : 0;
+      }
+    } else {
+      // Fill the rest with zeros
+      while (offset < end) {
+        buff[offset++] = 0;
+      }
+    }
+    return buff
+  },
+  decode (buff, offset) {
+    offset = ~~offset;
+    let result = '';
+    for (let i = 0; i < v6Size; i += 2) {
+      if (i !== 0) {
+        result += ':';
+      }
+      result += (buff[offset + i] << 8 | buff[offset + i + 1]).toString(16);
+    }
+    return result
+      .replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3')
+      .replace(/:{3,4}/, '::')
+  }
+};
+function sizeOf (ip) {
+  if (v4.isFormat(ip)) return v4.size
+  if (v6.isFormat(ip)) return v6.size
+  throw Error(`Invalid ip address: ${ip}`)
+}
+
+function familyOf (string) {
+  return sizeOf(string) === v4.size ? 1 : 2
+}
+
+function encode$2 (ip, buff, offset) {
+  offset = ~~offset;
+  const size = sizeOf(ip);
+  if (typeof buff === 'function') {
+    buff = buff(offset + size);
+  }
+  if (size === v4.size) {
+    return v4.encode(ip, buff, offset)
+  }
+  return v6.encode(ip, buff, offset)
+}
+
+function decode$2 (buff, offset, length) {
+  offset = ~~offset;
+  length = length || (buff.length - offset);
+  if (length === v4.size) {
+    return v4.decode(buff, offset, length)
+  }
+  if (length === v6.size) {
+    return v6.decode(buff, offset, length)
+  }
+  throw Error(`Invalid buffer size needs to be ${v4.size} for v4 or ${v6.size} for v6.`)
+}
+
+function toString$4 (type) {
+  switch (type) {
+    case 1: return 'A'
+    case 10: return 'NULL'
+    case 28: return 'AAAA'
+    case 18: return 'AFSDB'
+    case 42: return 'APL'
+    case 257: return 'CAA'
+    case 60: return 'CDNSKEY'
+    case 59: return 'CDS'
+    case 37: return 'CERT'
+    case 5: return 'CNAME'
+    case 49: return 'DHCID'
+    case 32769: return 'DLV'
+    case 39: return 'DNAME'
+    case 48: return 'DNSKEY'
+    case 43: return 'DS'
+    case 55: return 'HIP'
+    case 13: return 'HINFO'
+    case 45: return 'IPSECKEY'
+    case 25: return 'KEY'
+    case 36: return 'KX'
+    case 29: return 'LOC'
+    case 15: return 'MX'
+    case 35: return 'NAPTR'
+    case 2: return 'NS'
+    case 47: return 'NSEC'
+    case 50: return 'NSEC3'
+    case 51: return 'NSEC3PARAM'
+    case 12: return 'PTR'
+    case 46: return 'RRSIG'
+    case 17: return 'RP'
+    case 24: return 'SIG'
+    case 6: return 'SOA'
+    case 99: return 'SPF'
+    case 33: return 'SRV'
+    case 44: return 'SSHFP'
+    case 32768: return 'TA'
+    case 249: return 'TKEY'
+    case 52: return 'TLSA'
+    case 250: return 'TSIG'
+    case 16: return 'TXT'
+    case 252: return 'AXFR'
+    case 251: return 'IXFR'
+    case 41: return 'OPT'
+    case 255: return 'ANY'
+  }
+  return 'UNKNOWN_' + type
+}
+
+function toType (name) {
+  switch (name.toUpperCase()) {
+    case 'A': return 1
+    case 'NULL': return 10
+    case 'AAAA': return 28
+    case 'AFSDB': return 18
+    case 'APL': return 42
+    case 'CAA': return 257
+    case 'CDNSKEY': return 60
+    case 'CDS': return 59
+    case 'CERT': return 37
+    case 'CNAME': return 5
+    case 'DHCID': return 49
+    case 'DLV': return 32769
+    case 'DNAME': return 39
+    case 'DNSKEY': return 48
+    case 'DS': return 43
+    case 'HIP': return 55
+    case 'HINFO': return 13
+    case 'IPSECKEY': return 45
+    case 'KEY': return 25
+    case 'KX': return 36
+    case 'LOC': return 29
+    case 'MX': return 15
+    case 'NAPTR': return 35
+    case 'NS': return 2
+    case 'NSEC': return 47
+    case 'NSEC3': return 50
+    case 'NSEC3PARAM': return 51
+    case 'PTR': return 12
+    case 'RRSIG': return 46
+    case 'RP': return 17
+    case 'SIG': return 24
+    case 'SOA': return 6
+    case 'SPF': return 99
+    case 'SRV': return 33
+    case 'SSHFP': return 44
+    case 'TA': return 32768
+    case 'TKEY': return 249
+    case 'TLSA': return 52
+    case 'TSIG': return 250
+    case 'TXT': return 16
+    case 'AXFR': return 252
+    case 'IXFR': return 251
+    case 'OPT': return 41
+    case 'ANY': return 255
+    case '*': return 255
+  }
+  if (name.toUpperCase().startsWith('UNKNOWN_')) return parseInt(name.slice(8))
+  return 0
+}
+
+/*
+ * Traditional DNS header RCODEs (4-bits) defined by IANA in
+ * https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml
+ */
+
+function toString$3 (rcode) {
+  switch (rcode) {
+    case 0: return 'NOERROR'
+    case 1: return 'FORMERR'
+    case 2: return 'SERVFAIL'
+    case 3: return 'NXDOMAIN'
+    case 4: return 'NOTIMP'
+    case 5: return 'REFUSED'
+    case 6: return 'YXDOMAIN'
+    case 7: return 'YXRRSET'
+    case 8: return 'NXRRSET'
+    case 9: return 'NOTAUTH'
+    case 10: return 'NOTZONE'
+    case 11: return 'RCODE_11'
+    case 12: return 'RCODE_12'
+    case 13: return 'RCODE_13'
+    case 14: return 'RCODE_14'
+    case 15: return 'RCODE_15'
+  }
+  return 'RCODE_' + rcode
+}
+
+/*
+ * Traditional DNS header OPCODEs (4-bits) defined by IANA in
+ * https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-5
+ */
+
+function toString$2 (opcode) {
+  switch (opcode) {
+    case 0: return 'QUERY'
+    case 1: return 'IQUERY'
+    case 2: return 'STATUS'
+    case 3: return 'OPCODE_3'
+    case 4: return 'NOTIFY'
+    case 5: return 'UPDATE'
+    case 6: return 'OPCODE_6'
+    case 7: return 'OPCODE_7'
+    case 8: return 'OPCODE_8'
+    case 9: return 'OPCODE_9'
+    case 10: return 'OPCODE_10'
+    case 11: return 'OPCODE_11'
+    case 12: return 'OPCODE_12'
+    case 13: return 'OPCODE_13'
+    case 14: return 'OPCODE_14'
+    case 15: return 'OPCODE_15'
+  }
+  return 'OPCODE_' + opcode
+}
+
+function toString$1 (klass) {
+  switch (klass) {
+    case 1: return 'IN'
+    case 2: return 'CS'
+    case 3: return 'CH'
+    case 4: return 'HS'
+    case 255: return 'ANY'
+  }
+  return 'UNKNOWN_' + klass
+}
+
+function toClass (name) {
+  switch (name.toUpperCase()) {
+    case 'IN': return 1
+    case 'CS': return 2
+    case 'CH': return 3
+    case 'HS': return 4
+    case 'ANY': return 255
+  }
+  return 0
+}
+
+function toString (type) {
+  switch (type) {
+    // list at
+    // https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-11
+    case 1: return 'LLQ'
+    case 2: return 'UL'
+    case 3: return 'NSID'
+    case 5: return 'DAU'
+    case 6: return 'DHU'
+    case 7: return 'N3U'
+    case 8: return 'CLIENT_SUBNET'
+    case 9: return 'EXPIRE'
+    case 10: return 'COOKIE'
+    case 11: return 'TCP_KEEPALIVE'
+    case 12: return 'PADDING'
+    case 13: return 'CHAIN'
+    case 14: return 'KEY_TAG'
+    case 26946: return 'DEVICEID'
+  }
+  if (type < 0) {
+    return null
+  }
+  return `OPTION_${type}`
+}
+
+function toCode (name) {
+  if (typeof name === 'number') {
+    return name
+  }
+  if (!name) {
+    return -1
+  }
+  switch (name.toUpperCase()) {
+    case 'OPTION_0': return 0
+    case 'LLQ': return 1
+    case 'UL': return 2
+    case 'NSID': return 3
+    case 'OPTION_4': return 4
+    case 'DAU': return 5
+    case 'DHU': return 6
+    case 'N3U': return 7
+    case 'CLIENT_SUBNET': return 8
+    case 'EXPIRE': return 9
+    case 'COOKIE': return 10
+    case 'TCP_KEEPALIVE': return 11
+    case 'PADDING': return 12
+    case 'CHAIN': return 13
+    case 'KEY_TAG': return 14
+    case 'DEVICEID': return 26946
+    case 'OPTION_65535': return 65535
+  }
+  const m = name.match(/_(\d+)$/);
+  if (m) {
+    return parseInt(m[1], 10)
+  }
+  return -1
+}
+
+const SURROGATE_A = 0b1101100000000000;
+const SURROGATE_B = 0b1101110000000000;
+
+function encodingLength$1 (str) {
+  let len = 0;
+  const strLen = str.length;
+  for (let i = 0; i < strLen; i += 1) {
+    const code = str.charCodeAt(i);
+    if (code <= 0x7F) {
+      len += 1;
+    } else if (code <= 0x07FF) {
+      len += 2;
+    } else if ((code & 0xF800) !== SURROGATE_A) {
+      len += 3;
+    } else {
+      const next = i + 1;
+      if (next === strLen || code >= SURROGATE_B) {
+        len += 3;
+      } else {
+        const nextCode = str.charCodeAt(next);
+        if ((nextCode & 0xFC00) !== SURROGATE_B) {
+          len += 3;
+        } else {
+          i = next;
+          len += 4;
+        }
+      }
+    }
+  }
+  return len
+}
+
+function encode$1 (str, buf, offset) {
+  const strLen = str.length;
+  if (offset === undefined || offset === null) {
+    offset = 0;
+  }
+  if (buf === undefined) {
+    buf = new Uint8Array(encodingLength$1(str) + offset);
+  }
+  let off = offset;
+  for (let i = 0; i < strLen; i += 1) {
+    let code = str.charCodeAt(i);
+    if (code <= 0x7F) {
+      buf[off++] = code;
+    } else if (code <= 0x07FF) {
+      buf[off++] = 0b11000000 | ((code & 0b11111000000) >> 6);
+      buf[off++] = 0b10000000 | (code & 0b00000111111);
+    } else if ((code & 0xF800) !== SURROGATE_A) {
+      buf[off++] = 0b11100000 | ((code & 0b1111000000000000) >> 12);
+      buf[off++] = 0b10000000 | ((code & 0b0000111111000000) >> 6);
+      buf[off++] = 0b10000000 | (code & 0b0000000000111111);
+    } else {
+      const next = i + 1;
+      if (next === strLen || code >= SURROGATE_B) {
+        // Incorrectly started surrogate pair
+        buf[off++] = 0xef;
+        buf[off++] = 0xbf;
+        buf[off++] = 0xbd;
+      } else {
+        const nextCode = str.charCodeAt(next);
+        if ((nextCode & 0xFC00) !== SURROGATE_B) {
+          // Incorrect surrogate pair
+          buf[off++] = 0xef;
+          buf[off++] = 0xbf;
+          buf[off++] = 0xbd;
+        } else {
+          i = next;
+          code = 0b000010000000000000000 |
+            ((code & 0b1111111111) << 10) |
+            (nextCode & 0b1111111111);
+          buf[off++] = 0b11110000 | ((code & 0b111000000000000000000) >> 18);
+          buf[off++] = 0b10000000 | ((code & 0b000111111000000000000) >> 12);
+          buf[off++] = 0b10000000 | ((code & 0b000000000111111000000) >> 6);
+          buf[off++] = 0b10000000 | (code & 0b000000000000000111111);
+        }
+      }
+    }
+  }
+  encode$1.bytes = off - offset;
+  return buf
+}
+encode$1.bytes = 0;
+
+function decode$1 (buf, start, end) {
+  let result = '';
+  if (start === undefined || start === null) {
+    start = 0;
+  }
+  if (end === undefined || end === null) {
+    end = buf.length;
+  }
+  for (let offset = start; offset < end;) {
+    const code = buf[offset++];
+    let num;
+    if (code <= 128) {
+      num = code;
+    } else if (code > 191 && code < 224) {
+      num = ((code & 0b11111) << 6) | (buf[offset++] & 0b111111);
+    } else if (code > 239 && code < 365) {
+      num = (
+        ((code & 0b111) << 18) |
+        ((buf[offset++] & 0b111111) << 12) |
+        ((buf[offset++] & 0b111111) << 6) |
+        (buf[offset++] & 0b111111)
+      ) - 0x10000;
+      const numA = SURROGATE_A | ((num >> 10) & 0b1111111111);
+      result += String.fromCharCode(numA);
+      num = SURROGATE_B | (num & 0b1111111111);
+    } else {
+      num = ((code & 0b1111) << 12) |
+        ((buf[offset++] & 0b111111) << 6) |
+        (buf[offset++] & 0b111111);
+    }
+    result += String.fromCharCode(num);
+  }
+  decode$1.bytes = end - start;
+  return result
+}
+decode$1.bytes = 0;
+
+const isU8Arr = input => input instanceof Uint8Array;
+
+function bytelength (input) {
+  return typeof input === 'string' ? encodingLength$1(input) : input.byteLength
+}
+
+function from (input) {
+  if (input instanceof Uint8Array) {
+    return input
+  }
+  if (Array.isArray(input)) {
+    return new Uint8Array(input)
+  }
+  return encode$1(input)
+}
+
+function write (arr, str, start) {
+  if (typeof str !== 'string') {
+    throw new Error('unknown input type')
+  }
+  encode$1(str, arr, start);
+  return encode$1.bytes
+}
+
+const P_24 = Math.pow(2, 24);
+const P_16 = Math.pow(2, 16);
+const P_8 = Math.pow(2, 8);
+const readUInt32BE = (buf, offset) => buf[offset] * P_24 +
+  buf[offset + 1] * P_16 +
+  buf[offset + 2] * P_8 +
+  buf[offset + 3];
+
+const readUInt16BE = (buf, offset) => (buf[offset] << 8) | buf[offset + 1];
+const writeUInt32BE = (buf, value, offset) => {
+  value = +value;
+  buf[offset + 3] = value;
+  value = value >>> 8;
+  buf[offset + 2] = value;
+  value = value >>> 8;
+  buf[offset + 1] = value;
+  value = value >>> 8;
+  buf[offset] = value;
+  return offset + 4
+};
+const writeUInt16BE = (buf, value, offset) => {
+  buf[offset] = value >> 8;
+  buf[offset + 1] = value & 0xFF;
+  return offset + 2
+};
+
+function copy (source, target, targetStart, sourceStart, sourceEnd) {
+  if (targetStart < 0) {
+    sourceStart -= targetStart;
+    targetStart = 0;
+  }
+
+  if (sourceStart < 0) {
+    sourceStart = 0;
+  }
+
+  if (sourceEnd < 0) {
+    return new Uint8Array(0)
+  }
+
+  if (targetStart >= target.length || sourceStart >= sourceEnd) {
+    return 0
+  }
+
+  return _copyActual(source, target, targetStart, sourceStart, sourceEnd)
+}
+
+function _copyActual (source, target, targetStart, sourceStart, sourceEnd) {
+  if (sourceEnd - sourceStart > target.length - targetStart) {
+    sourceEnd = sourceStart + target.length - targetStart;
+  }
+
+  let nb = sourceEnd - sourceStart;
+  const sourceLen = source.length - sourceStart;
+  if (nb > sourceLen) {
+    nb = sourceLen;
+  }
+
+  if (sourceStart !== 0 || sourceEnd < source.length) {
+    source = new Uint8Array(source.buffer, source.byteOffset + sourceStart, nb);
+  }
+
+  target.set(source, targetStart);
+
+  return nb
+}
+
+const QUERY_FLAG = 0;
+const RESPONSE_FLAG = 1 << 15;
+const FLUSH_MASK = 1 << 15;
+const NOT_FLUSH_MASK = ~FLUSH_MASK;
+const QU_MASK = 1 << 15;
+const NOT_QU_MASK = ~QU_MASK;
+
+function codec ({ bytes = 0, encode, decode, encodingLength }) {
+  encode.bytes = bytes;
+  decode.bytes = bytes;
+  return {
+    encode,
+    decode,
+    encodingLength: encodingLength || (() => bytes)
+  }
+}
+
+const name = codec({
+  encode (str, buf, offset) {
+    if (!buf) buf = new Uint8Array(name.encodingLength(str));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    // strip leading and trailing .
+    const n = str.replace(/^\.|\.$/gm, '');
+    if (n.length) {
+      const list = n.split('.');
+
+      for (let i = 0; i < list.length; i++) {
+        const len = write(buf, list[i], offset + 1);
+        buf[offset] = len;
+        offset += len + 1;
+      }
+    }
+
+    buf[offset++] = 0;
+
+    name.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const list = [];
+    let oldOffset = offset;
+    let totalLength = 0;
+    let consumedBytes = 0;
+    let jumped = false;
+
+    while (true) {
+      if (offset >= buf.length) {
+        throw new Error('Cannot decode name (buffer overflow)')
+      }
+      const len = buf[offset++];
+      consumedBytes += jumped ? 0 : 1;
+
+      if (len === 0) {
+        break
+      } else if ((len & 0xc0) === 0) {
+        if (offset + len > buf.length) {
+          throw new Error('Cannot decode name (buffer overflow)')
+        }
+        totalLength += len + 1;
+        if (totalLength > 254) {
+          throw new Error('Cannot decode name (name too long)')
+        }
+        list.push(decode$1(buf, offset, offset + len));
+        offset += len;
+        consumedBytes += jumped ? 0 : len;
+      } else if ((len & 0xc0) === 0xc0) {
+        if (offset + 1 > buf.length) {
+          throw new Error('Cannot decode name (buffer overflow)')
+        }
+        const jumpOffset = readUInt16BE(buf, offset - 1) - 0xc000;
+        if (jumpOffset >= oldOffset) {
+          // Allow only pointers to prior data. RFC 1035, section 4.1.4 states:
+          // "[...] an entire domain name or a list of labels at the end of a domain name
+          // is replaced with a pointer to a prior occurance (sic) of the same name."
+          throw new Error('Cannot decode name (bad pointer)')
+        }
+        offset = jumpOffset;
+        oldOffset = jumpOffset;
+        consumedBytes += jumped ? 0 : 1;
+        jumped = true;
+      } else {
+        throw new Error('Cannot decode name (bad label)')
+      }
+    }
+
+    name.decode.bytes = consumedBytes;
+    return list.length === 0 ? '.' : list.join('.')
+  },
+  encodingLength (n) {
+    if (n === '.' || n === '..') return 1
+    return bytelength(n.replace(/^\.|\.$/gm, '')) + 2
+  }
+});
+
+const string = codec({
+  encode (s, buf, offset) {
+    if (!buf) buf = new Uint8Array(string.encodingLength(s));
+    if (!offset) offset = 0;
+
+    const len = write(buf, s, offset + 1);
+    buf[offset] = len;
+    string.encode.bytes = len + 1;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const len = buf[offset];
+    const s = decode$1(buf, offset + 1, offset + 1 + len);
+    string.decode.bytes = len + 1;
+    return s
+  },
+  encodingLength (s) {
+    return bytelength(s) + 1
+  }
+});
+
+const header = codec({
+  bytes: 12,
+  encode (h, buf, offset) {
+    if (!buf) buf = new Uint8Array(header.encodingLength(h));
+    if (!offset) offset = 0;
+
+    const flags = (h.flags || 0) & 32767;
+    const type = h.type === 'response' ? RESPONSE_FLAG : QUERY_FLAG;
+
+    writeUInt16BE(buf, h.id || 0, offset);
+    writeUInt16BE(buf, flags | type, offset + 2);
+    writeUInt16BE(buf, h.questions.length, offset + 4);
+    writeUInt16BE(buf, h.answers.length, offset + 6);
+    writeUInt16BE(buf, h.authorities.length, offset + 8);
+    writeUInt16BE(buf, h.additionals.length, offset + 10);
+
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    if (buf.length < 12) throw new Error('Header must be 12 bytes')
+    const flags = readUInt16BE(buf, offset + 2);
+
+    return {
+      id: readUInt16BE(buf, offset),
+      type: flags & RESPONSE_FLAG ? 'response' : 'query',
+      flags: flags & 32767,
+      flag_qr: ((flags >> 15) & 0x1) === 1,
+      opcode: toString$2((flags >> 11) & 0xf),
+      flag_aa: ((flags >> 10) & 0x1) === 1,
+      flag_tc: ((flags >> 9) & 0x1) === 1,
+      flag_rd: ((flags >> 8) & 0x1) === 1,
+      flag_ra: ((flags >> 7) & 0x1) === 1,
+      flag_z: ((flags >> 6) & 0x1) === 1,
+      flag_ad: ((flags >> 5) & 0x1) === 1,
+      flag_cd: ((flags >> 4) & 0x1) === 1,
+      rcode: toString$3(flags & 0xf),
+      questions: new Array(readUInt16BE(buf, offset + 4)),
+      answers: new Array(readUInt16BE(buf, offset + 6)),
+      authorities: new Array(readUInt16BE(buf, offset + 8)),
+      additionals: new Array(readUInt16BE(buf, offset + 10))
+    }
+  },
+  encodingLength () {
+    return 12
+  }
+});
+
+const runknown = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(runknown.encodingLength(data));
+    if (!offset) offset = 0;
+
+    const dLen = data.length;
+    writeUInt16BE(buf, dLen, offset);
+    copy(data, buf, offset + 2, 0, dLen);
+
+    runknown.encode.bytes = dLen + 2;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const len = readUInt16BE(buf, offset);
+    const data = buf.slice(offset + 2, offset + 2 + len);
+    runknown.decode.bytes = len + 2;
+    return data
+  },
+  encodingLength (data) {
+    return data.length + 2
+  }
+});
+
+const rns = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(rns.encodingLength(data));
+    if (!offset) offset = 0;
+
+    name.encode(data, buf, offset + 2);
+    writeUInt16BE(buf, name.encode.bytes, offset);
+    rns.encode.bytes = name.encode.bytes + 2;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const len = readUInt16BE(buf, offset);
+    const dd = name.decode(buf, offset + 2);
+
+    rns.decode.bytes = len + 2;
+    return dd
+  },
+  encodingLength (data) {
+    return name.encodingLength(data) + 2
+  }
+});
+
+const rsoa = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(rsoa.encodingLength(data));
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+    offset += 2;
+    name.encode(data.mname, buf, offset);
+    offset += name.encode.bytes;
+    name.encode(data.rname, buf, offset);
+    offset += name.encode.bytes;
+    writeUInt32BE(buf, data.serial || 0, offset);
+    offset += 4;
+    writeUInt32BE(buf, data.refresh || 0, offset);
+    offset += 4;
+    writeUInt32BE(buf, data.retry || 0, offset);
+    offset += 4;
+    writeUInt32BE(buf, data.expire || 0, offset);
+    offset += 4;
+    writeUInt32BE(buf, data.minimum || 0, offset);
+    offset += 4;
+
+    writeUInt16BE(buf, offset - oldOffset - 2, oldOffset);
+    rsoa.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+
+    const data = {};
+    offset += 2;
+    data.mname = name.decode(buf, offset);
+    offset += name.decode.bytes;
+    data.rname = name.decode(buf, offset);
+    offset += name.decode.bytes;
+    data.serial = readUInt32BE(buf, offset);
+    offset += 4;
+    data.refresh = readUInt32BE(buf, offset);
+    offset += 4;
+    data.retry = readUInt32BE(buf, offset);
+    offset += 4;
+    data.expire = readUInt32BE(buf, offset);
+    offset += 4;
+    data.minimum = readUInt32BE(buf, offset);
+    offset += 4;
+
+    rsoa.decode.bytes = offset - oldOffset;
+    return data
+  },
+  encodingLength (data) {
+    return 22 + name.encodingLength(data.mname) + name.encodingLength(data.rname)
+  }
+});
+
+const rtxt = codec({
+  encode (data, buf, offset) {
+    if (!Array.isArray(data)) data = [data];
+    for (let i = 0; i < data.length; i++) {
+      if (typeof data[i] === 'string') {
+        data[i] = from(data[i]);
+      }
+      if (!isU8Arr(data[i])) {
+        throw new Error('Must be a Buffer')
+      }
+    }
+
+    if (!buf) buf = new Uint8Array(rtxt.encodingLength(data));
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+    offset += 2;
+
+    data.forEach(function (d) {
+      buf[offset++] = d.length;
+      copy(d, buf, offset, 0, d.length);
+      offset += d.length;
+    });
+
+    writeUInt16BE(buf, offset - oldOffset - 2, oldOffset);
+    rtxt.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+    let remaining = readUInt16BE(buf, offset);
+    offset += 2;
+
+    const data = [];
+    while (remaining > 0) {
+      const len = buf[offset++];
+      --remaining;
+      if (remaining < len) {
+        throw new Error('Buffer overflow')
+      }
+      data.push(buf.slice(offset, offset + len));
+      offset += len;
+      remaining -= len;
+    }
+
+    rtxt.decode.bytes = offset - oldOffset;
+    return data
+  },
+  encodingLength (data) {
+    if (!Array.isArray(data)) data = [data];
+    let length = 2;
+    data.forEach(function (buf) {
+      if (typeof buf === 'string') {
+        length += bytelength(buf) + 1;
+      } else {
+        length += buf.length + 1;
+      }
+    });
+    return length
+  }
+});
+
+const rnull = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(rnull.encodingLength(data));
+    if (!offset) offset = 0;
+
+    if (typeof data === 'string') data = from(data);
+    if (!data) data = new Uint8Array(0);
+
+    const oldOffset = offset;
+    offset += 2;
+
+    const len = data.length;
+    copy(data, buf, offset, 0, len);
+    offset += len;
+
+    writeUInt16BE(buf, offset - oldOffset - 2, oldOffset);
+    rnull.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+    const len = readUInt16BE(buf, offset);
+
+    offset += 2;
+
+    const data = buf.slice(offset, offset + len);
+    offset += len;
+
+    rnull.decode.bytes = offset - oldOffset;
+    return data
+  },
+  encodingLength (data) {
+    if (!data) return 2
+    return (isU8Arr(data) ? data.length : bytelength(data)) + 2
+  }
+});
+
+const rhinfo = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(rhinfo.encodingLength(data));
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+    offset += 2;
+    string.encode(data.cpu, buf, offset);
+    offset += string.encode.bytes;
+    string.encode(data.os, buf, offset);
+    offset += string.encode.bytes;
+    writeUInt16BE(buf, offset - oldOffset - 2, oldOffset);
+    rhinfo.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+
+    const data = {};
+    offset += 2;
+    data.cpu = string.decode(buf, offset);
+    offset += string.decode.bytes;
+    data.os = string.decode(buf, offset);
+    offset += string.decode.bytes;
+    rhinfo.decode.bytes = offset - oldOffset;
+    return data
+  },
+  encodingLength (data) {
+    return string.encodingLength(data.cpu) + string.encodingLength(data.os) + 2
+  }
+});
+
+const rptr = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(rptr.encodingLength(data));
+    if (!offset) offset = 0;
+
+    name.encode(data, buf, offset + 2);
+    writeUInt16BE(buf, name.encode.bytes, offset);
+    rptr.encode.bytes = name.encode.bytes + 2;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const data = name.decode(buf, offset + 2);
+    rptr.decode.bytes = name.decode.bytes + 2;
+    return data
+  },
+  encodingLength (data) {
+    return name.encodingLength(data) + 2
+  }
+});
+
+const rsrv = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(rsrv.encodingLength(data));
+    if (!offset) offset = 0;
+
+    writeUInt16BE(buf, data.priority || 0, offset + 2);
+    writeUInt16BE(buf, data.weight || 0, offset + 4);
+    writeUInt16BE(buf, data.port || 0, offset + 6);
+    name.encode(data.target, buf, offset + 8);
+
+    const len = name.encode.bytes + 6;
+    writeUInt16BE(buf, len, offset);
+
+    rsrv.encode.bytes = len + 2;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const len = readUInt16BE(buf, offset);
+
+    const data = {};
+    data.priority = readUInt16BE(buf, offset + 2);
+    data.weight = readUInt16BE(buf, offset + 4);
+    data.port = readUInt16BE(buf, offset + 6);
+    data.target = name.decode(buf, offset + 8);
+
+    rsrv.decode.bytes = len + 2;
+    return data
+  },
+  encodingLength (data) {
+    return 8 + name.encodingLength(data.target)
+  }
+});
+
+const rcaa = codec({
+  encode (data, buf, offset) {
+    const len = rcaa.encodingLength(data);
+
+    if (!buf) buf = new Uint8Array(rcaa.encodingLength(data));
+    if (!offset) offset = 0;
+
+    if (data.issuerCritical) {
+      data.flags = rcaa.ISSUER_CRITICAL;
+    }
+
+    writeUInt16BE(buf, len - 2, offset);
+    offset += 2;
+    buf[offset] = data.flags || 0;
+    offset += 1;
+    string.encode(data.tag, buf, offset);
+    offset += string.encode.bytes;
+    write(buf, data.value, offset);
+    offset += bytelength(data.value);
+
+    rcaa.encode.bytes = len;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const len = readUInt16BE(buf, offset);
+    offset += 2;
+
+    const oldOffset = offset;
+    const data = {};
+    data.flags = buf[offset];
+    offset += 1;
+    data.tag = string.decode(buf, offset);
+    offset += string.decode.bytes;
+    data.value = decode$1(buf, offset, oldOffset + len);
+
+    data.issuerCritical = !!(data.flags & rcaa.ISSUER_CRITICAL);
+
+    rcaa.decode.bytes = len + 2;
+
+    return data
+  },
+  encodingLength (data) {
+    return string.encodingLength(data.tag) + string.encodingLength(data.value) + 2
+  }
+});
+
+rcaa.ISSUER_CRITICAL = 1 << 7;
+
+const rmx = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(rmx.encodingLength(data));
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+    offset += 2;
+    writeUInt16BE(buf, data.preference || 0, offset);
+    offset += 2;
+    name.encode(data.exchange, buf, offset);
+    offset += name.encode.bytes;
+
+    writeUInt16BE(buf, offset - oldOffset - 2, oldOffset);
+    rmx.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+
+    const data = {};
+    offset += 2;
+    data.preference = readUInt16BE(buf, offset);
+    offset += 2;
+    data.exchange = name.decode(buf, offset);
+    offset += name.decode.bytes;
+
+    rmx.decode.bytes = offset - oldOffset;
+    return data
+  },
+  encodingLength (data) {
+    return 4 + name.encodingLength(data.exchange)
+  }
+});
+
+const ra = codec({
+  encode (host, buf, offset) {
+    if (!buf) buf = new Uint8Array(ra.encodingLength(host));
+    if (!offset) offset = 0;
+
+    writeUInt16BE(buf, 4, offset);
+    offset += 2;
+    v4.encode(host, buf, offset);
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    offset += 2;
+    const host = v4.decode(buf, offset);
+    return host
+  },
+  bytes: 6
+});
+
+const raaaa = codec({
+  encode (host, buf, offset) {
+    if (!buf) buf = new Uint8Array(raaaa.encodingLength(host));
+    if (!offset) offset = 0;
+
+    writeUInt16BE(buf, 16, offset);
+    offset += 2;
+    v6.encode(host, buf, offset);
+    raaaa.encode.bytes = 18;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    offset += 2;
+    const host = v6.decode(buf, offset);
+    raaaa.decode.bytes = 18;
+    return host
+  },
+  bytes: 18
+});
+
+const alloc = size => new Uint8Array(size);
+
+const roption = codec({
+  encode (option, buf, offset) {
+    if (!buf) buf = new Uint8Array(roption.encodingLength(option));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const code = toCode(option.code);
+    writeUInt16BE(buf, code, offset);
+    offset += 2;
+    if (option.data) {
+      writeUInt16BE(buf, option.data.length, offset);
+      offset += 2;
+      copy(option.data, buf, offset);
+      offset += option.data.length;
+    } else {
+      switch (code) {
+        // case 3: NSID.  No encode makes sense.
+        // case 5,6,7: Not implementable
+        case 8: // ECS
+          {
+            // note: do IP math before calling
+            const spl = option.sourcePrefixLength || 0;
+            const fam = option.family || familyOf(option.ip);
+            const ipBuf = encode$2(option.ip, alloc);
+            const ipLen = Math.ceil(spl / 8);
+            writeUInt16BE(buf, ipLen + 4, offset);
+            offset += 2;
+            writeUInt16BE(buf, fam, offset);
+            offset += 2;
+            buf[offset++] = spl;
+            buf[offset++] = option.scopePrefixLength || 0;
+
+            copy(ipBuf, buf, offset, 0, ipLen);
+            offset += ipLen;
+          }
+          break
+        // case 9: EXPIRE (experimental)
+        // case 10: COOKIE.  No encode makes sense.
+        case 11: // KEEP-ALIVE
+          if (option.timeout) {
+            writeUInt16BE(buf, 2, offset);
+            offset += 2;
+            writeUInt16BE(buf, option.timeout, offset);
+            offset += 2;
+          } else {
+            writeUInt16BE(buf, 0, offset);
+            offset += 2;
+          }
+          break
+        case 12: // PADDING
+          {
+            const len = option.length || 0;
+            writeUInt16BE(buf, len, offset);
+            offset += 2;
+            buf.fill(0, offset, offset + len);
+            offset += len;
+          }
+          break
+        // case 13:  CHAIN.  Experimental.
+        case 14: // KEY-TAG
+          {
+            const tagsLen = option.tags.length * 2;
+            writeUInt16BE(buf, tagsLen, offset);
+            offset += 2;
+            for (const tag of option.tags) {
+              writeUInt16BE(buf, tag, offset);
+              offset += 2;
+            }
+          }
+          break
+        default:
+          throw new Error(`Unknown roption code: ${option.code}`)
+      }
+    }
+
+    roption.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const option = {};
+    option.code = readUInt16BE(buf, offset);
+    option.type = toString(option.code);
+    offset += 2;
+    const len = readUInt16BE(buf, offset);
+    offset += 2;
+    option.data = buf.slice(offset, offset + len);
+    switch (option.code) {
+      // case 3: NSID.  No decode makes sense.
+      case 8: // ECS
+        option.family = readUInt16BE(buf, offset);
+        offset += 2;
+        option.sourcePrefixLength = buf[offset++];
+        option.scopePrefixLength = buf[offset++];
+        {
+          const padded = new Uint8Array((option.family === 1) ? 4 : 16);
+          copy(buf, padded, 0, offset, offset + len - 4);
+          option.ip = decode$2(padded);
+        }
+        break
+      // case 12: Padding.  No decode makes sense.
+      case 11: // KEEP-ALIVE
+        if (len > 0) {
+          option.timeout = readUInt16BE(buf, offset);
+          offset += 2;
+        }
+        break
+      case 14:
+        option.tags = [];
+        for (let i = 0; i < len; i += 2) {
+          option.tags.push(readUInt16BE(buf, offset));
+          offset += 2;
+        }
+      // don't worry about default.  caller will use data if desired
+    }
+
+    roption.decode.bytes = len + 4;
+    return option
+  },
+  encodingLength (option) {
+    if (option.data) {
+      return option.data.length + 4
+    }
+    const code = toCode(option.code);
+    switch (code) {
+      case 8: // ECS
+      {
+        const spl = option.sourcePrefixLength || 0;
+        return Math.ceil(spl / 8) + 8
+      }
+      case 11: // KEEP-ALIVE
+        return (typeof option.timeout === 'number') ? 6 : 4
+      case 12: // PADDING
+        return option.length + 4
+      case 14: // KEY-TAG
+        return 4 + (option.tags.length * 2)
+    }
+    throw new Error(`Unknown roption code: ${option.code}`)
+  }
+});
+
+const ropt = codec({
+  encode (options, buf, offset) {
+    if (!buf) buf = new Uint8Array(ropt.encodingLength(options));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const rdlen = encodingLengthList(options, roption);
+    writeUInt16BE(buf, rdlen, offset);
+    offset = encodeList(options, roption, buf, offset + 2);
+
+    ropt.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const options = [];
+    let rdlen = readUInt16BE(buf, offset);
+    offset += 2;
+    let o = 0;
+    while (rdlen > 0) {
+      options[o++] = roption.decode(buf, offset);
+      offset += roption.decode.bytes;
+      rdlen -= roption.decode.bytes;
+    }
+    ropt.decode.bytes = offset - oldOffset;
+    return options
+  },
+  encodingLength (options) {
+    return 2 + encodingLengthList(options || [], roption)
+  }
+});
+
+const rdnskey = codec({
+  encode (key, buf, offset) {
+    if (!buf) buf = new Uint8Array(rdnskey.encodingLength(key));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const keydata = key.key;
+    if (!isU8Arr(keydata)) {
+      throw new Error('Key must be a Buffer')
+    }
+
+    offset += 2; // Leave space for length
+    writeUInt16BE(buf, key.flags, offset);
+    offset += 2;
+    buf[offset] = rdnskey.PROTOCOL_DNSSEC;
+    offset += 1;
+    buf[offset] = key.algorithm;
+    offset += 1;
+    copy(keydata, buf, offset, 0, keydata.length);
+    offset += keydata.length;
+
+    rdnskey.encode.bytes = offset - oldOffset;
+    writeUInt16BE(buf, rdnskey.encode.bytes - 2, oldOffset);
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const key = {};
+    const length = readUInt16BE(buf, offset);
+    offset += 2;
+    key.flags = readUInt16BE(buf, offset);
+    offset += 2;
+    if (buf[offset] !== rdnskey.PROTOCOL_DNSSEC) {
+      throw new Error('Protocol must be 3')
+    }
+    offset += 1;
+    key.algorithm = buf[offset];
+    offset += 1;
+    key.key = buf.slice(offset, oldOffset + length + 2);
+    offset += key.key.length;
+    rdnskey.decode.bytes = offset - oldOffset;
+    return key
+  },
+  encodingLength (key) {
+    return 6 + bytelength(key.key)
+  }
+});
+
+rdnskey.PROTOCOL_DNSSEC = 3;
+rdnskey.ZONE_KEY = 0x80;
+rdnskey.SECURE_ENTRYPOINT = 0x8000;
+
+const rrrsig = codec({
+  encode (sig, buf, offset) {
+    if (!buf) buf = new Uint8Array(rrrsig.encodingLength(sig));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const signature = sig.signature;
+    if (!isU8Arr(signature)) {
+      throw new Error('Signature must be a Buffer')
+    }
+
+    offset += 2; // Leave space for length
+    writeUInt16BE(buf, toType(sig.typeCovered), offset);
+    offset += 2;
+    buf[offset] = sig.algorithm;
+    offset += 1;
+    buf[offset] = sig.labels;
+    offset += 1;
+    writeUInt32BE(buf, sig.originalTTL, offset);
+    offset += 4;
+    writeUInt32BE(buf, sig.expiration, offset);
+    offset += 4;
+    writeUInt32BE(buf, sig.inception, offset);
+    offset += 4;
+    writeUInt16BE(buf, sig.keyTag, offset);
+    offset += 2;
+    name.encode(sig.signersName, buf, offset);
+    offset += name.encode.bytes;
+    copy(signature, buf, offset, 0, signature.length);
+    offset += signature.length;
+
+    rrrsig.encode.bytes = offset - oldOffset;
+    writeUInt16BE(buf, rrrsig.encode.bytes - 2, oldOffset);
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const sig = {};
+    const length = readUInt16BE(buf, offset);
+    offset += 2;
+    sig.typeCovered = toString$4(readUInt16BE(buf, offset));
+    offset += 2;
+    sig.algorithm = buf[offset];
+    offset += 1;
+    sig.labels = buf[offset];
+    offset += 1;
+    sig.originalTTL = readUInt32BE(buf, offset);
+    offset += 4;
+    sig.expiration = readUInt32BE(buf, offset);
+    offset += 4;
+    sig.inception = readUInt32BE(buf, offset);
+    offset += 4;
+    sig.keyTag = readUInt16BE(buf, offset);
+    offset += 2;
+    sig.signersName = name.decode(buf, offset);
+    offset += name.decode.bytes;
+    sig.signature = buf.slice(offset, oldOffset + length + 2);
+    offset += sig.signature.length;
+    rrrsig.decode.bytes = offset - oldOffset;
+    return sig
+  },
+  encodingLength (sig) {
+    return 20 +
+      name.encodingLength(sig.signersName) +
+      bytelength(sig.signature)
+  }
+});
+const rrp = codec({
+  encode (data, buf, offset) {
+    if (!buf) buf = new Uint8Array(rrp.encodingLength(data));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    offset += 2; // Leave space for length
+    name.encode(data.mbox || '.', buf, offset);
+    offset += name.encode.bytes;
+    name.encode(data.txt || '.', buf, offset);
+    offset += name.encode.bytes;
+    rrp.encode.bytes = offset - oldOffset;
+    writeUInt16BE(buf, rrp.encode.bytes - 2, oldOffset);
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const data = {};
+    offset += 2;
+    data.mbox = name.decode(buf, offset) || '.';
+    offset += name.decode.bytes;
+    data.txt = name.decode(buf, offset) || '.';
+    offset += name.decode.bytes;
+    rrp.decode.bytes = offset - oldOffset;
+    return data
+  },
+  encodingLength (data) {
+    return 2 + name.encodingLength(data.mbox || '.') + name.encodingLength(data.txt || '.')
+  }
+});
+
+const typebitmap = codec({
+  encode (typelist, buf, offset) {
+    if (!buf) buf = new Uint8Array(typebitmap.encodingLength(typelist));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const typesByWindow = [];
+    for (let i = 0; i < typelist.length; i++) {
+      const typeid = toType(typelist[i]);
+      if (typesByWindow[typeid >> 8] === undefined) {
+        typesByWindow[typeid >> 8] = [];
+      }
+      typesByWindow[typeid >> 8][(typeid >> 3) & 0x1F] |= 1 << (7 - (typeid & 0x7));
+    }
+
+    for (let i = 0; i < typesByWindow.length; i++) {
+      if (typesByWindow[i] !== undefined) {
+        const windowBuf = from(typesByWindow[i]);
+        buf[offset] = i;
+        offset += 1;
+        buf[offset] = windowBuf.length;
+        offset += 1;
+        copy(windowBuf, buf, offset, 0, windowBuf.length);
+        offset += windowBuf.length;
+      }
+    }
+
+    typebitmap.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset, length) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const typelist = [];
+    while (offset - oldOffset < length) {
+      const window = buf[offset];
+      offset += 1;
+      const windowLength = buf[offset];
+      offset += 1;
+      for (let i = 0; i < windowLength; i++) {
+        const b = buf[offset + i];
+        for (let j = 0; j < 8; j++) {
+          if (b & (1 << (7 - j))) {
+            const typeid = toString$4((window << 8) | (i << 3) | j);
+            typelist.push(typeid);
+          }
+        }
+      }
+      offset += windowLength;
+    }
+
+    typebitmap.decode.bytes = offset - oldOffset;
+    return typelist
+  },
+  encodingLength (typelist) {
+    const extents = [];
+    for (let i = 0; i < typelist.length; i++) {
+      const typeid = toType(typelist[i]);
+      extents[typeid >> 8] = Math.max(extents[typeid >> 8] || 0, typeid & 0xFF);
+    }
+
+    let len = 0;
+    for (let i = 0; i < extents.length; i++) {
+      if (extents[i] !== undefined) {
+        len += 2 + Math.ceil((extents[i] + 1) / 8);
+      }
+    }
+
+    return len
+  }
+});
+
+const rnsec = codec({
+  encode (record, buf, offset) {
+    if (!buf) buf = new Uint8Array(rnsec.encodingLength(record));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    offset += 2; // Leave space for length
+    name.encode(record.nextDomain, buf, offset);
+    offset += name.encode.bytes;
+    typebitmap.encode(record.rrtypes, buf, offset);
+    offset += typebitmap.encode.bytes;
+
+    rnsec.encode.bytes = offset - oldOffset;
+    writeUInt16BE(buf, rnsec.encode.bytes - 2, oldOffset);
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const record = {};
+    const length = readUInt16BE(buf, offset);
+    offset += 2;
+    record.nextDomain = name.decode(buf, offset);
+    offset += name.decode.bytes;
+    record.rrtypes = typebitmap.decode(buf, offset, length - (offset - oldOffset));
+    offset += typebitmap.decode.bytes;
+
+    rnsec.decode.bytes = offset - oldOffset;
+    return record
+  },
+  encodingLength (record) {
+    return 2 +
+      name.encodingLength(record.nextDomain) +
+      typebitmap.encodingLength(record.rrtypes)
+  }
+});
+
+const rnsec3 = codec({
+  encode (record, buf, offset) {
+    if (!buf) buf = new Uint8Array(rnsec3.encodingLength(record));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const salt = record.salt;
+    if (!isU8Arr(salt)) {
+      throw new Error('salt must be a Buffer')
+    }
+
+    const nextDomain = record.nextDomain;
+    if (!isU8Arr(nextDomain)) {
+      throw new Error('nextDomain must be a Buffer')
+    }
+
+    offset += 2; // Leave space for length
+    buf[offset] = record.algorithm;
+    offset += 1;
+    buf[offset] = record.flags;
+    offset += 1;
+    writeUInt16BE(buf, record.iterations, offset);
+    offset += 2;
+    buf[offset] = salt.length;
+    offset += 1;
+    copy(salt, buf, offset, 0, salt.length);
+    offset += salt.length;
+    buf[offset] = nextDomain.length;
+    offset += 1;
+    copy(nextDomain, buf, offset, 0, nextDomain.length);
+    offset += nextDomain.length;
+    typebitmap.encode(record.rrtypes, buf, offset);
+    offset += typebitmap.encode.bytes;
+
+    rnsec3.encode.bytes = offset - oldOffset;
+    writeUInt16BE(buf, rnsec3.encode.bytes - 2, oldOffset);
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const record = {};
+    const length = readUInt16BE(buf, offset);
+    offset += 2;
+    record.algorithm = buf[offset];
+    offset += 1;
+    record.flags = buf[offset];
+    offset += 1;
+    record.iterations = readUInt16BE(buf, offset);
+    offset += 2;
+    const saltLength = buf[offset];
+    offset += 1;
+    record.salt = buf.slice(offset, offset + saltLength);
+    offset += saltLength;
+    const hashLength = buf[offset];
+    offset += 1;
+    record.nextDomain = buf.slice(offset, offset + hashLength);
+    offset += hashLength;
+    record.rrtypes = typebitmap.decode(buf, offset, length - (offset - oldOffset));
+    offset += typebitmap.decode.bytes;
+
+    rnsec3.decode.bytes = offset - oldOffset;
+    return record
+  },
+  encodingLength (record) {
+    return 8 +
+      record.salt.length +
+      record.nextDomain.length +
+      typebitmap.encodingLength(record.rrtypes)
+  }
+});
+
+const rds = codec({
+  encode (digest, buf, offset) {
+    if (!buf) buf = new Uint8Array(rds.encodingLength(digest));
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const digestdata = digest.digest;
+    if (!isU8Arr(digestdata)) {
+      throw new Error('Digest must be a Buffer')
+    }
+
+    offset += 2; // Leave space for length
+    writeUInt16BE(buf, digest.keyTag, offset);
+    offset += 2;
+    buf[offset] = digest.algorithm;
+    offset += 1;
+    buf[offset] = digest.digestType;
+    offset += 1;
+    copy(digestdata, buf, offset, 0, digestdata.length);
+    offset += digestdata.length;
+
+    rds.encode.bytes = offset - oldOffset;
+    writeUInt16BE(buf, rds.encode.bytes - 2, oldOffset);
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+    const oldOffset = offset;
+
+    const digest = {};
+    const length = readUInt16BE(buf, offset);
+    offset += 2;
+    digest.keyTag = readUInt16BE(buf, offset);
+    offset += 2;
+    digest.algorithm = buf[offset];
+    offset += 1;
+    digest.digestType = buf[offset];
+    offset += 1;
+    digest.digest = buf.slice(offset, oldOffset + length + 2);
+    offset += digest.digest.length;
+    rds.decode.bytes = offset - oldOffset;
+    return digest
+  },
+  encodingLength (digest) {
+    return 6 + bytelength(digest.digest)
+  }
+});
+
+function renc (type) {
+  switch (type.toUpperCase()) {
+    case 'A': return ra
+    case 'PTR': return rptr
+    case 'CNAME': return rptr
+    case 'DNAME': return rptr
+    case 'TXT': return rtxt
+    case 'NULL': return rnull
+    case 'AAAA': return raaaa
+    case 'SRV': return rsrv
+    case 'HINFO': return rhinfo
+    case 'CAA': return rcaa
+    case 'NS': return rns
+    case 'SOA': return rsoa
+    case 'MX': return rmx
+    case 'OPT': return ropt
+    case 'DNSKEY': return rdnskey
+    case 'RRSIG': return rrrsig
+    case 'RP': return rrp
+    case 'NSEC': return rnsec
+    case 'NSEC3': return rnsec3
+    case 'DS': return rds
+  }
+  return runknown
+}
+
+const answer = codec({
+  encode (a, buf, offset) {
+    if (!buf) buf = new Uint8Array(answer.encodingLength(a));
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+
+    name.encode(a.name, buf, offset);
+    offset += name.encode.bytes;
+
+    writeUInt16BE(buf, toType(a.type), offset);
+
+    if (a.type.toUpperCase() === 'OPT') {
+      if (a.name !== '.') {
+        throw new Error('OPT name must be root.')
+      }
+      writeUInt16BE(buf, a.udpPayloadSize || 4096, offset + 2);
+      buf[offset + 4] = a.extendedRcode || 0;
+      buf[offset + 5] = a.ednsVersion || 0;
+      writeUInt16BE(buf, a.flags || 0, offset + 6);
+
+      offset += 8;
+      ropt.encode(a.options || [], buf, offset);
+      offset += ropt.encode.bytes;
+    } else {
+      let klass = toClass(a.class === undefined ? 'IN' : a.class);
+      if (a.flush) klass |= FLUSH_MASK; // the 1st bit of the class is the flush bit
+      writeUInt16BE(buf, klass, offset + 2);
+      writeUInt32BE(buf, a.ttl || 0, offset + 4);
+
+      offset += 8;
+      const enc = renc(a.type);
+      enc.encode(a.data, buf, offset);
+      offset += enc.encode.bytes;
+    }
+
+    answer.encode.bytes = offset - oldOffset;
+    return buf
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const a = {};
+    const oldOffset = offset;
+
+    a.name = name.decode(buf, offset);
+    offset += name.decode.bytes;
+    a.type = toString$4(readUInt16BE(buf, offset));
+    if (a.type === 'OPT') {
+      a.udpPayloadSize = readUInt16BE(buf, offset + 2);
+      a.extendedRcode = buf[offset + 4];
+      a.ednsVersion = buf[offset + 5];
+      a.flags = readUInt16BE(buf, offset + 6);
+      a.flag_do = ((a.flags >> 15) & 0x1) === 1;
+      a.options = ropt.decode(buf, offset + 8);
+      offset += 8 + ropt.decode.bytes;
+    } else {
+      const klass = readUInt16BE(buf, offset + 2);
+      a.ttl = readUInt32BE(buf, offset + 4);
+
+      a.class = toString$1(klass & NOT_FLUSH_MASK);
+      a.flush = !!(klass & FLUSH_MASK);
+
+      const enc = renc(a.type);
+      a.data = enc.decode(buf, offset + 8);
+      offset += 8 + enc.decode.bytes;
+    }
+
+    answer.decode.bytes = offset - oldOffset;
+    return a
+  },
+  encodingLength (a) {
+    const data = (a.data !== null && a.data !== undefined) ? a.data : a.options;
+    return name.encodingLength(a.name) + 8 + renc(a.type).encodingLength(data)
+  }
+});
+
+const question = codec({
+  encode (q, buf, offset) {
+    if (!buf) buf = new Uint8Array(question.encodingLength(q));
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+
+    name.encode(q.name, buf, offset);
+    offset += name.encode.bytes;
+
+    writeUInt16BE(buf, toType(q.type), offset);
+    offset += 2;
+
+    writeUInt16BE(buf, toClass(q.class === undefined ? 'IN' : q.class), offset);
+    offset += 2;
+
+    question.encode.bytes = offset - oldOffset;
+    return q
+  },
+  decode (buf, offset) {
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+    const q = {};
+
+    q.name = name.decode(buf, offset);
+    offset += name.decode.bytes;
+
+    q.type = toString$4(readUInt16BE(buf, offset));
+    offset += 2;
+
+    q.class = toString$1(readUInt16BE(buf, offset));
+    offset += 2;
+
+    const qu = !!(q.class & QU_MASK);
+    if (qu) q.class &= NOT_QU_MASK;
+
+    question.decode.bytes = offset - oldOffset;
+    return q
+  },
+  encodingLength (q) {
+    return name.encodingLength(q.name) + 4
+  }
+});
+const RECURSION_DESIRED = 1 << 8;
+
+const packet = {
+  encode: function (result, buf, offset) {
+    const allocing = !buf;
+
+    if (allocing) buf = new Uint8Array(encodingLength(result));
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+
+    if (!result.questions) result.questions = [];
+    if (!result.answers) result.answers = [];
+    if (!result.authorities) result.authorities = [];
+    if (!result.additionals) result.additionals = [];
+
+    header.encode(result, buf, offset);
+    offset += header.encode.bytes;
+
+    offset = encodeList(result.questions, question, buf, offset);
+    offset = encodeList(result.answers, answer, buf, offset);
+    offset = encodeList(result.authorities, answer, buf, offset);
+    offset = encodeList(result.additionals, answer, buf, offset);
+
+    packet.encode.bytes = offset - oldOffset;
+
+    // just a quick sanity check
+    if (allocing && encode.bytes !== buf.length) {
+      return buf.slice(0, encode.bytes)
+    }
+
+    return buf
+  },
+  decode: function (buf, offset) {
+    if (!offset) offset = 0;
+
+    const oldOffset = offset;
+    const result = header.decode(buf, offset);
+    offset += header.decode.bytes;
+
+    offset = decodeList(result.questions, question, buf, offset);
+    offset = decodeList(result.answers, answer, buf, offset);
+    offset = decodeList(result.authorities, answer, buf, offset);
+    offset = decodeList(result.additionals, answer, buf, offset);
+
+    packet.decode.bytes = offset - oldOffset;
+
+    return result
+  },
+  encodingLength: function (result) {
+    return header.encodingLength(result) +
+      encodingLengthList(result.questions || [], question) +
+      encodingLengthList(result.answers || [], answer) +
+      encodingLengthList(result.authorities || [], answer) +
+      encodingLengthList(result.additionals || [], answer)
+  }
+};
+packet.encode.bytes = 0;
+packet.decode.bytes = 0;
+
+const encode = packet.encode;
+const decode = packet.decode;
+const encodingLength = packet.encodingLength;
+
+function encodingLengthList (list, enc) {
+  let len = 0;
+  for (let i = 0; i < list.length; i++) len += enc.encodingLength(list[i]);
+  return len
+}
+
+function encodeList (list, enc, buf, offset) {
+  for (let i = 0; i < list.length; i++) {
+    enc.encode(list[i], buf, offset);
+    offset += enc.encode.bytes;
+  }
+  return offset
+}
+
+function decodeList (list, enc, buf, offset) {
+  for (let i = 0; i < list.length; i++) {
+    list[i] = enc.decode(buf, offset);
+    offset += enc.decode.bytes;
+  }
+  return offset
+}
+
+const PREFERS_PADDING = 1;
+const PREFERS_NO_PADDING = 2;
+
+function make (name, charset, padding, paddingMode) {
+  if (charset.length !== 64) {
+    throw new Error(`Charset needs to be 64 characters long! (${charset.length})`)
+  }
+  const byCharCode = new Uint8Array(256);
+  const byNum = new Uint8Array(64);
+  for (let i = 0; i < 64; i += 1) {
+    const code = charset.charCodeAt(i);
+    if (code > 255) {
+      throw new Error(`Character #${i} in charset [code=${code}, char=${charset.charAt(i)}] is too high! (max=255)`)
+    }
+    if (byCharCode[code] !== 0) {
+      throw new Error(`Character [code=${code}, char=${charset.charAt(i)}] is more than once in the charset!`)
+    }
+    byCharCode[code] = i;
+    byNum[i] = code;
+  }
+  const padCode = padding.charCodeAt(0);
+  const codec = {
+    name,
+    encodingLength (str) {
+      const strLen = str.length;
+      const len = strLen * 0.75 | 0;
+      if (str.charCodeAt(strLen - 1) === padCode) {
+        if (str.charCodeAt(strLen - 2) === padCode) {
+          return len - 2
+        }
+        return len - 1
+      }
+      return len
+    },
+    encode (str, buffer, offset) {
+      if (buffer === null || buffer === undefined) {
+        buffer = new Uint8Array(codec.encodingLength(str));
+      }
+      if (offset === null || offset === undefined) {
+        offset = 0;
+      }
+
+      let strLen = str.length;
+      if (str.charCodeAt(strLen - 1) === padCode) {
+        if (str.charCodeAt(strLen - 2) === padCode) {
+          strLen -= 2;
+        } else {
+          strLen -= 1;
+        }
+      }
+
+      const padding = strLen % 4;
+      const safeLen = strLen - padding;
+
+      let off = offset;
+      let i = 0;
+      while (i < safeLen) {
+        const code =
+          (byCharCode[str.charCodeAt(i)] << 18) |
+          (byCharCode[str.charCodeAt(i + 1)] << 12) |
+          (byCharCode[str.charCodeAt(i + 2)] << 6) |
+          byCharCode[str.charCodeAt(i + 3)];
+        buffer[off++] = code >> 16;
+        buffer[off++] = code >> 8;
+        buffer[off++] = code;
+        i += 4;
+      }
+
+      if (padding === 3) {
+        const code =
+          (byCharCode[str.charCodeAt(i)] << 10) |
+          (byCharCode[str.charCodeAt(i + 1)] << 4) |
+          (byCharCode[str.charCodeAt(i + 2)] >> 2);
+        buffer[off++] = code >> 8;
+        buffer[off++] = code;
+      } else if (padding === 2) {
+        buffer[off++] = (byCharCode[str.charCodeAt(i)] << 2) |
+          (byCharCode[str.charCodeAt(i + 1)] >> 4);
+      }
+
+      codec.encode.bytes = off - offset;
+      return buffer
+    },
+    decode (buffer, start, end) {
+      if (start === null || start === undefined) {
+        start = 0;
+      }
+      if (end === null || end === undefined) {
+        end = buffer.length;
+      }
+
+      const length = end - start;
+      const pad = length % 3;
+      const safeEnd = start + length - pad;
+      const codes = [];
+      for (let off = start; off < safeEnd; off += 3) {
+        const num = (buffer[off] << 16) | ((buffer[off + 1] << 8)) | buffer[off + 2];
+        codes.push(
+          byNum[num >> 18 & 0x3F],
+          byNum[num >> 12 & 0x3F],
+          byNum[num >> 6 & 0x3F],
+          byNum[num & 0x3F]
+        );
+      }
+
+      if (pad === 2) {
+        const num = (buffer[end - 2] << 8) + buffer[end - 1];
+        codes.push(
+          byNum[num >> 10],
+          byNum[(num >> 4) & 0x3F],
+          byNum[(num << 2) & 0x3F]
+        );
+        if (paddingMode === PREFERS_PADDING) {
+          codes.push(padCode);
+        }
+      } else if (pad === 1) {
+        const num = buffer[end - 1];
+        codes.push(
+          byNum[num >> 2],
+          byNum[(num << 4) & 0x3F]
+        );
+        if (paddingMode === PREFERS_PADDING) {
+          codes.push(padCode, padCode);
+        }
+      }
+
+      codec.decode.bytes = length;
+      return String.fromCharCode.apply(String, codes)
+    }
+  };
+  return codec
+}
+
+make('base64', 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', '=', PREFERS_PADDING);
+// https://datatracker.ietf.org/doc/html/rfc4648#section-5
+const base64URL = make('base64-url', 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_', '=', PREFERS_NO_PADDING);
+
+let AbortError = typeof global !== 'undefined' ? global.AbortError : typeof window !== 'undefined' ? window.AbortError : null;
+if (!AbortError) {
+  AbortError = class AbortError extends Error {
+    constructor (message = 'Request aborted.') {
+      super(message);
+    }
+  };
+}
+AbortError.prototype.name = 'AbortError';
+AbortError.prototype.code = 'ABORT_ERR';
+
+const URL = (typeof globalThis !== 'undefined' && globalThis.URL) || require('url').URL;
+
+class HTTPStatusError extends Error {
+  constructor (uri, code, method) {
+    super('status=' + code + ' while requesting ' + uri + ' [' + method + ']');
+    this.uri = uri;
+    this.status = code;
+    this.method = method;
+  }
+
+  toJSON () {
+    return {
+      code: this.code,
+      uri: this.uri,
+      status: this.status,
+      method: this.method,
+      endpoint: this.endpoint
+    }
+  }
+}
+HTTPStatusError.prototype.name = 'HTTPStatusError';
+HTTPStatusError.prototype.code = 'HTTP_STATUS';
+
+class ResponseError extends Error {
+  constructor (message, cause) {
+    super(message);
+    this.cause = cause;
+  }
+
+  toJSON () {
+    return {
+      message: this.message,
+      endpoint: this.endpoint,
+      code: this.code,
+      cause: reduceError(this.cause)
+    }
+  }
+}
+ResponseError.prototype.name = 'ResponseError';
+ResponseError.prototype.code = 'RESPONSE_ERR';
+
+class TimeoutError extends Error {
+  constructor (timeout) {
+    super('Timeout (t=' + timeout + ').');
+    this.timeout = timeout;
+  }
+
+  toJSON () {
+    return {
+      code: this.code,
+      endpoint: this.endpoint,
+      timeout: this.timeout
+    }
+  }
+}
+TimeoutError.prototype.name = 'TimeoutError';
+TimeoutError.prototype.code = 'ETIMEOUT';
+
+const v4Regex = /^((\d{1,3}\.){3,3}\d{1,3})(:(\d{2,5}))?$/;
+const v6Regex = /^((::)?(((\d{1,3}\.){3}(\d{1,3}){1})?([0-9a-f]){0,4}:{0,2}){1,8}(::)?)(:(\d{2,5}))?$/i;
+
+function reduceError (err) {
+  if (typeof err === 'string') {
+    return {
+      message: err
+    }
+  }
+  try {
+    const json = JSON.stringify(err);
+    if (json !== '{}') {
+      return JSON.parse(json)
+    }
+  } catch (e) {}
+  const error = {
+    message: String(err.message || err)
+  };
+  if (err.code !== undefined) {
+    error.code = String(err.code);
+  }
+  return error
+}
+
+const baseParts = /^(([a-z0-9]+:)\/\/)?([^/[\s:]+|\[[^\]]+\])?(:([^/\s]+))?(\/[^\s]*)?(.*)$/;
+const httpFlags = /\[(post|get|((ipv4|ipv6|name)=([^\]]+)))\]/ig;
+const updFlags = /\[(((pk|name)=([^\]]+)))\]/ig;
+
+function parseEndpoint (endpoint) {
+  const parts = baseParts.exec(endpoint);
+  const protocol = parts[2] || 'https:';
+  const host = parts[3];
+  const port = parts[5];
+  const path = parts[6];
+  const rest = parts[7];
+  if (protocol === 'https:' || protocol === 'http:') {
+    const flags = parseFlags(rest, httpFlags);
+    return {
+      name: flags.name,
+      protocol,
+      ipv4: flags.ipv4,
+      ipv6: flags.ipv6,
+      host,
+      port,
+      path,
+      method: flags.post ? 'POST' : 'GET'
+    }
+  }
+  if (protocol === 'udp:' || protocol === 'udp4:' || protocol === 'udp6:') {
+    const flags = parseFlags(rest, updFlags);
+    const v6Parts = /^\[(.*)\]$/.exec(host);
+    if (v6Parts && protocol === 'udp4:') {
+      throw new Error(`Endpoint parsing error: Cannot use ipv6 host with udp4: (endpoint=${endpoint})`)
+    }
+    if (!v6Parts && protocol === 'udp6:') {
+      throw new Error(`Endpoint parsing error: Incorrectly formatted host for udp6: (endpoint=${endpoint})`)
+    }
+    if (v6Parts) {
+      return new UDP6Endpoint({ protocol: 'udp6:', ipv6: v6Parts[1], port, pk: flags.pk, name: flags.name })
+    }
+    return new UDP4Endpoint({ protocol: 'udp4:', ipv4: host, port, pk: flags.pk, name: flags.name })
+  }
+  throw new InvalidProtocolError(protocol, endpoint)
+}
+
+function parseFlags (rest, regex) {
+  regex.lastIndex = 0;
+  const result = {};
+  while (true) {
+    const match = regex.exec(rest);
+    if (!match) break
+    if (match[2]) {
+      result[match[3].toLowerCase()] = match[4];
+    } else {
+      result[match[1].toLowerCase()] = true;
+    }
+  }
+  return result
+}
+
+class InvalidProtocolError extends Error {
+  constructor (protocol, endpoint) {
+    super(`Invalid Endpoint: unsupported protocol "${protocol}" for endpoint: ${endpoint}, supported protocols: ${supportedProtocols.join(', ')}`);
+    this.protocol = protocol;
+    this.endpoint = endpoint;
+  }
+
+  toJSON () {
+    return {
+      code: this.code,
+      endpoint: this.endpoint,
+      timeout: this.timeout
+    }
+  }
+}
+InvalidProtocolError.prototype.name = 'InvalidProtocolError';
+InvalidProtocolError.prototype.code = 'EPROTOCOL';
+
+const supportedProtocols = ['http:', 'https:', 'udp4:', 'udp6:'];
+
+class BaseEndpoint {
+  constructor (opts, isHTTP) {
+    this.name = opts.name || null;
+    this.protocol = opts.protocol;
+    const port = typeof opts.port === 'string' ? opts.port = parseInt(opts.port, 10) : opts.port;
+    if (port === undefined || port === null) {
+      this.port = isHTTP
+        ? (this.protocol === 'https:' ? 443 : 80)
+        : (opts.pk ? 443 : 53);
+    } else if (typeof port !== 'number' && !isNaN(port)) {
+      throw new Error(`Invalid Endpoint: port "${opts.port}" needs to be a number: ${JSON.stringify(opts)}`)
+    } else {
+      this.port = port;
+    }
+  }
+
+  toJSON () {
+    return this.toString()
+  }
+}
+
+class UDPEndpoint extends BaseEndpoint {
+  constructor (opts) {
+    super(opts, false);
+    this.pk = opts.pk || null;
+  }
+
+  toString () {
+    const port = this.port !== (this.pk ? 443 : 53) ? `:${this.port}` : '';
+    const pk = this.pk ? ` [pk=${this.pk}]` : '';
+    const name = this.name ? ` [name=${this.name}]` : '';
+    return `udp://${this.ipv4 || `[${this.ipv6}]`}${port}${pk}${name}`
+  }
+}
+
+class UDP4Endpoint extends UDPEndpoint {
+  constructor (opts) {
+    super(Object.assign({ protocol: 'udp4:' }, opts));
+    if (!opts.ipv4 || typeof opts.ipv4 !== 'string') {
+      throw new Error(`Invalid Endpoint: .ipv4 "${opts.ipv4}" needs to be set: ${JSON.stringify(opts)}`)
+    }
+    this.ipv4 = opts.ipv4;
+  }
+}
+
+class UDP6Endpoint extends UDPEndpoint {
+  constructor (opts) {
+    super(Object.assign({ protocol: 'udp6:' }, opts));
+    if (!opts.ipv6 || typeof opts.ipv6 !== 'string') {
+      throw new Error(`Invalid Endpoint: .ipv6 "${opts.ipv6}" needs to be set: ${JSON.stringify(opts)}`)
+    }
+    this.ipv6 = opts.ipv6;
+  }
+}
+
+function safeHost (host) {
+  return v6Regex.test(host) && !v4Regex.test(host) ? `[${host}]` : host
+}
+
+class HTTPEndpoint extends BaseEndpoint {
+  constructor (opts) {
+    super(Object.assign({ protocol: 'https:' }, opts), true);
+    if (!opts.host) {
+      if (opts.ipv4) {
+        opts.host = opts.ipv4;
+      }
+      if (opts.ipv6) {
+        opts.host = `[${opts.ipv6}]`;
+      }
+    }
+    if (!opts.host || typeof opts.host !== 'string') {
+      throw new Error(`Invalid Endpoint: host "${opts.path}" needs to be set: ${JSON.stringify(opts)}`)
+    }
+    this.host = opts.host;
+    this.path = opts.path || '/dns-query';
+    this.method = /^post$/i.test(opts.method) ? 'POST' : 'GET';
+    this.ipv4 = opts.ipv4;
+    this.ipv6 = opts.ipv6;
+    if (!this.ipv6) {
+      const v6Parts = v6Regex.exec(this.host);
+      if (v6Parts) {
+        this.ipv6 = v6Parts[1];
+      }
+    }
+    if (!this.ipv4) {
+      if (v4Regex.test(this.host)) {
+        this.ipv4 = this.host;
+      }
+    }
+    const url = `${this.protocol}//${safeHost(this.host)}:${this.port}${this.path}`;
+    try {
+      this.url = new URL(url);
+    } catch (err) {
+      throw new Error(err.message + ` [${url}]`)
+    }
+  }
+
+  toString () {
+    const protocol = this.protocol === 'https:' ? '' : 'http://';
+    const port = this.port !== (this.protocol === 'https:' ? 443 : 80) ? `:${this.port}` : '';
+    const method = this.method !== 'GET' ? ' [post]' : '';
+    const path = this.path === '/dns-query' ? '' : this.path;
+    const name = this.name ? ` [name=${this.name}]` : '';
+    const ipv4 = this.ipv4 && this.ipv4 !== this.host ? ` [ipv4=${this.ipv4}]` : '';
+    const ipv6 = this.ipv6 && this.ipv6 !== this.host ? ` [ipv6=${this.ipv6}]` : '';
+    return `${protocol}${safeHost(this.host)}${port}${path}${method}${ipv4}${ipv6}${name}`
+  }
+}
+
+function toEndpoint (input) {
+  let opts;
+  if (typeof input === 'string') {
+    opts = parseEndpoint(input);
+  } else {
+    if (typeof input !== 'object' || input === null || Array.isArray(input)) {
+      throw new Error(`Can not convert ${input} to an endpoint`)
+    } else if (input instanceof BaseEndpoint) {
+      return input
+    }
+    opts = input;
+  }
+  if (opts.protocol === null || opts.protocol === undefined) {
+    opts.protocol = 'https:';
+  }
+  const protocol = opts.protocol;
+  if (protocol === 'udp4:') {
+    return new UDP4Endpoint(opts)
+  }
+  if (protocol === 'udp6:') {
+    return new UDP6Endpoint(opts)
+  }
+  if (protocol === 'https:' || protocol === 'http:') {
+    return new HTTPEndpoint(opts)
+  }
+  throw new InvalidProtocolError(protocol, JSON.stringify(opts))
+}
+
+/* global XMLHttpRequest, localStorage */
+const contentType = 'application/dns-message';
+
+function noop () { }
+
+function queryDns () {
+  throw new Error('Only "doh" endpoints are supported in the browser')
+}
+
+async function loadJSON (url, cache, timeout, abortSignal) {
+  const cacheKey = cache ? cache.localStoragePrefix + cache.name : null;
+  if (cacheKey) {
+    try {
+      const cached = JSON.parse(localStorage.getItem(cacheKey));
+      if (cached && cached.time > cache.maxTime) {
+        return cached
+      }
+    } catch (err) {}
+  }
+  const { data } = await requestRaw(url, 'GET', null, timeout, abortSignal);
+  const result = {
+    time: Date.now(),
+    data: JSON.parse(decode$1(data))
+  };
+  if (cacheKey) {
+    try {
+      localStorage.setItem(cacheKey, JSON.stringify(result));
+    } catch (err) {
+      result.time = null;
+    }
+  }
+  return result
+}
+
+function requestRaw (url, method, data, timeout, abortSignal) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(url);
+    if (method === 'GET' && data) {
+      target.search = '?dns=' + base64URL.decode(data);
+    }
+    const uri = target.toString();
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, uri, true);
+    xhr.setRequestHeader('Accept', contentType);
+    if (method === 'POST') {
+      xhr.setRequestHeader('Content-Type', contentType);
+    }
+    xhr.responseType = 'arraybuffer';
+    xhr.timeout = timeout;
+    xhr.ontimeout = ontimeout;
+    xhr.onreadystatechange = onreadystatechange;
+    xhr.onerror = onerror;
+    xhr.onload = onload;
+    if (method === 'POST') {
+      xhr.send(data);
+    } else {
+      xhr.send();
+    }
+
+    if (abortSignal) {
+      abortSignal.addEventListener('abort', onabort);
+    }
+
+    function ontimeout () {
+      finish(new TimeoutError(timeout));
+      try {
+        xhr.abort();
+      } catch (e) { }
+    }
+
+    function onload () {
+      if (xhr.status !== 200) {
+        finish(new HTTPStatusError(uri, xhr.status, method));
+      } else {
+        let buf;
+        if (typeof xhr.response === 'string') {
+          buf = encode$1(xhr.response);
+        } else if (xhr.response instanceof Uint8Array) {
+          buf = xhr.response;
+        } else if (Array.isArray(xhr.response) || xhr.response instanceof ArrayBuffer) {
+          buf = new Uint8Array(xhr.response);
+        } else {
+          throw new Error('Unprocessable response ' + xhr.response)
+        }
+        finish(null, buf);
+      }
+    }
+
+    function onreadystatechange () {
+      if (xhr.readyState > 1 && xhr.status !== 200 && xhr.status !== 0) {
+        finish(new HTTPStatusError(uri, xhr.status, method));
+        try {
+          xhr.abort();
+        } catch (e) { }
+      }
+    }
+
+    let finish = function (error, data) {
+      finish = noop;
+      if (abortSignal) {
+        abortSignal.removeEventListener('abort', onabort);
+      }
+      if (error) {
+        resolve({
+          error,
+          response: xhr
+        });
+      } else {
+        resolve({
+          data,
+          response: xhr
+        });
+      }
+    };
+
+    function onerror () {
+      finish(xhr.status === 200 ? new Error('Inexplicable XHR Error') : new HTTPStatusError(uri, xhr.status, method));
+    }
+
+    function onabort () {
+      finish(new AbortError());
+      try {
+        xhr.abort();
+      } catch (e) { }
+    }
+  })
+}
+
+function request (url, method, packet, timeout, abortSignal) {
+  return requestRaw(url, method, packet, timeout, abortSignal)
+}
+
+function processResolvers$1 (resolvers) {
+  return resolvers.filter(resolver => resolver.cors || resolver.endpoint.cors)
+}
+
+const resolvers = {
+  data: [
+    {
+      name: 'adfree.usableprivacy.net',
+      endpoint: {
+        protocol: 'https:',
+        host: 'adfree.usableprivacy.net'
+      },
+      description: 'Public updns DoH service with advertising, tracker and malware filters.\nHosted in Europe by @usableprivacy, details see: https://docs.usableprivacy.com',
+      country: 'Germany',
+      location: {
+        lat: 51.2993,
+        long: 9.491
+      },
+      filter: true
+    },
+    {
+      name: 'adguard-dns-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.adguard.com',
+        ipv4: '94.140.15.15'
+      },
+      description: 'Remove ads and protect your computer from malware (over DoH)',
+      country: 'France',
+      location: {
+        lat: 48.8582,
+        long: 2.3387
+      },
+      filter: true
+    },
+    {
+      name: 'adguard-dns-family-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns-family.adguard.com',
+        ipv4: '94.140.15.16'
+      },
+      description: 'Adguard DNS with safesearch and adult content blocking (over DoH)',
+      country: 'France',
+      location: {
+        lat: 48.8582,
+        long: 2.3387
+      },
+      filter: true
+    },
+    {
+      name: 'adguard-dns-unfiltered-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns-unfiltered.adguard.com',
+        ipv4: '94.140.14.140'
+      },
+      description: 'AdGuard public DNS servers without filters (over DoH)',
+      country: 'France',
+      location: {
+        lat: 48.8582,
+        long: 2.3387
+      }
+    },
+    {
+      name: 'ahadns-doh-chi',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.chi.ahadns.net',
+        cors: true
+      },
+      description: 'A zero logging DNS with support for DNS-over-HTTPS (DoH) & DNS-over-TLS (DoT). Blocks ads, malware, trackers, viruses, ransomware, telemetry and more. No persistent logs. DNSSEC. Hosted in Chicago, USA. By https://ahadns.com/\nServer statistics can be seen at: https://statistics.ahadns.com/?server=chi',
+      country: 'United States',
+      location: {
+        lat: 41.8483,
+        long: -87.6517
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'ahadns-doh-in',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.in.ahadns.net',
+        cors: true
+      },
+      description: 'A zero logging DNS with support for DNS-over-HTTPS (DoH) & DNS-over-TLS (DoT). Blocks ads, malware, trackers, viruses, ransomware, telemetry and more. No persistent logs. DNSSEC. Hosted in Mumbai, India. By https://ahadns.com/\nServer statistics can be seen at: https://statistics.ahadns.com/?server=in',
+      country: 'India',
+      location: {
+        lat: 19.0748,
+        long: 72.8856
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'ahadns-doh-la',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.la.ahadns.net',
+        cors: true
+      },
+      description: 'A zero logging DNS with support for DNS-over-HTTPS (DoH) & DNS-over-TLS (DoT). Blocks ads, malware, trackers, viruses, ransomware, telemetry and more. No persistent logs. DNSSEC. Hosted in Los Angeles, USA. By https://ahadns.com/\nServer statistics can be seen at: https://statistics.ahadns.com/?server=la',
+      country: 'United States',
+      location: {
+        lat: 34.0549,
+        long: -118.2578
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'ahadns-doh-nl',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.nl.ahadns.net',
+        cors: true
+      },
+      description: 'A zero logging DNS with support for DNS-over-HTTPS (DoH) & DNS-over-TLS (DoT). Blocks ads, malware, trackers, viruses, ransomware, telemetry and more. No persistent logs. DNSSEC. Hosted in Amsterdam, Netherlands. By https://ahadns.com/\nServer statistics can be seen at: https://statistics.ahadns.com/?server=nl',
+      country: 'Netherlands',
+      location: {
+        lat: 52.3824,
+        long: 4.8995
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'ahadns-doh-ny',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.ny.ahadns.net',
+        cors: true
+      },
+      description: 'A zero logging DNS with support for DNS-over-HTTPS (DoH) & DNS-over-TLS (DoT). Blocks ads, malware, trackers, viruses, ransomware, telemetry and more. No persistent logs. DNSSEC. Hosted in New York. By https://ahadns.com/\nServer statistics can be seen at: https://statistics.ahadns.com/?server=ny',
+      country: 'United States',
+      location: {
+        lat: 40.7308,
+        long: -73.9975
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'ahadns-doh-pl',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.pl.ahadns.net',
+        cors: true
+      },
+      description: 'A zero logging DNS with support for DNS-over-HTTPS (DoH) & DNS-over-TLS (DoT). Blocks ads, malware, trackers, viruses, ransomware, telemetry and more. No persistent logs. DNSSEC. Hosted in Poland. By https://ahadns.com/\nServer statistics can be seen at: https://statistics.ahadns.com/?server=pl',
+      country: 'Netherlands',
+      location: {
+        lat: 52.3824,
+        long: 4.8995
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'alidns-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.alidns.com',
+        ipv4: '223.5.5.5',
+        cors: true
+      },
+      description: 'A public DNS resolver that supports DoH/DoT in mainland China, provided by Alibaba-Cloud.\nWarning: GFW filtering rules are applied by that resolver.\nHomepage: https://alidns.com/',
+      country: 'China',
+      location: {
+        lat: 34.7725,
+        long: 113.7266
+      },
+      filter: true,
+      log: true,
+      cors: true
+    },
+    {
+      name: 'ams-ads-doh-nl',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dnsnl-noads.alekberg.net'
+      },
+      description: 'Resolver in Amsterdam. DoH protocol. Non-logging. Blocks ads, malware and trackers. DNSSEC enabled.',
+      country: 'Romania',
+      location: {
+        lat: 45.9968,
+        long: 24.997
+      },
+      filter: true
+    },
+    {
+      name: 'ams-doh-nl',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dnsnl.alekberg.net'
+      },
+      description: 'Resolver in Amsterdam. DoH protocol. Non-logging, non-filtering, DNSSEC.',
+      country: 'Romania',
+      location: {
+        lat: 45.9968,
+        long: 24.997
+      }
+    },
+    {
+      name: 'att',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dohtrial.att.net'
+      },
+      description: 'AT&T test DoH server.',
+      log: true
+    },
+    {
+      name: 'bcn-ads-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dnses-noads.alekberg.net'
+      },
+      description: 'Resolver in Spain. DoH protocol. Non-logging, remove ads and malware, DNSSEC.',
+      country: 'Spain',
+      location: {
+        lat: 41.3891,
+        long: 2.1611
+      },
+      filter: true
+    },
+    {
+      name: 'bcn-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dnses.alekberg.net'
+      },
+      description: 'Resolver in Spain. DoH protocol. Non-logging, non-filtering, DNSSEC.',
+      country: 'Spain',
+      location: {
+        lat: 41.3891,
+        long: 2.1611
+      }
+    },
+    {
+      name: 'brahma-world',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.brahma.world'
+      },
+      description: 'DNS-over-HTTPS server. Non Logging, filters ads, trackers and malware. DNSSEC ready, QNAME Minimization, No EDNS Client-Subnet.\nHosted in Stockholm, Sweden. (https://dns.brahma.world)',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      filter: true
+    },
+    {
+      name: 'cisco-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.opendns.com',
+        ipv4: '146.112.41.2'
+      },
+      description: 'Remove your DNS blind spot (DoH protocol)\nWarning: modifies your queries to include a copy of your network\naddress when forwarding them to a selection of companies and organizations.',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      filter: true,
+      log: true
+    },
+    {
+      name: 'cloudflare',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.cloudflare.com',
+        ipv4: '1.0.0.1',
+        cors: true
+      },
+      description: 'Cloudflare DNS (anycast) - aka 1.1.1.1 / 1.0.0.1',
+      country: 'Australia',
+      location: {
+        lat: -33.494,
+        long: 143.2104
+      },
+      cors: true
+    },
+    {
+      name: 'cloudflare-family',
+      endpoint: {
+        protocol: 'https:',
+        host: 'family.cloudflare-dns.com',
+        ipv4: '1.0.0.3',
+        cors: true
+      },
+      description: 'Cloudflare DNS (anycast) with malware protection and parental control - aka 1.1.1.3 / 1.0.0.3',
+      country: 'Australia',
+      location: {
+        lat: -33.494,
+        long: 143.2104
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'cloudflare-ipv6',
+      endpoint: {
+        protocol: 'https:',
+        host: '1dot1dot1dot1.cloudflare-dns.com',
+        cors: true
+      },
+      description: 'Cloudflare DNS over IPv6 (anycast)',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      cors: true
+    },
+    {
+      name: 'cloudflare-security',
+      endpoint: {
+        protocol: 'https:',
+        host: 'security.cloudflare-dns.com',
+        ipv4: '1.0.0.2',
+        cors: true
+      },
+      description: 'Cloudflare DNS (anycast) with malware blocking - aka 1.1.1.2 / 1.0.0.2',
+      country: 'Australia',
+      location: {
+        lat: -33.494,
+        long: 143.2104
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'controld-block-malware',
+      endpoint: {
+        protocol: 'https:',
+        host: 'freedns.controld.com',
+        path: '/p1'
+      },
+      description: 'ControlD Free DNS. Take CONTROL of your Internet. Block unwanted content, bypass geo-restrictions and be more productive. DoH protocol and No logging. - https://controld.com/free-dns\nThis DNS blocks Malware domains.',
+      country: 'Canada',
+      location: {
+        lat: 43.6319,
+        long: -79.3716
+      },
+      filter: true
+    },
+    {
+      name: 'controld-block-malware-ad',
+      endpoint: {
+        protocol: 'https:',
+        host: 'freedns.controld.com',
+        path: '/p2'
+      },
+      description: 'ControlD Free DNS. Take CONTROL of your Internet. Block unwanted content, bypass geo-restrictions and be more productive. DoH protocol and No logging. - https://controld.com/free-dns\nThis DNS blocks Malware, Ads & Tracking domains.',
+      country: 'Canada',
+      location: {
+        lat: 43.6319,
+        long: -79.3716
+      },
+      filter: true
+    },
+    {
+      name: 'controld-block-malware-ad-social',
+      endpoint: {
+        protocol: 'https:',
+        host: 'freedns.controld.com',
+        path: '/p3'
+      },
+      description: 'ControlD Free DNS. Take CONTROL of your Internet. Block unwanted content, bypass geo-restrictions and be more productive. DoH protocol and No logging. - https://controld.com/free-dns\nThis DNS blocks Malware, Ads & Tracking and Social Networks domains.',
+      country: 'Canada',
+      location: {
+        lat: 43.6319,
+        long: -79.3716
+      },
+      filter: true
+    },
+    {
+      name: 'controld-family-friendly',
+      endpoint: {
+        protocol: 'https:',
+        host: 'freedns.controld.com',
+        path: '/family'
+      },
+      description: 'ControlD Free DNS. Take CONTROL of your Internet. Block unwanted content, bypass geo-restrictions and be more productive. DoH protocol and No logging. - https://controld.com/free-dns\nThis DNS blocks Malware, Ads & Tracking, Adult Content and Drugs domains.',
+      country: 'Canada',
+      location: {
+        lat: 43.6319,
+        long: -79.3716
+      },
+      filter: true
+    },
+    {
+      name: 'controld-uncensored',
+      endpoint: {
+        protocol: 'https:',
+        host: 'freedns.controld.com',
+        path: '/uncensored'
+      },
+      description: 'ControlD Free DNS. Take CONTROL of your Internet. Block unwanted content, bypass geo-restrictions and be more productive. DoH protocol and No logging. - https://controld.com/free-dns\nThis DNS unblocks censored domains from various countries.',
+      country: 'Canada',
+      location: {
+        lat: 43.6319,
+        long: -79.3716
+      }
+    },
+    {
+      name: 'controld-unfiltered',
+      endpoint: {
+        protocol: 'https:',
+        host: 'freedns.controld.com',
+        path: '/p0'
+      },
+      description: 'ControlD Free DNS. Take CONTROL of your Internet. Block unwanted content, bypass geo-restrictions and be more productive. DoH protocol and No logging. - https://controld.com/free-dns\nThis is a Unfiltered DNS, no DNS record blocking or manipulation here, if you want to block Malware, Ads & Tracking or Social Network domains, use the other ControlD DNS configs.',
+      country: 'Canada',
+      location: {
+        lat: 43.6319,
+        long: -79.3716
+      }
+    },
+    {
+      name: 'dns.digitale-gesellschaft.ch',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.digitale-gesellschaft.ch'
+      },
+      description: 'Public DoH resolver operated by the Digital Society (https://www.digitale-gesellschaft.ch).\nHosted in Zurich, Switzerland.\nNon-logging, non-filtering, supports DNSSEC.',
+      country: 'Switzerland',
+      location: {
+        lat: 47.1449,
+        long: 8.1551
+      }
+    },
+    {
+      name: 'dns.ryan-palmer',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns1.ryan-palmer.com'
+      },
+      description: 'Non-logging, non-filtering, DNSSEC DoH Server. Hosted in the UK.',
+      country: 'United Kingdom',
+      location: {
+        lat: 51.5164,
+        long: -0.093
+      }
+    },
+    {
+      name: 'dns.sb',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.sb',
+        ipv4: '185.222.222.222',
+        cors: true
+      },
+      description: 'DNSSEC-enabled DoH server by https://xtom.com/\nhttps://dns.sb/doh/',
+      country: 'Unknown',
+      location: {
+        lat: 47,
+        long: 8
+      },
+      cors: true
+    },
+    {
+      name: 'dns.therifleman.name',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.therifleman.name'
+      },
+      description: 'DNS-over-HTTPS DNS forwarder from Mumbai, India. Blocks web and Android trackers and ads.\nIP addresses are not logged, but queries are logged for 24 hours for debugging.\nReport issues, send suggestions @ joker349 at protonmail.com.\nAlso supports DoT (for android) @ dns.therifleman.name and plain DNS @ 172.104.206.174',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      filter: true
+    },
+    {
+      name: 'dnsforfamily-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns-doh.dnsforfamily.com'
+      },
+      description: '(DoH Protocol) (Now supports DNSSEC). Block adult websites, gambling websites, malwares and advertisements.\nIt also enforces safe search in: Google, YouTube, Bing, DuckDuckGo and Yandex.\nSocial websites like Facebook and Instagram are not blocked. No DNS queries are logged.\nAs of 26-May-2022 5.9 million websites are blocked and new websites are added to blacklist daily.\nCompletely free, no ads or any commercial motive. Operating for 4 years now.\nProvided by: https://dnsforfamily.com',
+      country: 'Finland',
+      location: {
+        lat: 60.1758,
+        long: 24.9349
+      },
+      filter: true
+    },
+    {
+      name: 'dnsforfamily-doh-no-safe-search',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns-doh-no-safe-search.dnsforfamily.com'
+      },
+      description: '(DoH Protocol) (Now supports DNSSEC) Block adult websites, gambling websites, malwares and advertisements.\nUnlike other dnsforfamily servers, this one does not enforces safe search. So Google, YouTube, Bing, DuckDuckGo and Yandex are completely accessible without any restriction.\nSocial websites like Facebook and Instagram are not blocked. No DNS queries are logged.\nAs of 26-May-2022 5.9 million websites are blocked and new websites are added to blacklist daily.\nCompletely free, no ads or any commercial motive. Operating for 4 years now.\nWarning: This server is incompatible with anonymization.\nProvided by: https://dnsforfamily.com',
+      country: 'Finland',
+      location: {
+        lat: 60.1758,
+        long: 24.9349
+      },
+      filter: true
+    },
+    {
+      name: 'dnsforge.de',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dnsforge.de',
+        cors: true
+      },
+      description: 'Public DoH resolver running with Pihole for Adblocking (https://dnsforge.de).\nNon-logging, AD-filtering, supports DNSSEC. Hosted in Germany.',
+      country: 'Germany',
+      location: {
+        lat: 52.2998,
+        long: 9.447
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'dnshome-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.dnshome.de'
+      },
+      description: 'https://www.dnshome.de/ public resolver in Germany'
+    },
+    {
+      name: 'dnspod-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.pub',
+        cors: true
+      },
+      description: 'A public DNS resolver in mainland China provided by DNSPod (Tencent Cloud).\nhttps://www.dnspod.cn/Products/Public.DNS?lang=en',
+      filter: true,
+      log: true,
+      cors: true
+    },
+    {
+      name: 'dnswarden-asia-adblock-dohv4',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.asia.dnswarden.com',
+        path: '/adblock'
+      },
+      description: 'Hosted in Singapore. For more information look [here](https://github.com/bhanupratapys/dnswarden) or [here](https://dnswarden.com).',
+      country: 'Singapore',
+      location: {
+        lat: 1.2929,
+        long: 103.8547
+      },
+      filter: true
+    },
+    {
+      name: 'dnswarden-asia-adultfilter-dohv4',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.asia.dnswarden.com',
+        path: '/adultfilter'
+      },
+      description: 'Hosted in Singapore. For more information look [here](https://github.com/bhanupratapys/dnswarden) or [here](https://dnswarden.com).',
+      country: 'Singapore',
+      location: {
+        lat: 1.2929,
+        long: 103.8547
+      },
+      filter: true
+    },
+    {
+      name: 'dnswarden-asia-uncensor-dohv4',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.asia.dnswarden.com',
+        path: '/uncensored'
+      },
+      description: 'Hosted in Singapore. For more information look [here](https://github.com/bhanupratapys/dnswarden) or [here](https://dnswarden.com).',
+      country: 'Singapore',
+      location: {
+        lat: 1.2929,
+        long: 103.8547
+      }
+    },
+    {
+      name: 'dnswarden-eu-adblock-dohv4',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.eu.dnswarden.com'
+      },
+      description: 'Hosted in Germany. For more information look [here](https://github.com/bhanupratapys/dnswarden) or [here](https://dnswarden.com).',
+      country: 'Germany',
+      location: {
+        lat: 50.1103,
+        long: 8.7147
+      },
+      filter: true
+    },
+    {
+      name: 'dnswarden-us-adblock-dohv4',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.us.dnswarden.com'
+      },
+      description: 'Hosted in USA (Dallas) . For more information look [here](https://github.com/bhanupratapys/dnswarden) or [here](https://dnswarden.com).',
+      country: 'United States',
+      location: {
+        lat: 32.7889,
+        long: -96.8021
+      },
+      filter: true
+    },
+    {
+      name: 'doh-ch-blahdns',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh-ch.blahdns.com',
+        cors: true
+      },
+      description: 'Blocks ad and Tracking, no Logging, DNSSEC, Hosted in Switzerland. By https://blahdns.com/',
+      country: 'Netherlands',
+      location: {
+        lat: 52.3824,
+        long: 4.8995
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'doh-cleanbrowsing-adult',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.cleanbrowsing.org',
+        path: '/doh/adult-filter/',
+        cors: true
+      },
+      description: 'Blocks access to all adult, pornographic and explicit sites. It does\nnot block proxy or VPNs, nor mixed-content sites. Sites like Reddit\nare allowed. Google and Bing are set to the Safe Mode.\nBy https://cleanbrowsing.org/',
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'doh-cleanbrowsing-family',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.cleanbrowsing.org',
+        path: '/doh/family-filter/',
+        cors: true
+      },
+      description: 'Blocks access to all adult, pornographic and explicit sites. It also\nblocks proxy and VPN domains that are used to bypass the filters.\nMixed content sites (like Reddit) are also blocked. Google, Bing and\nYoutube are set to the Safe Mode.\nBy https://cleanbrowsing.org/',
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'doh-cleanbrowsing-security',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.cleanbrowsing.org',
+        path: '/doh/security-filter/',
+        cors: true
+      },
+      description: 'Block access to phishing, malware and malicious domains. It does not block adult content.\nBy https://cleanbrowsing.org/',
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'doh-crypto-sx',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.crypto.sx',
+        cors: true
+      },
+      description: 'DNS-over-HTTPS server. Anycast, no logs, no censorship, DNSSEC.\nBackend hosted by Scaleway, globally cached via Cloudflare.\nMaintained by Frank Denis.',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      cors: true
+    },
+    {
+      name: 'doh-crypto-sx-ipv6',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh-ipv6.crypto.sx',
+        cors: true
+      },
+      description: 'DNS-over-HTTPS server accessible over IPv6. Anycast, no logs, no censorship, DNSSEC.\nBackend hosted by Scaleway, globally cached via Cloudflare.\nMaintained by Frank Denis.',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      cors: true
+    },
+    {
+      name: 'doh-de-blahdns',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh-de.blahdns.com',
+        cors: true
+      },
+      description: 'Blocks ad and Tracking, no Logging, DNSSEC, Hosted in Germany. By https://blahdns.com/',
+      country: 'Germany',
+      location: {
+        lat: 51.2993,
+        long: 9.491
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'doh-fi-blahdns',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh-fi.blahdns.com',
+        cors: true
+      },
+      description: 'Blocks ad and Tracking, no Logging, DNSSEC, Hosted in Finland. By https://blahdns.com/',
+      country: 'Finland',
+      location: {
+        lat: 60.1758,
+        long: 24.9349
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'doh-ibksturm',
+      endpoint: {
+        protocol: 'https:',
+        host: 'ibksturm.synology.me'
+      },
+      description: 'DoH & DoT Server, No Logging, No Filters, DNSSEC\nRunning privately by ibksturm in Thurgau, Switzerland'
+    },
+    {
+      name: 'doh-jp-blahdns',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh-jp.blahdns.com',
+        cors: true
+      },
+      description: 'Blocks ad and Tracking, no Logging, DNSSEC, Hosted in Japan. By https://blahdns.com/',
+      country: 'Japan',
+      location: {
+        lat: 35.6882,
+        long: 139.7532
+      },
+      filter: true,
+      cors: true
+    },
+    {
+      name: 'doh.ffmuc.net',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.ffmuc.net'
+      },
+      description: 'An open (non-logging, non-filtering, non-censoring) DoH resolver operated by Freifunk Munich with nodes in DE.\nhttps://ffmuc.net/',
+      country: 'Germany',
+      location: {
+        lat: 51.2993,
+        long: 9.491
+      }
+    },
+    {
+      name: 'doh.tiarap.org',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.tiarap.org'
+      },
+      description: 'Non-Logging DNS-over-HTTPS server, cached via Cloudflare.\nFilters out ads, trackers and malware, NO ECS, supports DNSSEC.',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      filter: true
+    },
+    {
+      name: 'google',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.google',
+        ipv4: '8.8.8.8',
+        cors: true
+      },
+      description: 'Google DNS (anycast)',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      log: true,
+      cors: true
+    },
+    {
+      name: 'hdns',
+      endpoint: {
+        protocol: 'https:',
+        host: 'query.hdns.io',
+        cors: true
+      },
+      description: 'HDNS is a public DNS resolver that supports Handshake domains.\nhttps://www.hdns.io',
+      country: 'United States',
+      location: {
+        lat: 37.7771,
+        long: -122.406
+      },
+      cors: true
+    },
+    {
+      name: 'he',
+      endpoint: {
+        protocol: 'https:',
+        host: 'ordns.he.net'
+      },
+      description: 'Hurricane Electric DoH server (anycast)\nUnknown logging policy.',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      log: true
+    },
+    {
+      name: 'id-gmail-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.tiar.app'
+      },
+      description: 'Non-Logging DNS-over-HTTPS server located in Singapore.\nFilters out ads, trackers and malware, supports DNSSEC, provided by id-gmail.',
+      country: 'Singapore',
+      location: {
+        lat: 1.2929,
+        long: 103.8547
+      },
+      filter: true
+    },
+    {
+      name: 'iij',
+      endpoint: {
+        protocol: 'https:',
+        host: 'public.dns.iij.jp'
+      },
+      description: 'DoH server operated by Internet Initiative Japan in Tokyo.\nhttps://www.iij.ad.jp/',
+      country: 'Japan',
+      location: {
+        lat: 35.69,
+        long: 139.69
+      },
+      log: true
+    },
+    {
+      name: 'iqdns-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'a.passcloud.xyz'
+      },
+      description: 'Non-logging DoH service runned by V2EX.com user johnsonwil.\nReturns "no such domain" for anti-Chinese government websites. Supports DNSSEC.\nFor more information: https://www.v2ex.com/t/785666',
+      filter: true
+    },
+    {
+      name: 'jp.tiar.app-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'jp.tiar.app'
+      },
+      description: 'Non-Logging, Non-Filtering DNS-over-HTTPS server in Japan.\nNo ECS, Support DNSSEC',
+      country: 'Japan',
+      location: {
+        lat: 35.6882,
+        long: 139.7532
+      }
+    },
+    {
+      name: 'jp.tiarap.org',
+      endpoint: {
+        protocol: 'https:',
+        host: 'jp.tiarap.org'
+      },
+      description: 'DNS-over-HTTPS Server. Non-Logging, Non-Filtering, No ECS, Support DNSSEC.\nCached via Cloudflare.'
+    },
+    {
+      name: 'libredns',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.libredns.gr'
+      },
+      description: 'DoH server in Germany. No logging, but no DNS padding and no DNSSEC support.\nhttps://libredns.gr/',
+      country: 'Germany',
+      location: {
+        lat: 51.2993,
+        long: 9.491
+      }
+    },
+    {
+      name: 'nextdns',
+      endpoint: {
+        protocol: 'https:',
+        host: 'anycsast.dns.nextdns.io'
+      },
+      description: 'NextDNS is a cloud-based private DNS service that gives you full control\nover what is allowed and what is blocked on the Internet.\nDNSSEC, Anycast, Non-logging, NoFilters\nhttps://www.nextdns.io/',
+      country: 'Netherlands',
+      location: {
+        lat: 52.3891,
+        long: 4.6563
+      }
+    },
+    {
+      name: 'nextdns-ultralow',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.nextdns.io',
+        path: '/dnscrypt-proxy'
+      },
+      description: 'NextDNS is a cloud-based private DNS service that gives you full control\nover what is allowed and what is blocked on the Internet.\nhttps://www.nextdns.io/\nTo select the server location, the "-ultralow" variant relies on bootstrap servers\ninstead of anycast.'
+    },
+    {
+      name: 'njalla-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.njal.la',
+        cors: true
+      },
+      description: 'Non-logging DoH server in Sweden operated by Njalla.\nhttps://dns.njal.la/',
+      country: 'Sweden',
+      location: {
+        lat: 59.3247,
+        long: 18.056
+      },
+      cors: true
+    },
+    {
+      name: 'odoh-cloudflare',
+      endpoint: {
+        protocol: 'https:',
+        host: 'odoh.cloudflare-dns.com',
+        cors: true
+      },
+      description: 'Cloudflare ODoH server.\nhttps://cloudflare.com',
+      cors: true
+    },
+    {
+      name: 'odoh-crypto-sx',
+      endpoint: {
+        protocol: 'https:',
+        host: 'odoh.crypto.sx',
+        cors: true
+      },
+      description: 'ODoH target server. Anycast, no logs.\nBackend hosted by Scaleway. Maintained by Frank Denis.',
+      cors: true
+    },
+    {
+      name: 'odoh-id-gmail',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.tiar.app',
+        path: '/odoh'
+      },
+      description: 'ODoH target server. Based in Singapore, no logs.\nFilter ads, trackers and malware.',
+      filter: true
+    },
+    {
+      name: 'odoh-jp.tiar.app',
+      endpoint: {
+        protocol: 'https:',
+        host: 'jp.tiar.app',
+        path: '/odoh'
+      },
+      description: 'ODoH target server. no logs.'
+    },
+    {
+      name: 'odoh-jp.tiarap.org',
+      endpoint: {
+        protocol: 'https:',
+        host: 'jp.tiarap.org',
+        path: '/odoh'
+      },
+      description: 'ODoH target server via Cloudflare, no logs.'
+    },
+    {
+      name: 'odoh-resolver4.dns.openinternet.io',
+      endpoint: {
+        protocol: 'https:',
+        host: 'resolver4.dns.openinternet.io'
+      },
+      description: "ODoH target server. no logs, no filter, DNSSEC.\nRunning on dedicated hardware colocated at Sonic.net in Santa Rosa, CA in the United States.\nUses Sonic's recusrive DNS servers as upstream resolvers (but is not affiliated with Sonic\nin any way). Provided by https://openinternet.io"
+    },
+    {
+      name: 'odoh-tiarap.org',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.tiarap.org',
+        path: '/odoh'
+      },
+      description: 'ODoH target server via Cloudflare, no logs.\nFilter ads, trackers and malware.',
+      filter: true
+    },
+    {
+      name: 'publicarray-au2-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh-2.seby.io',
+        cors: true
+      },
+      description: 'DNSSEC • OpenNIC • Non-logging • Uncensored - hosted on ovh.com.au\nMaintained by publicarray - https://dns.seby.io',
+      country: 'Australia',
+      location: {
+        lat: -33.8591,
+        long: 151.2002
+      },
+      cors: true
+    },
+    {
+      name: 'puredns-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'puredns.org',
+        ipv4: '146.190.6.13',
+        cors: true
+      },
+      description: 'Public uncensored DNS resolver in Singapore - https://puredns.org\n** Only available in Indonesia and Singapore **',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      cors: true
+    },
+    {
+      name: 'quad101',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.twnic.tw',
+        cors: true
+      },
+      description: 'DNSSEC-aware public resolver by the Taiwan Network Information Center (TWNIC)\nhttps://101.101.101.101/index_en.html',
+      cors: true
+    },
+    {
+      name: 'quad9-doh-ip4-port443-filter-ecs-pri',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns11.quad9.net',
+        ipv4: '149.112.112.11'
+      },
+      description: 'Quad9 (anycast) dnssec/no-log/filter/ecs 9.9.9.11 - 149.112.112.11',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      filter: true
+    },
+    {
+      name: 'quad9-doh-ip4-port443-filter-pri',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.quad9.net',
+        ipv4: '149.112.112.112'
+      },
+      description: 'Quad9 (anycast) dnssec/no-log/filter 9.9.9.9 - 149.112.112.9 - 149.112.112.112',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      filter: true
+    },
+    {
+      name: 'quad9-doh-ip4-port443-nofilter-ecs-pri',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns12.quad9.net',
+        ipv4: '9.9.9.12'
+      },
+      description: 'Quad9 (anycast) no-dnssec/no-log/no-filter/ecs 9.9.9.12 - 149.112.112.12',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      }
+    },
+    {
+      name: 'quad9-doh-ip4-port443-nofilter-pri',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns10.quad9.net',
+        ipv4: '149.112.112.10'
+      },
+      description: 'Quad9 (anycast) no-dnssec/no-log/no-filter 9.9.9.10 - 149.112.112.10',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      }
+    },
+    {
+      name: 'quad9-doh-ip6-port5053-filter-pri',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns9.quad9.net'
+      },
+      description: 'Quad9 (anycast) dnssec/no-log/filter 2620:fe::fe - 2620:fe::9 - 2620:fe::fe:9',
+      country: 'United States',
+      location: {
+        lat: 37.751,
+        long: -97.822
+      },
+      filter: true
+    },
+    {
+      name: 'safesurfer-doh',
+      endpoint: {
+        protocol: 'https:',
+        host: 'doh.safesurfer.io'
+      },
+      description: 'Family safety focused blocklist for over 2 million adult sites, as well as phishing and malware and more.\nFree to use, paid for customizing blocking for more categories+sites and viewing usage at my.safesurfer.io. Logs taken for viewing\nusage, data never sold - https://safesurfer.io',
+      filter: true,
+      log: true
+    },
+    {
+      name: 'sth-ads-doh-se',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dnsse-noads.alekberg.net'
+      },
+      description: 'Resolver in Stockholm, Sweden. DoH server. Non-logging, remove ads and malware, DNSSEC.',
+      country: 'Bulgaria',
+      location: {
+        lat: 42.696,
+        long: 23.332
+      },
+      filter: true
+    },
+    {
+      name: 'sth-doh-se',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dnsse.alekberg.net'
+      },
+      description: 'Resolver in Stockholm, Sweden. DoH server. Non-logging, non-filtering, DNSSEC.',
+      country: 'Bulgaria',
+      location: {
+        lat: 42.696,
+        long: 23.332
+      }
+    },
+    {
+      name: 'switch',
+      endpoint: {
+        protocol: 'https:',
+        host: 'dns.switch.ch'
+      },
+      description: 'Public DoH service provided by SWITCH in Switzerland\nhttps://www.switch.ch\nProvides protection against malware, but does not block ads.',
+      filter: true
+    },
+    {
+      name: 'uncensoreddns-dk-ipv4',
+      endpoint: {
+        protocol: 'https:',
+        host: 'unicast.uncensoreddns.org'
+      },
+      description: 'Also known as censurfridns.\nDoH, no logs, no filter, DNSSEC, unicast hosted in Denmark - https://blog.uncensoreddns.org',
+      country: 'Denmark',
+      location: {
+        lat: 55.7123,
+        long: 12.0564
+      }
+    },
+    {
+      name: 'uncensoreddns-ipv4',
+      endpoint: {
+        protocol: 'https:',
+        host: 'anycast.uncensoreddns.org'
+      },
+      description: 'Also known as censurfridns.\nDoH, no logs, no filter, DNSSEC, anycast - https://blog.uncensoreddns.org',
+      country: 'Denmark',
+      location: {
+        lat: 55.7123,
+        long: 12.0564
+      }
+    },
+    {
+      name: 'v.dnscrypt.uk-doh-ipv4',
+      endpoint: {
+        protocol: 'https:',
+        host: 'v.dnscrypt.uk'
+      },
+      description: 'DoH, no logs, uncensored, DNSSEC. Hosted in London UK on Digital Ocean\nhttps://www.dnscrypt.uk',
+      country: 'United Kingdom',
+      location: {
+        lat: 51.4964,
+        long: -0.1224
+      }
+    }
+  ],
+  time: 1654187067783
+};
+
+function processResolvers (res) {
+  const time = (res.time === null || res.time === undefined) ? Date.now() : res.time;
+  const resolvers = processResolvers$1(res.data.map(resolver => {
+    resolver.endpoint = toEndpoint(Object.assign({ name: resolver.name }, resolver.endpoint));
+    return resolver
+  }));
+  const endpoints = resolvers.map(resolver => resolver.endpoint);
+  return {
+    data: {
+      resolvers,
+      resolverByName: resolvers.reduce((byName, resolver) => {
+        byName[resolver.name] = resolver;
+        return byName
+      }, {}),
+      endpoints,
+      endpointByName: endpoints.reduce((byName, endpoint) => {
+        byName[endpoint.name] = endpoint;
+        return byName
+      }, {})
+    },
+    time
+  }
+}
+
+const backup = processResolvers(resolvers);
+
+function toMultiQuery (singleQuery) {
+  const query = Object.assign({
+    type: 'query'
+  }, singleQuery);
+  delete query.question;
+  query.questions = [];
+  if (singleQuery.question) {
+    query.questions.push(singleQuery.question);
+  }
+  return query
+}
+
+function queryOne (endpoint, query, timeout, abortSignal) {
+  if (abortSignal && abortSignal.aborted) {
+    return Promise.reject(new AbortError())
+  }
+  if (endpoint.protocol === 'udp4:' || endpoint.protocol === 'udp6:') {
+    return queryDns()
+  }
+  return queryDoh(endpoint, query, timeout, abortSignal)
+}
+
+function queryDoh (endpoint, query, timeout, abortSignal) {
+  return request(
+    endpoint.url,
+    endpoint.method,
+    encode(Object.assign({
+      flags: RECURSION_DESIRED
+    }, query)),
+    timeout,
+    abortSignal
+  ).then(
+    function (res) {
+      const data = res.data;
+      const response = res.response;
+      let error = res.error;
+      if (error === undefined) {
+        if (data.length === 0) {
+          error = new ResponseError('Empty.');
+        } else {
+          try {
+            const decoded = decode(data);
+            decoded.response = response;
+            return decoded
+          } catch (err) {
+            error = new ResponseError('Invalid packet (cause=' + err.message + ')', err);
+          }
+        }
+      }
+      throw Object.assign(error, { response })
+    }
+  )
+}
+
+const UPDATE_URL = new URL('https://martinheidegger.github.io/dns-query/resolvers.json');
+
+function isNameString (entry) {
+  return /^@/.test(entry)
+}
+
+class Wellknown {
+  constructor (opts) {
+    this.opts = Object.assign({
+      timeout: 5000,
+      update: true,
+      updateURL: UPDATE_URL,
+      persist: false,
+      localStoragePrefix: 'dnsquery_',
+      maxAge: 300000 // 5 minutes
+    }, opts);
+    this._dataP = null;
+  }
+
+  _data (force, outdated) {
+    if (!force && this._dataP !== null) {
+      return this._dataP.then(res => {
+        if (res.time < Date.now() - this.opts.maxAge) {
+          return this._data(true, res)
+        }
+        return res
+      })
+    }
+    this._dataP = (!this.opts.update
+      ? Promise.resolve(backup)
+      : loadJSON(
+        this.opts.updateURL,
+        this.opts.persist
+          ? {
+              name: 'resolvers.json',
+              localStoragePrefix: this.opts.localStoragePrefix,
+              maxTime: Date.now() - this.opts.maxAge
+            }
+          : null,
+        this.opts.timeout
+      )
+        .then(res => processResolvers({
+          data: res.data.resolvers,
+          time: res.time
+        }))
+        .catch(() => outdated || backup)
+    );
+    return this._dataP
+  }
+
+  data () {
+    return this._data(false).then(data => data.data)
+  }
+
+  endpoints (input) {
+    if (input === null || input === undefined) {
+      return this.data().then(data => data.endpoints)
+    }
+    if (input === 'doh') {
+      input = filterDoh;
+    }
+    if (input === 'dns') {
+      input = filterDns;
+    }
+    if (typeof input === 'function') {
+      return this.data().then(data => data.endpoints.filter(input))
+    }
+    if (typeof input === 'string' || typeof input[Symbol.iterator] !== 'function') {
+      return Promise.reject(new Error(`Endpoints (${input}) needs to be iterable (array).`))
+    }
+    input = Array.from(input).filter(Boolean);
+    if (input.findIndex(isNameString) === -1) {
+      try {
+        return Promise.resolve(input.map(toEndpoint))
+      } catch (err) {
+        return Promise.reject(err)
+      }
+    }
+    return this.data().then(data =>
+      input.map(entry => {
+        if (isNameString(entry)) {
+          const found = data.endpointByName[entry.substring(1)];
+          if (!found) {
+            throw new Error(`Endpoint ${entry} is not known.`)
+          }
+          return found
+        }
+        return toEndpoint(entry)
+      })
+    )
+  }
+}
+
+new Wellknown();
+
+function isPromise (input) {
+  if (input === null) {
+    return false
+  }
+  if (typeof input !== 'object') {
+    return false
+  }
+  return typeof input.then === 'function'
+}
+
+function toPromise (input) {
+  return isPromise(input) ? input : Promise.resolve(input)
+}
+
+function query (q, opts) {
+  opts = Object.assign({
+    retries: 5,
+    timeout: 30000 // 30 seconds
+  }, opts);
+  if (!q.question) return Promise.reject(new Error('To request data you need to specify a .question!'))
+  return toPromise(opts.endpoints)
+    .then(endpoints => {
+      if (!Array.isArray(endpoints) || endpoints.length === 0) {
+        throw new Error('No endpoints defined to lookup dns records.')
+      }
+      return queryN(endpoints.map(toEndpoint), toMultiQuery(q), opts)
+    })
+    .then(data => {
+      data.question = data.questions[0];
+      delete data.questions;
+      return data
+    })
+}
+
+function queryN (endpoints, q, opts) {
+  const endpoint = endpoints.length === 1
+    ? endpoints[0]
+    : endpoints[Math.floor(Math.random() * endpoints.length) % endpoints.length];
+  return queryOne(endpoint, q, opts.timeout, opts.signal)
+    .then(
+      data => {
+        // Add the endpoint to give a chance to identify which endpoint returned the result
+        data.endpoint = endpoint.toString();
+        return data
+      },
+      err => {
+        if (err.name === 'AbortError' || opts.retries === 0) {
+          err.endpoint = endpoint.toString();
+          throw err
+        }
+        if (opts.retries > 0) {
+          opts.retries -= 1;
+        }
+        return queryN(endpoints, q, opts)
+      }
+    )
+}
+
+function filterDoh (endpoint) {
+  return endpoint.protocol === 'https:' || endpoint.protocol === 'http:'
+}
+
+function filterDns (endpoint) {
+  return endpoint.protocol === 'udp4:' || endpoint.protocol === 'udp6:'
+}
+
+const log$3 = debug("waku:dns-over-https");
+class DnsOverHttps {
+    /**
+     * Create new Dns-Over-Http DNS client.
+     *
+     * @param endpoints The endpoints for Dns-Over-Https queries;
+     * Defaults to [[DnsOverHttps.DefaultEndpoints]].
+     * @param retries Retries if a given endpoint fails.
+     *
+     * @throws {code: string} If DNS query fails.
+     */
+    constructor(endpoints = DnsOverHttps.DefaultEndpoints, retries = 3) {
+        this.endpoints = endpoints;
+        this.retries = retries;
+    }
+    /**
+     * Resolves a TXT record
+     *
+     * @param domain The domain name
+     *
+     * @throws if the query fails
+     */
+    async resolveTXT(domain) {
+        let answers;
+        try {
+            const res = await query({
+                question: { type: "TXT", name: domain },
+            }, {
+                endpoints: this.endpoints,
+                retries: this.retries,
+            });
+            answers = res.answers;
+        }
+        catch (error) {
+            log$3("query failed: ", error);
+            throw new Error("DNS query failed");
+        }
+        if (!answers)
+            throw new Error(`Could not resolve ${domain}`);
+        const data = answers.map((a) => a.data);
+        const result = [];
+        data.forEach((d) => {
+            if (typeof d === "string") {
+                result.push(d);
+            }
+            else if (Array.isArray(d)) {
+                d.forEach((sd) => {
+                    if (typeof sd === "string") {
+                        result.push(sd);
+                    }
+                    else {
+                        result.push(bytesToUtf8(sd));
+                    }
+                });
+            }
+            else {
+                result.push(bytesToUtf8(d));
+            }
+        });
+        return result;
+    }
+}
+/**
+ * Default endpoints to use for DNS queries.
+ * Taken from https://github.com/martinheidegger/dns-query as static data
+ * to avoid dynamic queries.
+ *
+ * To dynamically retrieve other endpoints, use https://github.com/martinheidegger/dns-query#well-known-endpoints
+ */
+DnsOverHttps.DefaultEndpoints = [
+    toEndpoint({
+        name: "cisco-doh",
+        protocol: "https:",
+        host: "doh.opendns.com",
+        ipv4: "146.112.41.2",
+    }),
+    toEndpoint({
+        name: "cloudflare",
+        protocol: "https:",
+        host: "dns.cloudflare.com",
+        ipv4: "1.0.0.1",
+    }),
+];
+
+var base32$1 = {exports: {}};
+
+/*
+ * [hi-base32]{@link https://github.com/emn178/hi-base32}
+ *
+ * @version 0.5.0
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2015-2018
+ * @license MIT
+ */
+
+(function (module) {
+	/*jslint bitwise: true */
+	(function () {
+
+	  var root = typeof window === 'object' ? window : {};
+	  var NODE_JS = !root.HI_BASE32_NO_NODE_JS && typeof process === 'object' && process.versions && process.versions.node;
+	  if (NODE_JS) {
+	    root = commonjsGlobal;
+	  }
+	  var COMMON_JS = !root.HI_BASE32_NO_COMMON_JS && 'object' === 'object' && module.exports;
+	  var BASE32_ENCODE_CHAR = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'.split('');
+	  var BASE32_DECODE_CHAR = {
+	    'A': 0, 'B': 1, 'C': 2, 'D': 3, 'E': 4, 'F': 5, 'G': 6, 'H': 7, 'I': 8,
+	    'J': 9, 'K': 10, 'L': 11, 'M': 12, 'N': 13, 'O': 14, 'P': 15, 'Q': 16,
+	    'R': 17, 'S': 18, 'T': 19, 'U': 20, 'V': 21, 'W': 22, 'X': 23, 'Y': 24,
+	    'Z': 25, '2': 26, '3': 27, '4': 28, '5': 29, '6': 30, '7': 31
+	  };
+
+	  var blocks = [0, 0, 0, 0, 0, 0, 0, 0];
+
+	  var throwInvalidUtf8 = function (position, partial) {
+	    if (partial.length > 10) {
+	      partial = '...' + partial.substr(-10);
+	    }
+	    var err = new Error('Decoded data is not valid UTF-8.'
+	      + ' Maybe try base32.decode.asBytes()?'
+	      + ' Partial data after reading ' + position + ' bytes: ' + partial + ' <-');
+	    err.position = position;
+	    throw err;
+	  };
+
+	  var toUtf8String = function (bytes) {
+	    var str = '', length = bytes.length, i = 0, followingChars = 0, b, c;
+	    while (i < length) {
+	      b = bytes[i++];
+	      if (b <= 0x7F) {
+	        str += String.fromCharCode(b);
+	        continue;
+	      } else if (b > 0xBF && b <= 0xDF) {
+	        c = b & 0x1F;
+	        followingChars = 1;
+	      } else if (b <= 0xEF) {
+	        c = b & 0x0F;
+	        followingChars = 2;
+	      } else if (b <= 0xF7) {
+	        c = b & 0x07;
+	        followingChars = 3;
+	      } else {
+	        throwInvalidUtf8(i, str);
+	      }
+
+	      for (var j = 0; j < followingChars; ++j) {
+	        b = bytes[i++];
+	        if (b < 0x80 || b > 0xBF) {
+	          throwInvalidUtf8(i, str);
+	        }
+	        c <<= 6;
+	        c += b & 0x3F;
+	      }
+	      if (c >= 0xD800 && c <= 0xDFFF) {
+	        throwInvalidUtf8(i, str);
+	      }
+	      if (c > 0x10FFFF) {
+	        throwInvalidUtf8(i, str);
+	      }
+
+	      if (c <= 0xFFFF) {
+	        str += String.fromCharCode(c);
+	      } else {
+	        c -= 0x10000;
+	        str += String.fromCharCode((c >> 10) + 0xD800);
+	        str += String.fromCharCode((c & 0x3FF) + 0xDC00);
+	      }
+	    }
+	    return str;
+	  };
+
+	  var decodeAsBytes = function (base32Str) {
+	    if (base32Str === '') {
+	      return [];
+	    } else if (!/^[A-Z2-7=]+$/.test(base32Str)) {
+	      throw new Error('Invalid base32 characters');
+	    }
+	    base32Str = base32Str.replace(/=/g, '');
+	    var v1, v2, v3, v4, v5, v6, v7, v8, bytes = [], index = 0, length = base32Str.length;
+
+	    // 4 char to 3 bytes
+	    for (var i = 0, count = length >> 3 << 3; i < count;) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v3 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v4 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v5 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v6 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v7 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v8 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      bytes[index++] = (v1 << 3 | v2 >>> 2) & 255;
+	      bytes[index++] = (v2 << 6 | v3 << 1 | v4 >>> 4) & 255;
+	      bytes[index++] = (v4 << 4 | v5 >>> 1) & 255;
+	      bytes[index++] = (v5 << 7 | v6 << 2 | v7 >>> 3) & 255;
+	      bytes[index++] = (v7 << 5 | v8) & 255;
+	    }
+
+	    // remain bytes
+	    var remain = length - count;
+	    if (remain === 2) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      bytes[index++] = (v1 << 3 | v2 >>> 2) & 255;
+	    } else if (remain === 4) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v3 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v4 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      bytes[index++] = (v1 << 3 | v2 >>> 2) & 255;
+	      bytes[index++] = (v2 << 6 | v3 << 1 | v4 >>> 4) & 255;
+	    } else if (remain === 5) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v3 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v4 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v5 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      bytes[index++] = (v1 << 3 | v2 >>> 2) & 255;
+	      bytes[index++] = (v2 << 6 | v3 << 1 | v4 >>> 4) & 255;
+	      bytes[index++] = (v4 << 4 | v5 >>> 1) & 255;
+	    } else if (remain === 7) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v3 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v4 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v5 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v6 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v7 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      bytes[index++] = (v1 << 3 | v2 >>> 2) & 255;
+	      bytes[index++] = (v2 << 6 | v3 << 1 | v4 >>> 4) & 255;
+	      bytes[index++] = (v4 << 4 | v5 >>> 1) & 255;
+	      bytes[index++] = (v5 << 7 | v6 << 2 | v7 >>> 3) & 255;
+	    }
+	    return bytes;
+	  };
+
+	  var encodeAscii = function (str) {
+	    var v1, v2, v3, v4, v5, base32Str = '', length = str.length;
+	    for (var i = 0, count = parseInt(length / 5) * 5; i < count;) {
+	      v1 = str.charCodeAt(i++);
+	      v2 = str.charCodeAt(i++);
+	      v3 = str.charCodeAt(i++);
+	      v4 = str.charCodeAt(i++);
+	      v5 = str.charCodeAt(i++);
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	        BASE32_ENCODE_CHAR[(v3 << 1 | v4 >>> 7) & 31] +
+	        BASE32_ENCODE_CHAR[(v4 >>> 2) & 31] +
+	        BASE32_ENCODE_CHAR[(v4 << 3 | v5 >>> 5) & 31] +
+	        BASE32_ENCODE_CHAR[v5 & 31];
+	    }
+
+	    // remain char
+	    var remain = length - count;
+	    if (remain === 1) {
+	      v1 = str.charCodeAt(i);
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2) & 31] +
+	        '======';
+	    } else if (remain === 2) {
+	      v1 = str.charCodeAt(i++);
+	      v2 = str.charCodeAt(i);
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 << 4) & 31] +
+	        '====';
+	    } else if (remain === 3) {
+	      v1 = str.charCodeAt(i++);
+	      v2 = str.charCodeAt(i++);
+	      v3 = str.charCodeAt(i);
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	        BASE32_ENCODE_CHAR[(v3 << 1) & 31] +
+	        '===';
+	    } else if (remain === 4) {
+	      v1 = str.charCodeAt(i++);
+	      v2 = str.charCodeAt(i++);
+	      v3 = str.charCodeAt(i++);
+	      v4 = str.charCodeAt(i);
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	        BASE32_ENCODE_CHAR[(v3 << 1 | v4 >>> 7) & 31] +
+	        BASE32_ENCODE_CHAR[(v4 >>> 2) & 31] +
+	        BASE32_ENCODE_CHAR[(v4 << 3) & 31] +
+	        '=';
+	    }
+	    return base32Str;
+	  };
+
+	  var encodeUtf8 = function (str) {
+	    var v1, v2, v3, v4, v5, code, end = false, base32Str = '',
+	      index = 0, i, start = 0, length = str.length;
+	      if (str === '') {
+	        return base32Str;
+	      }
+	    do {
+	      blocks[0] = blocks[5];
+	      blocks[1] = blocks[6];
+	      blocks[2] = blocks[7];
+	      for (i = start; index < length && i < 5; ++index) {
+	        code = str.charCodeAt(index);
+	        if (code < 0x80) {
+	          blocks[i++] = code;
+	        } else if (code < 0x800) {
+	          blocks[i++] = 0xc0 | (code >> 6);
+	          blocks[i++] = 0x80 | (code & 0x3f);
+	        } else if (code < 0xd800 || code >= 0xe000) {
+	          blocks[i++] = 0xe0 | (code >> 12);
+	          blocks[i++] = 0x80 | ((code >> 6) & 0x3f);
+	          blocks[i++] = 0x80 | (code & 0x3f);
+	        } else {
+	          code = 0x10000 + (((code & 0x3ff) << 10) | (str.charCodeAt(++index) & 0x3ff));
+	          blocks[i++] = 0xf0 | (code >> 18);
+	          blocks[i++] = 0x80 | ((code >> 12) & 0x3f);
+	          blocks[i++] = 0x80 | ((code >> 6) & 0x3f);
+	          blocks[i++] = 0x80 | (code & 0x3f);
+	        }
+	      }
+	      start = i - 5;
+	      if (index === length) {
+	        ++index;
+	      }
+	      if (index > length && i < 6) {
+	        end = true;
+	      }
+	      v1 = blocks[0];
+	      if (i > 4) {
+	        v2 = blocks[1];
+	        v3 = blocks[2];
+	        v4 = blocks[3];
+	        v5 = blocks[4];
+	        base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	          BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	          BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	          BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	          BASE32_ENCODE_CHAR[(v3 << 1 | v4 >>> 7) & 31] +
+	          BASE32_ENCODE_CHAR[(v4 >>> 2) & 31] +
+	          BASE32_ENCODE_CHAR[(v4 << 3 | v5 >>> 5) & 31] +
+	          BASE32_ENCODE_CHAR[v5 & 31];
+	      } else if (i === 1) {
+	        base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	          BASE32_ENCODE_CHAR[(v1 << 2) & 31] +
+	          '======';
+	      } else if (i === 2) {
+	        v2 = blocks[1];
+	        base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	          BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	          BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	          BASE32_ENCODE_CHAR[(v2 << 4) & 31] +
+	          '====';
+	      } else if (i === 3) {
+	        v2 = blocks[1];
+	        v3 = blocks[2];
+	        base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	          BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	          BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	          BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	          BASE32_ENCODE_CHAR[(v3 << 1) & 31] +
+	          '===';
+	      } else {
+	        v2 = blocks[1];
+	        v3 = blocks[2];
+	        v4 = blocks[3];
+	        base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	          BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	          BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	          BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	          BASE32_ENCODE_CHAR[(v3 << 1 | v4 >>> 7) & 31] +
+	          BASE32_ENCODE_CHAR[(v4 >>> 2) & 31] +
+	          BASE32_ENCODE_CHAR[(v4 << 3) & 31] +
+	          '=';
+	      }
+	    } while (!end);
+	    return base32Str;
+	  };
+
+	  var encodeBytes = function (bytes) {
+	    var v1, v2, v3, v4, v5, base32Str = '', length = bytes.length;
+	    for (var i = 0, count = parseInt(length / 5) * 5; i < count;) {
+	      v1 = bytes[i++];
+	      v2 = bytes[i++];
+	      v3 = bytes[i++];
+	      v4 = bytes[i++];
+	      v5 = bytes[i++];
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	        BASE32_ENCODE_CHAR[(v3 << 1 | v4 >>> 7) & 31] +
+	        BASE32_ENCODE_CHAR[(v4 >>> 2) & 31] +
+	        BASE32_ENCODE_CHAR[(v4 << 3 | v5 >>> 5) & 31] +
+	        BASE32_ENCODE_CHAR[v5 & 31];
+	    }
+
+	    // remain char
+	    var remain = length - count;
+	    if (remain === 1) {
+	      v1 = bytes[i];
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2) & 31] +
+	        '======';
+	    } else if (remain === 2) {
+	      v1 = bytes[i++];
+	      v2 = bytes[i];
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 << 4) & 31] +
+	        '====';
+	    } else if (remain === 3) {
+	      v1 = bytes[i++];
+	      v2 = bytes[i++];
+	      v3 = bytes[i];
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	        BASE32_ENCODE_CHAR[(v3 << 1) & 31] +
+	        '===';
+	    } else if (remain === 4) {
+	      v1 = bytes[i++];
+	      v2 = bytes[i++];
+	      v3 = bytes[i++];
+	      v4 = bytes[i];
+	      base32Str += BASE32_ENCODE_CHAR[v1 >>> 3] +
+	        BASE32_ENCODE_CHAR[(v1 << 2 | v2 >>> 6) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 >>> 1) & 31] +
+	        BASE32_ENCODE_CHAR[(v2 << 4 | v3 >>> 4) & 31] +
+	        BASE32_ENCODE_CHAR[(v3 << 1 | v4 >>> 7) & 31] +
+	        BASE32_ENCODE_CHAR[(v4 >>> 2) & 31] +
+	        BASE32_ENCODE_CHAR[(v4 << 3) & 31] +
+	        '=';
+	    }
+	    return base32Str;
+	  };
+
+	  var encode = function (input, asciiOnly) {
+	    var notString = typeof(input) !== 'string';
+	    if (notString && input.constructor === ArrayBuffer) {
+	      input = new Uint8Array(input);
+	    }
+	    if (notString) {
+	      return encodeBytes(input);
+	    } else if (asciiOnly) {
+	      return encodeAscii(input);
+	    } else {
+	      return encodeUtf8(input);
+	    }
+	  };
+
+	  var decode = function (base32Str, asciiOnly) {
+	    if (!asciiOnly) {
+	      return toUtf8String(decodeAsBytes(base32Str));
+	    }
+	    if (base32Str === '') {
+	      return '';
+	    } else if (!/^[A-Z2-7=]+$/.test(base32Str)) {
+	      throw new Error('Invalid base32 characters');
+	    }
+	    var v1, v2, v3, v4, v5, v6, v7, v8, str = '', length = base32Str.indexOf('=');
+	    if (length === -1) {
+	      length = base32Str.length;
+	    }
+
+	    // 8 char to 5 bytes
+	    for (var i = 0, count = length >> 3 << 3; i < count;) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v3 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v4 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v5 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v6 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v7 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v8 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      str += String.fromCharCode((v1 << 3 | v2 >>> 2) & 255) +
+	        String.fromCharCode((v2 << 6 | v3 << 1 | v4 >>> 4) & 255) +
+	        String.fromCharCode((v4 << 4 | v5 >>> 1) & 255) +
+	        String.fromCharCode((v5 << 7 | v6 << 2 | v7 >>> 3) & 255) +
+	        String.fromCharCode((v7 << 5 | v8) & 255);
+	    }
+
+	    // remain bytes
+	    var remain = length - count;
+	    if (remain === 2) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      str += String.fromCharCode((v1 << 3 | v2 >>> 2) & 255);
+	    } else if (remain === 4) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v3 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v4 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      str += String.fromCharCode((v1 << 3 | v2 >>> 2) & 255) +
+	        String.fromCharCode((v2 << 6 | v3 << 1 | v4 >>> 4) & 255);
+	    } else if (remain === 5) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v3 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v4 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v5 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      str += String.fromCharCode((v1 << 3 | v2 >>> 2) & 255) +
+	        String.fromCharCode((v2 << 6 | v3 << 1 | v4 >>> 4) & 255) +
+	        String.fromCharCode((v4 << 4 | v5 >>> 1) & 255);
+	    } else if (remain === 7) {
+	      v1 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v2 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v3 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v4 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v5 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v6 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      v7 = BASE32_DECODE_CHAR[base32Str.charAt(i++)];
+	      str += String.fromCharCode((v1 << 3 | v2 >>> 2) & 255) +
+	        String.fromCharCode((v2 << 6 | v3 << 1 | v4 >>> 4) & 255) +
+	        String.fromCharCode((v4 << 4 | v5 >>> 1) & 255) +
+	        String.fromCharCode((v5 << 7 | v6 << 2 | v7 >>> 3) & 255);
+	    }
+	    return str;
+	  };
+
+	  var exports = {
+	    encode: encode,
+	    decode: decode
+	  };
+	  decode.asBytes = decodeAsBytes;
+
+	  if (COMMON_JS) {
+	    module.exports = exports;
+	  } else {
+	    root.base32 = exports;
+	  }
+	})();
+} (base32$1));
+
+var base32 = base32$1.exports;
+
+class ENRTree {
+    /**
+     * Extracts the branch subdomain referenced by a DNS tree root string after verifying
+     * the root record signature with its base32 compressed public key.
+     */
+    static parseAndVerifyRoot(root, publicKey) {
+        if (!root.startsWith(this.ROOT_PREFIX))
+            throw new Error(`ENRTree root entry must start with '${this.ROOT_PREFIX}'`);
+        const rootValues = ENRTree.parseRootValues(root);
+        const decodedPublicKey = base32.decode.asBytes(publicKey);
+        // The signature is a 65-byte secp256k1 over the keccak256 hash
+        // of the record content, excluding the `sig=` part, encoded as URL-safe base64 string
+        // (Trailing recovery bit must be trimmed to pass `ecdsaVerify` method)
+        const signedComponent = root.split(" sig")[0];
+        const signedComponentBuffer = utf8ToBytes(signedComponent);
+        const signatureBuffer = fromString(rootValues.signature, "base64url").slice(0, 64);
+        const isVerified = verifySignature(signatureBuffer, keccak256(signedComponentBuffer), new Uint8Array(decodedPublicKey));
+        if (!isVerified)
+            throw new Error("Unable to verify ENRTree root signature");
+        return rootValues.eRoot;
+    }
+    static parseRootValues(txt) {
+        const matches = txt.match(/^enrtree-root:v1 e=([^ ]+) l=([^ ]+) seq=(\d+) sig=([^ ]+)$/);
+        if (!Array.isArray(matches))
+            throw new Error("Could not parse ENRTree root entry");
+        matches.shift(); // The first entry is the full match
+        const [eRoot, lRoot, seq, signature] = matches;
+        if (!eRoot)
+            throw new Error("Could not parse 'e' value from ENRTree root entry");
+        if (!lRoot)
+            throw new Error("Could not parse 'l' value from ENRTree root entry");
+        if (!seq)
+            throw new Error("Could not parse 'seq' value from ENRTree root entry");
+        if (!signature)
+            throw new Error("Could not parse 'sig' value from ENRTree root entry");
+        return { eRoot, lRoot, seq: Number(seq), signature };
+    }
+    /**
+     * Returns the public key and top level domain of an ENR tree entry.
+     * The domain is the starting point for traversing a set of linked DNS TXT records
+     * and the public key is used to verify the root entry record
+     */
+    static parseTree(tree) {
+        if (!tree.startsWith(this.TREE_PREFIX))
+            throw new Error(`ENRTree tree entry must start with '${this.TREE_PREFIX}'`);
+        const matches = tree.match(/^enrtree:\/\/([^@]+)@(.+)$/);
+        if (!Array.isArray(matches))
+            throw new Error("Could not parse ENRTree tree entry");
+        matches.shift(); // The first entry is the full match
+        const [publicKey, domain] = matches;
+        if (!publicKey)
+            throw new Error("Could not parse public key from ENRTree tree entry");
+        if (!domain)
+            throw new Error("Could not parse domain from ENRTree tree entry");
+        return { publicKey, domain };
+    }
+    /**
+     * Returns subdomains listed in an ENR branch entry. These in turn lead to
+     * either further branch entries or ENR records.
+     */
+    static parseBranch(branch) {
+        if (!branch.startsWith(this.BRANCH_PREFIX))
+            throw new Error(`ENRTree branch entry must start with '${this.BRANCH_PREFIX}'`);
+        return branch.split(this.BRANCH_PREFIX)[1].split(",");
+    }
+}
+ENRTree.RECORD_PREFIX = ENR.RECORD_PREFIX;
+ENRTree.TREE_PREFIX = "enrtree:";
+ENRTree.BRANCH_PREFIX = "enrtree-branch:";
+ENRTree.ROOT_PREFIX = "enrtree-root:";
+
+const log$2 = debug("waku:discovery:fetch_nodes");
+/**
+ * Fetch nodes using passed [[getNode]] until all wanted capabilities are
+ * fulfilled or the number of [[getNode]] call exceeds the sum of
+ * [[wantedNodeCapabilityCount]] plus [[errorTolerance]].
+ */
+async function fetchNodesUntilCapabilitiesFulfilled(wantedNodeCapabilityCount, errorTolerance, getNode) {
+    const wanted = {
+        relay: wantedNodeCapabilityCount.relay ?? 0,
+        store: wantedNodeCapabilityCount.store ?? 0,
+        filter: wantedNodeCapabilityCount.filter ?? 0,
+        lightPush: wantedNodeCapabilityCount.lightPush ?? 0,
+    };
+    const maxSearches = wanted.relay + wanted.store + wanted.filter + wanted.lightPush;
+    const actual = {
+        relay: 0,
+        store: 0,
+        filter: 0,
+        lightPush: 0,
+    };
+    let totalSearches = 0;
+    const peers = [];
+    while (!isSatisfied(wanted, actual) &&
+        totalSearches < maxSearches + errorTolerance) {
+        const peer = await getNode();
+        if (peer && isNewPeer(peer, peers)) {
+            // ENRs without a waku2 key are ignored.
+            if (peer.waku2) {
+                if (helpsSatisfyCapabilities(peer.waku2, wanted, actual)) {
+                    addCapabilities(peer.waku2, actual);
+                    peers.push(peer);
+                }
+            }
+            log$2(`got new peer candidate from DNS address=${peer.nodeId}@${peer.ip}`);
+        }
+        totalSearches++;
+    }
+    return peers;
+}
+/**
+ * Fetch nodes using passed [[getNode]] until all wanted capabilities are
+ * fulfilled or the number of [[getNode]] call exceeds the sum of
+ * [[wantedNodeCapabilityCount]] plus [[errorTolerance]].
+ */
+async function* yieldNodesUntilCapabilitiesFulfilled(wantedNodeCapabilityCount, errorTolerance, getNode) {
+    const wanted = {
+        relay: wantedNodeCapabilityCount.relay ?? 0,
+        store: wantedNodeCapabilityCount.store ?? 0,
+        filter: wantedNodeCapabilityCount.filter ?? 0,
+        lightPush: wantedNodeCapabilityCount.lightPush ?? 0,
+    };
+    const maxSearches = wanted.relay + wanted.store + wanted.filter + wanted.lightPush;
+    const actual = {
+        relay: 0,
+        store: 0,
+        filter: 0,
+        lightPush: 0,
+    };
+    let totalSearches = 0;
+    const peerNodeIds = new Set();
+    while (!isSatisfied(wanted, actual) &&
+        totalSearches < maxSearches + errorTolerance) {
+        const peer = await getNode();
+        if (peer && peer.nodeId && !peerNodeIds.has(peer.nodeId)) {
+            peerNodeIds.add(peer.nodeId);
+            // ENRs without a waku2 key are ignored.
+            if (peer.waku2) {
+                if (helpsSatisfyCapabilities(peer.waku2, wanted, actual)) {
+                    addCapabilities(peer.waku2, actual);
+                    yield peer;
+                }
+            }
+            log$2(`got new peer candidate from DNS address=${peer.nodeId}@${peer.ip}`);
+        }
+        totalSearches++;
+    }
+}
+function isSatisfied(wanted, actual) {
+    return (actual.relay >= wanted.relay &&
+        actual.store >= wanted.store &&
+        actual.filter >= wanted.filter &&
+        actual.lightPush >= wanted.lightPush);
+}
+function isNewPeer(peer, peers) {
+    if (!peer.nodeId)
+        return false;
+    for (const existingPeer of peers) {
+        if (peer.nodeId === existingPeer.nodeId) {
+            return false;
+        }
+    }
+    return true;
+}
+function addCapabilities(node, total) {
+    if (node.relay)
+        total.relay += 1;
+    if (node.store)
+        total.store += 1;
+    if (node.filter)
+        total.filter += 1;
+    if (node.lightPush)
+        total.lightPush += 1;
+}
+/**
+ * Checks if the proposed ENR [[node]] helps satisfy the [[wanted]] capabilities,
+ * considering the [[actual]] capabilities of nodes retrieved so far..
+ *
+ * @throws If the function is called when the wanted capabilities are already fulfilled.
+ */
+function helpsSatisfyCapabilities(node, wanted, actual) {
+    if (isSatisfied(wanted, actual)) {
+        throw "Internal Error: Waku2 wanted capabilities are already fulfilled";
+    }
+    const missing = missingCapabilities(wanted, actual);
+    return ((missing.relay && node.relay) ||
+        (missing.store && node.store) ||
+        (missing.filter && node.filter) ||
+        (missing.lightPush && node.lightPush));
+}
+/**
+ * Return a [[Waku2]] Object for which capabilities are set to true if they are
+ * [[wanted]] yet missing from [[actual]].
+ */
+function missingCapabilities(wanted, actual) {
+    return {
+        relay: actual.relay < wanted.relay,
+        store: actual.store < wanted.store,
+        filter: actual.filter < wanted.filter,
+        lightPush: actual.lightPush < wanted.lightPush,
+    };
+}
+
+const log$1 = debug("waku:discovery:dns");
+class DnsNodeDiscovery {
+    constructor(dns) {
+        this._errorTolerance = 10;
+        this._DNSTreeCache = {};
+        this.dns = dns;
+    }
+    static dnsOverHttp(dnsClient) {
+        if (!dnsClient) {
+            dnsClient = new DnsOverHttps();
+        }
+        return new DnsNodeDiscovery(dnsClient);
+    }
+    /**
+     * Returns a list of verified peers listed in an EIP-1459 DNS tree. Method may
+     * return fewer peers than requested if [[wantedNodeCapabilityCount]] requires
+     * larger quantity of peers than available or the number of errors/duplicate
+     * peers encountered by randomized search exceeds the sum of the fields of
+     * [[wantedNodeCapabilityCount]] plus the [[_errorTolerance]] factor.
+     */
+    async getPeers(enrTreeUrls, wantedNodeCapabilityCount) {
+        const networkIndex = Math.floor(Math.random() * enrTreeUrls.length);
+        const { publicKey, domain } = ENRTree.parseTree(enrTreeUrls[networkIndex]);
+        const context = {
+            domain,
+            publicKey,
+            visits: {},
+        };
+        const peers = await fetchNodesUntilCapabilitiesFulfilled(wantedNodeCapabilityCount, this._errorTolerance, () => this._search(domain, context));
+        log$1("retrieved peers: ", peers.map((peer) => {
+            return {
+                id: peer.peerId?.toString(),
+                multiaddrs: peer.multiaddrs?.map((ma) => ma.toString()),
+            };
+        }));
+        return peers;
+    }
+    /**
+     * {@docInherit getPeers}
+     */
+    async *getNextPeer(enrTreeUrls, wantedNodeCapabilityCount) {
+        const networkIndex = Math.floor(Math.random() * enrTreeUrls.length);
+        const { publicKey, domain } = ENRTree.parseTree(enrTreeUrls[networkIndex]);
+        const context = {
+            domain,
+            publicKey,
+            visits: {},
+        };
+        for await (const peer of yieldNodesUntilCapabilitiesFulfilled(wantedNodeCapabilityCount, this._errorTolerance, () => this._search(domain, context))) {
+            yield peer;
+        }
+    }
+    /**
+     * Runs a recursive, randomized descent of the DNS tree to retrieve a single
+     * ENR record as an ENR. Returns null if parsing or DNS resolution fails.
+     */
+    async _search(subdomain, context) {
+        try {
+            const entry = await this._getTXTRecord(subdomain, context);
+            context.visits[subdomain] = true;
+            let next;
+            let branches;
+            const entryType = getEntryType(entry);
+            try {
+                switch (entryType) {
+                    case ENRTree.ROOT_PREFIX:
+                        next = ENRTree.parseAndVerifyRoot(entry, context.publicKey);
+                        return await this._search(next, context);
+                    case ENRTree.BRANCH_PREFIX:
+                        branches = ENRTree.parseBranch(entry);
+                        next = selectRandomPath(branches, context);
+                        return await this._search(next, context);
+                    case ENRTree.RECORD_PREFIX:
+                        return ENR.decodeTxt(entry);
+                    default:
+                        return null;
+                }
+            }
+            catch (error) {
+                log$1(`Failed to search DNS tree ${entryType} at subdomain ${subdomain}: ${error}`);
+                return null;
+            }
+        }
+        catch (error) {
+            log$1(`Failed to retrieve TXT record at subdomain ${subdomain}: ${error}`);
+            return null;
+        }
+    }
+    /**
+     * Retrieves the TXT record stored at a location from either
+     * this DNS tree cache or via DNS query.
+     *
+     * @throws if the TXT Record contains non-UTF-8 values.
+     */
+    async _getTXTRecord(subdomain, context) {
+        if (this._DNSTreeCache[subdomain]) {
+            return this._DNSTreeCache[subdomain];
+        }
+        // Location is either the top level tree entry host or a subdomain of it.
+        const location = subdomain !== context.domain
+            ? `${subdomain}.${context.domain}`
+            : context.domain;
+        const response = await this.dns.resolveTXT(location);
+        if (!response.length)
+            throw new Error("Received empty result array while fetching TXT record");
+        if (!response[0].length)
+            throw new Error("Received empty TXT record");
+        // Branch entries can be an array of strings of comma delimited subdomains, with
+        // some subdomain strings split across the array elements
+        const result = response.join("");
+        this._DNSTreeCache[subdomain] = result;
+        return result;
+    }
+}
+function getEntryType(entry) {
+    if (entry.startsWith(ENRTree.ROOT_PREFIX))
+        return ENRTree.ROOT_PREFIX;
+    if (entry.startsWith(ENRTree.BRANCH_PREFIX))
+        return ENRTree.BRANCH_PREFIX;
+    if (entry.startsWith(ENRTree.RECORD_PREFIX))
+        return ENRTree.RECORD_PREFIX;
+    return "";
+}
+/**
+ * Returns a randomly selected subdomain string from the list provided by a branch
+ * entry record.
+ *
+ * The client must track subdomains which are already resolved to avoid
+ * going into an infinite loop b/c branch entries can contain
+ * circular references. It’s in the client’s best interest to traverse the
+ * tree in random order.
+ */
+function selectRandomPath(branches, context) {
+    // Identify domains already visited in this traversal of the DNS tree.
+    // Then filter against them to prevent cycles.
+    const circularRefs = {};
+    for (const [idx, subdomain] of branches.entries()) {
+        if (context.visits[subdomain]) {
+            circularRefs[idx] = true;
+        }
+    }
+    // If all possible paths are circular...
+    if (Object.keys(circularRefs).length === branches.length) {
+        throw new Error("Unresolvable circular path detected");
+    }
+    // Randomly select a viable path
+    let index;
+    do {
+        index = Math.floor(Math.random() * branches.length);
+    } while (circularRefs[index]);
+    return branches[index];
+}
+
+const log = debug("waku:peer-discovery-dns");
+/**
+ * Parse options and expose function to return bootstrap peer addresses.
+ *
+ * @throws if an invalid combination of options is passed, see [[BootstrapOptions]] for details.
+ */
+class PeerDiscoveryDns extends EventEmitter {
+    /**
+     * @param enrUrl An EIP-1459 ENR Tree URL. For example:
+     * "enrtree://AOFTICU2XWDULNLZGRMQS4RIZPAZEHYMV4FYHAPW563HNRAOERP7C@test.nodes.vac.dev"
+     * @param wantedNodeCapabilityCount Specifies what node capabilities
+     * (protocol) must be returned.
+     */
+    constructor(enrUrl, wantedNodeCapabilityCount) {
+        super();
+        this._started = false;
+        log("Use following EIP-1459 ENR Tree URL: ", enrUrl);
+        const dns = DnsNodeDiscovery.dnsOverHttp();
+        this.nextPeer = dns.getNextPeer.bind({}, [enrUrl], wantedNodeCapabilityCount);
+    }
+    /**
+     * Start discovery process
+     */
+    async start() {
+        log("Starting peer discovery via dns");
+        this._started = true;
+        for await (const peer of this.nextPeer()) {
+            if (!this._started)
+                return;
+            const peerInfos = multiaddrsToPeerInfo(peer.getFullMultiaddrs());
+            peerInfos.forEach((peerInfo) => {
+                this.dispatchEvent(new CustomEvent("peer", { detail: peerInfo }));
+            });
+        }
+    }
+    /**
+     * Stop emitting events
+     */
+    stop() {
+        this._started = false;
+    }
+    get [symbol]() {
+        return true;
+    }
+    get [Symbol.toStringTag]() {
+        return "@waku/bootstrap";
+    }
+}
+
+export { PeerDiscoveryDns };