dns-message 0.1.0

package/dist/dns-message.js

@@ -0,0 +1,1504 @@
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+
+let t = function(t) {
+  t[t.QUERY = 0] = "QUERY";
+  t[t.RESPONSE = 32768] = "RESPONSE";
+  return t;
+}({});
+
+let e = function(t) {
+  t[t.A = 1] = "A";
+  t[t.NS = 2] = "NS";
+  t[t.CNAME = 5] = "CNAME";
+  t[t.SOA = 6] = "SOA";
+  t[t.NULL = 10] = "NULL";
+  t[t.PTR = 12] = "PTR";
+  t[t.HINFO = 13] = "HINFO";
+  t[t.MX = 15] = "MX";
+  t[t.TXT = 16] = "TXT";
+  t[t.RP = 17] = "RP";
+  t[t.AFSDB = 18] = "AFSDB";
+  t[t.SIG = 24] = "SIG";
+  t[t.KEY = 25] = "KEY";
+  t[t.AAAA = 28] = "AAAA";
+  t[t.LOC = 29] = "LOC";
+  t[t.SRV = 33] = "SRV";
+  t[t.NAPTR = 35] = "NAPTR";
+  t[t.KX = 36] = "KX";
+  t[t.CERT = 37] = "CERT";
+  t[t.DNAME = 39] = "DNAME";
+  t[t.OPT = 41] = "OPT";
+  t[t.APL = 42] = "APL";
+  t[t.DS = 43] = "DS";
+  t[t.SSHFP = 44] = "SSHFP";
+  t[t.IPSECKEY = 45] = "IPSECKEY";
+  t[t.RRSIG = 46] = "RRSIG";
+  t[t.NSEC = 47] = "NSEC";
+  t[t.DNSKEY = 48] = "DNSKEY";
+  t[t.DHCID = 49] = "DHCID";
+  t[t.NSEC3 = 50] = "NSEC3";
+  t[t.NSEC3PARAM = 51] = "NSEC3PARAM";
+  t[t.TLSA = 52] = "TLSA";
+  t[t.HIP = 55] = "HIP";
+  t[t.CDS = 59] = "CDS";
+  t[t.CDNSKEY = 60] = "CDNSKEY";
+  t[t.SVCB = 64] = "SVCB";
+  t[t.HTTPS = 65] = "HTTPS";
+  t[t.SPF = 99] = "SPF";
+  t[t.TKEY = 249] = "TKEY";
+  t[t.TSIG = 250] = "TSIG";
+  t[t.IXFR = 251] = "IXFR";
+  t[t.AXFR = 252] = "AXFR";
+  t[t.ANY = 255] = "ANY";
+  t[t.CAA = 257] = "CAA";
+  t[t.TA = 32768] = "TA";
+  t[t.DLV = 32769] = "DLV";
+  return t;
+}({});
+
+let n = function(t) {
+  t[t.IN = 1] = "IN";
+  t[t.CS = 2] = "CS";
+  t[t.CH = 3] = "CH";
+  t[t.HS = 4] = "HS";
+  t[t.ANY = 255] = "ANY";
+  return t;
+}({});
+
+let r = function(t) {
+  t[t.NOERR = 0] = "NOERR";
+  t[t.FORMERR = 1] = "FORMERR";
+  t[t.SERVFAIL = 2] = "SERVFAIL";
+  t[t.NXDOMAIN = 3] = "NXDOMAIN";
+  t[t.NOTIMP = 4] = "NOTIMP";
+  t[t.REFUSED = 5] = "REFUSED";
+  t[t.YXDOMAIN = 6] = "YXDOMAIN";
+  t[t.YXRRSET = 7] = "YXRRSET";
+  t[t.NXRRSET = 8] = "NXRRSET";
+  t[t.NOTAUTH = 9] = "NOTAUTH";
+  t[t.NOTZONE = 10] = "NOTZONE";
+  t[t.CHECKING_DISABLED = 16] = "CHECKING_DISABLED";
+  t[t.AUTHENTIC_DATA = 32] = "AUTHENTIC_DATA";
+  t[t.RECURSION_AVAILABLE = 128] = "RECURSION_AVAILABLE";
+  t[t.RECURSION_DESIRED = 256] = "RECURSION_DESIRED";
+  t[t.TRUNCATED_RESPONSE = 512] = "TRUNCATED_RESPONSE";
+  t[t.AUTHORITATIVE_ANSWER = 1024] = "AUTHORITATIVE_ANSWER";
+  return t;
+}({});
+
+let s = function(t) {
+  t[t.OPTION_0 = 0] = "OPTION_0";
+  t[t.LLQ = 1] = "LLQ";
+  t[t.UL = 2] = "UL";
+  t[t.NSID = 3] = "NSID";
+  t[t.OPTION_4 = 4] = "OPTION_4";
+  t[t.DAU = 5] = "DAU";
+  t[t.DHU = 6] = "DHU";
+  t[t.N3U = 7] = "N3U";
+  t[t.CLIENT_SUBNET = 8] = "CLIENT_SUBNET";
+  t[t.EXPIRE = 9] = "EXPIRE";
+  t[t.COOKIE = 10] = "COOKIE";
+  t[t.TCP_KEEPALIVE = 11] = "TCP_KEEPALIVE";
+  t[t.PADDING = 12] = "PADDING";
+  t[t.CHAIN = 13] = "CHAIN";
+  t[t.KEY_TAG = 14] = "KEY_TAG";
+  t[t.DEVICEID = 26946] = "DEVICEID";
+  t[t.OPTION_65535 = 65535] = "OPTION_65535";
+  return t;
+}({});
+
+const a = new TextEncoder;
+
+const i = new TextDecoder;
+
+const o = "undefined" != typeof Buffer ? t => Buffer.byteLength(t) : t => {
+  let e = t.length;
+  for (let n = e - 1; n >= 0; n--) {
+    const r = t.charCodeAt(n);
+    if (r > 127 && r <= 2047) {
+      e++;
+    } else if (r > 2047 && r <= 65535) {
+      e += 2;
+    }
+    if (r >= 56320 && r <= 57343) {
+      n--;
+    }
+  }
+  return e;
+};
+
+const c = {
+  bytes(t) {
+    let e = 2;
+    switch (t) {
+     case "":
+     case ".":
+     case "..":
+      return 1;
+
+     default:
+      if ("." === t[0]) {
+        e--;
+      }
+      if ("." === t[t.length - 1]) {
+        e--;
+      }
+      return e + t.replace(/\\\./g, ".").length;
+    }
+  },
+  write(t, e, n) {
+    const r = a.encode(n);
+    for (let n = 46 === r[0] ? 1 : 0, s = 0; n < r.byteLength; n = s + 1) {
+      s = r.indexOf(46, n);
+      while (s > -1 && 92 === r[s - 1]) {
+        s = r.indexOf(46, s + 1);
+      }
+      if (-1 === s) {
+        s = r.byteLength;
+      }
+      if (s === n) {
+        continue;
+      }
+      let a = e + 1;
+      for (let e = n; e < s; e++) {
+        if (92 === r[e] && 46 === r[e + 1]) {
+          e++;
+        }
+        t.setUint8(a++, r[e]);
+      }
+      t.setUint8(e, a - e - 1);
+      e = a;
+      n = s + 1;
+    }
+    return e + 1;
+  },
+  read(t, e) {
+    let {offset: n, length: r} = e;
+    const s = [];
+    while (e.offset - n < r) {
+      const a = t.getUint8(e.offset);
+      advance(e, 1);
+      if (0 === a) {
+        break;
+      } else if (!(192 & a)) {
+        const n = i.decode(sliceView(t, e, a));
+        s.push(n.replace(/\./g, "\\."));
+      } else if (!(192 & ~a)) {
+        const a = e.offset - n;
+        n = e.offset;
+        r = e.length;
+        e.offset = t.getUint16(e.offset - 1) - 49152;
+        e.length = r - a;
+        const i = c.read(t, e);
+        if (i && "." !== i) {
+          s.push(i);
+        }
+        e.offset = n;
+        e.length = r;
+        break;
+      }
+    }
+    return s.join(".") || ".";
+  }
+};
+
+const f = {
+  bytes: t => "string" == typeof t ? o(t) : t.byteLength,
+  write(t, e, n) {
+    const r = "string" == typeof n ? a.encode(n) : n;
+    new Uint8Array(t.buffer, t.byteOffset + e, r.byteLength).set(r);
+    return e += r.byteLength;
+  },
+  read: (t, e) => sliceView(t, e)
+};
+
+const d = {
+  bytes: t => o(t) + 1,
+  write(t, e, n) {
+    const r = a.encode(n);
+    t.setUint8(e++, r.byteLength);
+    return f.write(t, e, r);
+  },
+  read(t, e) {
+    const n = t.getUint8(e.offset);
+    advance(e, 1);
+    return i.decode(sliceView(t, e, n));
+  }
+};
+
+const u = {
+  bytes(t) {
+    const e = [];
+    for (let n = 0; n < t.length; n++) {
+      e[t[n] >> 8] = Math.max(e[t[n] >> 8] || 0, 255 & t[n]);
+    }
+    let n = 0;
+    for (let t = 0; t < e.length; t++) {
+      if (null != e[t]) {
+        n += 2 + Math.ceil((e[t] + 1) / 8);
+      }
+    }
+    return n;
+  },
+  write(t, e, n) {
+    const r = [];
+    for (let t = 0; t < n.length; t++) {
+      (r[n[t] >> 8] || (r[n[t] >> 8] = []))[n[t] >> 3 & 31] |= 1 << 7 - (7 & n[t]);
+    }
+    for (let n = 0; n < r.length; n++) {
+      const s = r[n];
+      if (null != s) {
+        t.setUint8(e++, n);
+        t.setUint8(e++, s.length);
+        for (let n = 0; n < s.length; n++) {
+          t.setUint8(e++, s[n]);
+        }
+      }
+    }
+    return e;
+  },
+  read(t, e) {
+    const {offset: n, length: r} = e;
+    const s = [];
+    while (e.offset - n < r) {
+      const n = t.getUint8(e.offset);
+      const r = t.getUint8(e.offset + 1);
+      for (let a = 0; a < r; a++) {
+        const r = t.getUint8(e.offset + 2 + a);
+        for (let t = 0; t < 8; t++) {
+          if (r & 1 << 7 - t) {
+            s.push(n << 8 | a << 3 | t);
+          }
+        }
+      }
+      advance(e, 2 + r);
+    }
+    return s;
+  }
+};
+
+const l = {
+  bytes: () => 4,
+  write(t, e, n) {
+    const r = n.split(".", 4);
+    for (let n = 0; n < 4; n++) {
+      t.setUint8(e++, parseInt(r[n], 10));
+    }
+    return e;
+  },
+  read(t, e) {
+    const n = Math.min(e.length, 4);
+    const r = new Array(4).fill(0).map((r, s) => s < n ? t.getUint8(e.offset + s) : 0).join(".");
+    advance(e, n);
+    return r;
+  }
+};
+
+const g = {
+  bytes: () => 2,
+  write(t, e, n) {
+    t.setUint16(e, n);
+    return e + 2;
+  },
+  read(t, e) {
+    const n = t.getUint16(e.offset);
+    advance(e, 2);
+    return n;
+  }
+};
+
+const y = {
+  bytes: () => 16,
+  write(t, e, n) {
+    const r = n.indexOf("::");
+    const s = (r > -1 ? n.slice(0, r) : n).split(":");
+    const a = r > -1 ? n.slice(r + 2).split(":") : [];
+    const i = a.length > 0 && a[a.length - 1].includes(".") ? a.pop() : void 0;
+    for (let n = 0; n < s.length; n++) {
+      t.setUint16(e, parseInt(s[n], 16));
+      e += 2;
+    }
+    for (let n = 8 - (s.length + a.length + (i ? 2 : 0)); n > 0; n--) {
+      t.setUint16(e, 0);
+      e += 2;
+    }
+    for (let n = 0; n < a.length; n++) {
+      t.setUint16(e, parseInt(a[n], 16));
+      e += 2;
+    }
+    if (i) {
+      const n = i.split(".", 4).map(t => parseInt(t, 10));
+      t.setUint16(e, n[0] << 8 | n[1]);
+      t.setUint16(e + 2, n[2] << 8 | n[3]);
+      e += 4;
+    }
+    return e;
+  },
+  read(t, e) {
+    let n = "";
+    const r = Math.min(e.length, 16);
+    for (let s = 0; s < r; s += 2) {
+      if (0 !== s) {
+        n += ":";
+      }
+      n += t.getUint16(e.offset + s).toString(16);
+    }
+    advance(e, r);
+    return n.replace(/(^|:)0(:0)*:0(:|$)/, "$1::$3").replace(/:{3,4}/, "::");
+  }
+};
+
+const withRDLength = t => ({
+  bytes: e => t.bytes(e) + 2,
+  write(e, n, r) {
+    const s = n;
+    n = t.write(e, n + 2, r);
+    e.setUint16(s, n - s - 2);
+    return n;
+  },
+  read(e, n) {
+    const {offset: r, length: s} = n;
+    const a = n.length = e.getUint16(n.offset);
+    n.offset += 2;
+    const i = t.read(e, n);
+    n.offset = r + 2 + a;
+    n.length = s;
+    return i;
+  }
+});
+
+const array = t => ({
+  bytes(e) {
+    let n = 0;
+    for (let r = 0; null != e && r < e.length; r++) {
+      n += t.bytes(e[r]);
+    }
+    return n;
+  },
+  write(e, n, r) {
+    for (let s = 0; null != r && s < r.length; s++) {
+      n = t.write(e, n, r[s]);
+    }
+    return n;
+  },
+  read(e, n) {
+    const {offset: r, length: s} = n;
+    const a = [];
+    while (n.offset - r < s) {
+      a.push(t.read(e, n));
+    }
+    return a;
+  }
+});
+
+const advance = (t, e) => {
+  t.offset += e;
+  t.length -= e;
+};
+
+const sliceView = (t, e, n = e.length) => {
+  const r = new Uint8Array(t.buffer, t.byteOffset + e.offset, n);
+  advance(e, n);
+  return r;
+};
+
+const U = 32768;
+
+const h = {
+  bytes: t => c.bytes(t.name) + 4,
+  write(t, e, r) {
+    let s = r.class || n.IN;
+    if (r.qu) {
+      s |= U;
+    }
+    e = c.write(t, e, r.name);
+    t.setUint16(e, r.type);
+    t.setUint16(e + 2, s);
+    return e += 4;
+  },
+  read(t, e) {
+    const r = c.read(t, e);
+    const s = t.getUint16(e.offset);
+    let a = t.getUint16(e.offset + 2) || n.ANY;
+    let i = !1;
+    if (a !== n.ANY && a & U) {
+      a &= -32769;
+      i = !0;
+    }
+    advance(e, 4);
+    return {
+      name: r,
+      type: s,
+      class: a,
+      qu: i
+    };
+  }
+};
+
+let p = function(t) {
+  t[t.v4 = 1] = "v4";
+  t[t.v6 = 2] = "v6";
+  return t;
+}({});
+
+const w = withRDLength({
+  bytes: t => f.bytes(t.data),
+  write: (t, e, n) => f.write(t, e, n.data),
+  read: (t, e) => ({
+    code: s.OPTION_0,
+    data: f.read(t, e)
+  })
+});
+
+const b = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])";
+
+const E = new RegExp(`^${`(?:${b}\\.){3}${b}`}$`);
+
+const A = withRDLength({
+  bytes: t => Math.ceil((t.sourcePrefixLength || 0) / 8) + 4,
+  write(t, e, n) {
+    const r = n.sourcePrefixLength || 0;
+    const s = n.scopePrefixLength || 0;
+    const a = n.family || (E.test(n.ip) ? p.v4 : p.v6);
+    const i = Math.ceil(r / 8);
+    t.setUint16(e, a);
+    t.setUint8(e + 2, r);
+    t.setUint8(e + 3, s);
+    e += 4;
+    const o = ((t, e) => {
+      const n = new ArrayBuffer(t.bytes(e));
+      const r = t.write(new DataView(n), 0, e);
+      return new Uint8Array(n, 0, r);
+    })(a === p.v4 ? l : y, n.ip);
+    for (let n = 0; n < i; n++) {
+      t.setUint8(e++, o[n]);
+    }
+    return e;
+  },
+  read(t, e) {
+    const n = t.getUint16(e.offset);
+    const r = t.getUint8(e.offset + 2);
+    const a = t.getUint8(e.offset + 3);
+    advance(e, 4);
+    return {
+      code: s.CLIENT_SUBNET,
+      family: n,
+      sourcePrefixLength: r,
+      scopePrefixLength: a,
+      ip: n === p.v4 ? l.read(t, e) : y.read(t, e)
+    };
+  }
+});
+
+const S = withRDLength({
+  bytes: t => t.timeout ? 2 : 0,
+  write(t, e, n) {
+    if (n.timeout) {
+      t.setUint16(e, n.timeout);
+      e += 2;
+    }
+    return e;
+  },
+  read(t, e) {
+    if (e.length) {
+      const n = t.getUint16(e.offset);
+      advance(e, 2);
+      return {
+        code: s.TCP_KEEPALIVE,
+        timeout: n
+      };
+    } else {
+      return {
+        code: s.TCP_KEEPALIVE,
+        timeout: void 0
+      };
+    }
+  }
+});
+
+const N = withRDLength({
+  bytes: t => t.length || 0,
+  write: (t, e, n) => e + (n.length || 0),
+  read(t, e) {
+    const {length: n} = e;
+    advance(e, n);
+    return {
+      code: s.PADDING,
+      length: n
+    };
+  }
+});
+
+const T = withRDLength({
+  bytes: t => 2 * t.tags.length,
+  write(t, e, n) {
+    for (let r = 0; r < n.tags.length; r++) {
+      t.setUint16(e, n.tags[r]);
+      e += 2;
+    }
+    return e;
+  },
+  read(t, e) {
+    const {offset: n, length: r} = e;
+    const a = [];
+    while (e.offset - n < r) {
+      a.push(t.getUint16(e.offset));
+      advance(e, 2);
+    }
+    return {
+      code: s.KEY_TAG,
+      tags: a
+    };
+  }
+});
+
+const isUnknownOpt = t => !!t.data;
+
+const I = {
+  bytes(t) {
+    if (isUnknownOpt(t)) {
+      return w.bytes(t) + 2;
+    }
+    switch (t.code) {
+     case s.CLIENT_SUBNET:
+      return A.bytes(t) + 2;
+
+     case s.TCP_KEEPALIVE:
+      return S.bytes(t) + 2;
+
+     case s.PADDING:
+      return N.bytes(t) + 2;
+
+     case s.KEY_TAG:
+      return T.bytes(t) + 2;
+    }
+  },
+  write(t, e, n) {
+    t.setUint16(e, n.code);
+    e += 2;
+    if (isUnknownOpt(n)) {
+      return w.write(t, e, n);
+    }
+    switch (n.code) {
+     case s.CLIENT_SUBNET:
+      return A.write(t, e, n);
+
+     case s.TCP_KEEPALIVE:
+      return S.write(t, e, n);
+
+     case s.PADDING:
+      return N.write(t, e, n);
+
+     case s.KEY_TAG:
+      return T.write(t, e, n);
+    }
+  },
+  read(t, e) {
+    const n = t.getUint16(e.offset);
+    advance(e, 2);
+    switch (n) {
+     case s.CLIENT_SUBNET:
+      return A.read(t, e);
+
+     case s.TCP_KEEPALIVE:
+      return S.read(t, e);
+
+     case s.PADDING:
+      return N.read(t, e);
+
+     case s.KEY_TAG:
+      return T.read(t, e);
+
+     default:
+      const r = w.read(t, e);
+      r.code = n;
+      return r;
+    }
+  }
+};
+
+let P = function(t) {
+  t[t.Mandatory = 0] = "Mandatory";
+  t[t.Alpn = 1] = "Alpn";
+  t[t.NoDefaultAlpn = 2] = "NoDefaultAlpn";
+  t[t.Port = 3] = "Port";
+  t[t.Ipv4Hint = 4] = "Ipv4Hint";
+  t[t.EchConfig = 5] = "EchConfig";
+  t[t.Ipv6Hint = 6] = "Ipv6Hint";
+  t[t.DohPath = 7] = "DohPath";
+  t[t.Odoh = 32769] = "Odoh";
+  return t;
+}({});
+
+const R = withRDLength(array(g));
+
+const D = withRDLength(array(d));
+
+const C = withRDLength(g);
+
+const m = withRDLength(array(l));
+
+const O = withRDLength(array(y));
+
+const L = withRDLength(f);
+
+const x = {
+  bytes(t) {
+    let e = 0;
+    if (null != t.mandatory) {
+      e += R.bytes(t.mandatory) + 2;
+    }
+    if (null != t.alpn) {
+      e += D.bytes(t.alpn) + 2;
+    }
+    if (t["no-default-alpn"]) {
+      e += 4;
+    }
+    if (null != t.port) {
+      e += C.bytes(t.port) + 2;
+    }
+    if (t.ipv4hint) {
+      e += m.bytes(t.ipv4hint) + 2;
+    }
+    if (t.ipv6hint) {
+      e += O.bytes(t.ipv6hint) + 2;
+    }
+    if (t.echconfig) {
+      e += L.bytes(t.echconfig) + 2;
+    }
+    if (t.dohpath) {
+      e += L.bytes(t.dohpath) + 2;
+    }
+    if (t.odoh) {
+      e += L.bytes(t.odoh) + 2;
+    }
+    return e;
+  },
+  write(t, e, n) {
+    if (null != n.mandatory) {
+      t.setUint16(e, P.Mandatory);
+      e = R.write(t, e + 2, n.mandatory);
+    }
+    if (null != n.alpn) {
+      t.setUint16(e, P.Alpn);
+      e = D.write(t, e + 2, n.alpn);
+    }
+    if (n["no-default-alpn"]) {
+      t.setUint16(e, P.NoDefaultAlpn);
+      e += 4;
+    }
+    if (null != n.port) {
+      t.setUint16(e, P.Port);
+      e = C.write(t, e + 2, n.port);
+    }
+    if (n.ipv4hint) {
+      t.setUint16(e, P.Ipv4Hint);
+      e = m.write(t, e + 2, n.ipv4hint);
+    }
+    if (n.ipv6hint) {
+      t.setUint16(e, P.Ipv6Hint);
+      e = O.write(t, e + 2, n.ipv6hint);
+    }
+    if (n.echconfig) {
+      t.setUint16(e, P.EchConfig);
+      e = L.write(t, e + 2, n.echconfig);
+    }
+    if (n.dohpath) {
+      t.setUint16(e, P.DohPath);
+      e = L.write(t, e + 2, n.dohpath);
+    }
+    if (n.odoh) {
+      t.setUint16(e, P.Odoh);
+      e = L.write(t, e + 2, n.odoh);
+    }
+    return e;
+  },
+  read(t, e) {
+    const {length: n, offset: r} = e;
+    const s = {
+      mandatory: void 0,
+      alpn: void 0,
+      "no-default-alpn": !1,
+      port: void 0,
+      ipv4hint: void 0,
+      ipv6hint: void 0,
+      echconfig: void 0,
+      dohpath: void 0,
+      odoh: void 0
+    };
+    while (e.offset - r < n) {
+      const n = t.getUint16(e.offset);
+      advance(e, 2);
+      switch (n) {
+       case P.Mandatory:
+        s.mandatory = R.read(t, e);
+        break;
+
+       case P.Alpn:
+        s.alpn = D.read(t, e);
+        break;
+
+       case P.NoDefaultAlpn:
+        s["no-default-alpn"] = !0;
+        advance(e, 2);
+        break;
+
+       case P.Port:
+        s.port = C.read(t, e);
+        break;
+
+       case P.Ipv4Hint:
+        s.ipv4hint = m.read(t, e);
+        break;
+
+       case P.Ipv6Hint:
+        s.ipv6hint = O.read(t, e);
+        break;
+
+       case P.EchConfig:
+        s.echconfig = L.read(t, e);
+        break;
+
+       case P.DohPath:
+        s.dohpath = i.decode(L.read(t, e));
+        break;
+
+       case P.Odoh:
+        s.odoh = L.read(t, e);
+        break;
+
+       default:
+        L.read(t, e);
+      }
+    }
+    return s;
+  }
+};
+
+const v = withRDLength(f);
+
+const H = withRDLength(c);
+
+const _ = withRDLength(l);
+
+const V = withRDLength(y);
+
+const Y = withRDLength(array(d));
+
+const K = withRDLength({
+  bytes: t => c.bytes(t.target) + 6,
+  write(t, e, n) {
+    t.setUint16(e, n.priority || 0);
+    t.setUint16(e + 2, n.weight || 0);
+    t.setUint16(e + 4, n.port || 0);
+    return c.write(t, e + 6, n.target);
+  },
+  read(t, e) {
+    const n = {
+      priority: 0,
+      weight: 0,
+      port: 0,
+      target: ""
+    };
+    n.priority = t.getUint16(e.offset);
+    n.weight = t.getUint16(e.offset + 2);
+    n.port = t.getUint16(e.offset + 4);
+    advance(e, 6);
+    n.target = c.read(t, e);
+    return n;
+  }
+});
+
+const M = withRDLength({
+  bytes: t => d.bytes(t.cpu) + d.bytes(t.os),
+  write(t, e, n) {
+    e = d.write(t, e, n.cpu);
+    return e = d.write(t, e, n.os);
+  },
+  read: (t, e) => ({
+    cpu: d.read(t, e),
+    os: d.read(t, e)
+  })
+});
+
+const toCaaTag = t => {
+  switch (t) {
+   case "issue":
+   case "issuewild":
+   case "iodef":
+    return t;
+
+   default:
+    return "issue";
+  }
+};
+
+const X = withRDLength({
+  bytes: t => d.bytes(t.tag) + f.bytes(t.value) + 1,
+  write(t, e, n) {
+    let r = n.flags || 0;
+    if (n.issuerCritical) {
+      r = 128;
+    }
+    t.setUint8(e, r);
+    e = d.write(t, e + 1, n.tag);
+    return e = f.write(t, e, n.value);
+  },
+  read(t, e) {
+    const n = t.getUint8(e.offset);
+    advance(e, 1);
+    return {
+      flags: n,
+      tag: toCaaTag(d.read(t, e)),
+      value: f.read(t, e),
+      issuerCritical: !!(128 & n)
+    };
+  }
+});
+
+const F = withRDLength({
+  bytes: t => c.bytes(t.mname) + c.bytes(t.rname) + 20,
+  write(t, e, n) {
+    e = c.write(t, e, n.mname);
+    e = c.write(t, e, n.rname);
+    t.setUint32(e, n.serial || 0);
+    t.setUint32(e + 4, n.refresh || 0);
+    t.setUint32(e + 8, n.retry || 0);
+    t.setUint32(e + 12, n.expire || 0);
+    t.setUint32(e + 16, n.minimum || 0);
+    return e + 20;
+  },
+  read(t, e) {
+    const n = {
+      mname: c.read(t, e),
+      rname: c.read(t, e),
+      serial: t.getUint32(e.offset),
+      refresh: t.getUint32(e.offset + 4),
+      retry: t.getUint32(e.offset + 8),
+      expire: t.getUint32(e.offset + 12),
+      minimum: t.getUint32(e.offset + 16)
+    };
+    e.offset += 20;
+    e.length -= 20;
+    return n;
+  }
+});
+
+const G = withRDLength({
+  bytes: t => c.bytes(t.exchange) + 2,
+  write(t, e, n) {
+    t.setUint16(e, n.preference || 0);
+    return c.write(t, e + 2, n.exchange);
+  },
+  read(t, e) {
+    const n = {
+      preference: t.getUint16(e.offset),
+      exchange: ""
+    };
+    advance(e, 2);
+    n.exchange = c.read(t, e);
+    return n;
+  }
+});
+
+const B = withRDLength({
+  bytes: t => f.bytes(t.key) + 4,
+  write(t, e, n) {
+    t.setUint16(e, n.flags);
+    t.setUint8(e + 2, 3);
+    t.setUint8(e + 3, n.algorithm);
+    return f.write(t, e + 4, n.key);
+  },
+  read(t, e) {
+    const n = t.getUint16(e.offset);
+    const r = t.getUint8(e.offset + 3);
+    advance(e, 4);
+    return {
+      flags: n,
+      algorithm: r,
+      key: f.read(t, e)
+    };
+  }
+});
+
+const k = withRDLength({
+  bytes: t => 18 + c.bytes(t.signersName) + f.bytes(t.signature),
+  write(t, e, n) {
+    t.setUint16(e, n.typeCovered);
+    t.setUint8(e + 2, n.algorithm);
+    t.setUint8(e + 3, n.labels);
+    t.setUint32(e + 4, n.originalTTL);
+    t.setUint32(e + 8, n.expiration);
+    t.setUint32(e + 12, n.inception);
+    t.setUint16(e + 16, n.keyTag);
+    e = c.write(t, e + 18, n.signersName);
+    return e = f.write(t, e, n.signature);
+  },
+  read(t, e) {
+    const n = t.getUint16(e.offset);
+    const r = t.getUint8(e.offset + 2);
+    const s = t.getUint8(e.offset + 3);
+    const a = t.getUint32(e.offset + 4);
+    const i = t.getUint32(e.offset + 8);
+    const o = t.getUint32(e.offset + 12);
+    const d = t.getUint16(e.offset + 16);
+    advance(e, 18);
+    return {
+      typeCovered: n,
+      algorithm: r,
+      labels: s,
+      originalTTL: a,
+      expiration: i,
+      inception: o,
+      keyTag: d,
+      signersName: c.read(t, e),
+      signature: f.read(t, e)
+    };
+  }
+});
+
+const $ = withRDLength({
+  bytes: t => c.bytes(t.mbox) + c.bytes(t.txt),
+  write(t, e, n) {
+    e = c.write(t, e, n.mbox);
+    return e = c.write(t, e, n.txt);
+  },
+  read: (t, e) => ({
+    mbox: c.read(t, e),
+    txt: c.read(t, e)
+  })
+});
+
+const q = withRDLength({
+  bytes: t => c.bytes(t.nextDomain) + u.bytes(t.rrtypes),
+  write(t, e, n) {
+    e = c.write(t, e, n.nextDomain);
+    return e = u.write(t, e, n.rrtypes);
+  },
+  read: (t, e) => ({
+    nextDomain: c.read(t, e),
+    rrtypes: u.read(t, e)
+  })
+});
+
+const Q = withRDLength({
+  bytes: t => d.bytes(t.salt) + d.bytes(t.nextDomain) + u.bytes(t.rrtypes) + 4,
+  write(t, e, n) {
+    t.setUint8(e, n.algorithm);
+    t.setUint8(e + 1, n.flags);
+    t.setUint16(e + 2, n.iterations);
+    e = d.write(t, e + 4, n.salt);
+    e = d.write(t, e, n.nextDomain);
+    return e = u.write(t, e, n.rrtypes);
+  },
+  read(t, e) {
+    const n = t.getUint8(e.offset);
+    const r = t.getUint8(e.offset + 1);
+    const s = t.getUint16(e.offset + 2);
+    advance(e, 4);
+    return {
+      algorithm: n,
+      flags: r,
+      iterations: s,
+      salt: d.read(t, e),
+      nextDomain: d.read(t, e),
+      rrtypes: u.read(t, e)
+    };
+  }
+});
+
+const j = withRDLength({
+  bytes: t => f.bytes(t.fingerprint) + 2,
+  write(t, e, n) {
+    t.setUint8(e, n.algorithm);
+    t.setUint8(e + 1, n.hash);
+    return f.write(t, e + 2, n.fingerprint);
+  },
+  read(t, e) {
+    const n = t.getUint8(e.offset);
+    const r = t.getUint8(e.offset + 1);
+    advance(e, 2);
+    return {
+      algorithm: n,
+      hash: r,
+      fingerprint: f.read(t, e)
+    };
+  }
+});
+
+const z = withRDLength({
+  bytes: t => f.bytes(t.digest) + 4,
+  write(t, e, n) {
+    t.setUint16(e, n.keyTag);
+    t.setUint8(e + 2, n.algorithm);
+    t.setUint8(e + 3, n.digestType);
+    return e = f.write(t, e + 4, n.digest);
+  },
+  read(t, e) {
+    const n = t.getUint16(e.offset);
+    const r = t.getUint8(e.offset + 2);
+    const s = t.getUint8(e.offset + 3);
+    advance(e, 4);
+    return {
+      keyTag: n,
+      algorithm: r,
+      digestType: s,
+      digest: f.read(t, e)
+    };
+  }
+});
+
+const W = withRDLength({
+  bytes: t => d.bytes(t.flags) + d.bytes(t.services) + d.bytes(t.regexp) + c.bytes(t.replacement) + 4,
+  write(t, e, n) {
+    t.setUint16(e, n.order);
+    t.setUint16(e + 2, n.preference);
+    e = d.write(t, e + 4, n.flags);
+    e = d.write(t, e, n.services);
+    e = d.write(t, e, n.regexp);
+    return e = c.write(t, e, n.replacement);
+  },
+  read(t, e) {
+    const n = t.getUint16(e.offset);
+    const r = t.getUint16(e.offset + 2);
+    advance(e, 4);
+    return {
+      order: n,
+      preference: r,
+      flags: d.read(t, e),
+      services: d.read(t, e),
+      regexp: d.read(t, e),
+      replacement: c.read(t, e)
+    };
+  }
+});
+
+const Z = withRDLength({
+  bytes: t => f.bytes(t.certificate) + 3,
+  write(t, e, n) {
+    t.setUint8(e, n.usage);
+    t.setUint8(e + 1, n.selector);
+    t.setUint8(e + 2, n.matchingType);
+    return f.write(t, e + 3, n.certificate);
+  },
+  read(t, e) {
+    const n = t.getUint8(e.offset);
+    const r = t.getUint8(e.offset + 1);
+    const s = t.getUint8(e.offset + 2);
+    advance(e, 3);
+    return {
+      usage: n,
+      selector: r,
+      matchingType: s,
+      certificate: f.read(t, e)
+    };
+  }
+});
+
+const J = withRDLength({
+  bytes: t => c.bytes(t.name) + x.bytes(t.params) + 2,
+  write(t, e, n) {
+    t.setUint16(e, n.priority || 0);
+    e = c.write(t, e + 2, n.name);
+    return e = x.write(t, e, n.params);
+  },
+  read(t, e) {
+    const n = t.getUint16(e.offset);
+    advance(e, 2);
+    return {
+      name: c.read(t, e),
+      priority: n,
+      params: x.read(t, e)
+    };
+  }
+});
+
+const tt = withRDLength(array(I));
+
+const et = 32768;
+
+const nt = {
+  bytes(t) {
+    const n = 8 + c.bytes(t.type === e.OPT ? "." : t.name);
+    switch (t.type) {
+     case e.A:
+      return n + _.bytes(t.data);
+
+     case e.NS:
+      return n + H.bytes(t.data);
+
+     case e.SOA:
+      return n + F.bytes(t.data);
+
+     case e.HINFO:
+      return n + M.bytes(t.data);
+
+     case e.MX:
+      return n + G.bytes(t.data);
+
+     case e.TXT:
+      return n + Y.bytes(t.data);
+
+     case e.RP:
+      return n + $.bytes(t.data);
+
+     case e.AAAA:
+      return n + V.bytes(t.data);
+
+     case e.SRV:
+      return n + K.bytes(t.data);
+
+     case e.NAPTR:
+      return n + W.bytes(t.data);
+
+     case e.OPT:
+      return n + tt.bytes(t.data);
+
+     case e.DS:
+      return n + z.bytes(t.data);
+
+     case e.SSHFP:
+      return n + j.bytes(t.data);
+
+     case e.RRSIG:
+      return n + k.bytes(t.data);
+
+     case e.NSEC:
+      return n + q.bytes(t.data);
+
+     case e.DNSKEY:
+      return n + B.bytes(t.data);
+
+     case e.NSEC3:
+      return n + Q.bytes(t.data);
+
+     case e.TLSA:
+      return n + Z.bytes(t.data);
+
+     case e.SVCB:
+     case e.HTTPS:
+      return n + J.bytes(t.data);
+
+     case e.CAA:
+      return n + X.bytes(t.data);
+
+     default:
+      return n + v.bytes(t.data);
+    }
+  },
+  write(t, n, r) {
+    if (r.type === e.OPT) {
+      n = c.write(t, n, ".");
+      t.setUint16(n, r.type);
+      t.setUint16(n + 2, r.udpPayloadSize || 4096);
+      t.setUint8(n + 4, r.extendedRcode || 0);
+      t.setUint8(n + 5, r.ednsVersion || 0);
+      t.setUint16(n + 6, r.flags || 0);
+      return tt.write(t, n += 8, r.data);
+    }
+    n = c.write(t, n, r.name);
+    t.setUint16(n, r.type);
+    t.setUint16(n + 2, (r.class || 0) | (r.flush ? et : 0));
+    t.setUint32(n + 4, r.ttl || 0);
+    n += 8;
+    switch (r.type) {
+     case e.A:
+      return _.write(t, n, r.data);
+
+     case e.NS:
+      return H.write(t, n, r.data);
+
+     case e.SOA:
+      return F.write(t, n, r.data);
+
+     case e.HINFO:
+      return M.write(t, n, r.data);
+
+     case e.MX:
+      return G.write(t, n, r.data);
+
+     case e.TXT:
+      return Y.write(t, n, r.data);
+
+     case e.RP:
+      return $.write(t, n, r.data);
+
+     case e.AAAA:
+      return V.write(t, n, r.data);
+
+     case e.SRV:
+      return K.write(t, n, r.data);
+
+     case e.NAPTR:
+      return W.write(t, n, r.data);
+
+     case e.DS:
+      return z.write(t, n, r.data);
+
+     case e.SSHFP:
+      return j.write(t, n, r.data);
+
+     case e.RRSIG:
+      return k.write(t, n, r.data);
+
+     case e.NSEC:
+      return q.write(t, n, r.data);
+
+     case e.DNSKEY:
+      return B.write(t, n, r.data);
+
+     case e.NSEC3:
+      return Q.write(t, n, r.data);
+
+     case e.TLSA:
+      return Z.write(t, n, r.data);
+
+     case e.SVCB:
+     case e.HTTPS:
+      return J.write(t, n, r.data);
+
+     case e.CAA:
+      return X.write(t, n, r.data);
+
+     default:
+      return v.write(t, n, r.data);
+    }
+  },
+  read(t, n) {
+    const r = c.read(t, n);
+    const s = t.getUint16(n.offset);
+    if (s === e.OPT) {
+      const e = t.getUint16(n.offset + 2) || 4096;
+      const r = t.getUint8(n.offset + 4);
+      const a = t.getUint8(n.offset + 5);
+      const i = t.getUint16(n.offset + 6);
+      advance(n, 8);
+      return {
+        type: s,
+        udpPayloadSize: e,
+        extendedRcode: r,
+        ednsVersion: a,
+        flags: i,
+        data: tt.read(t, n)
+      };
+    }
+    const a = t.getUint16(n.offset + 2);
+    const i = t.getUint32(n.offset + 4);
+    advance(n, 8);
+    const o = {
+      name: r,
+      type: s,
+      class: -32769 & a,
+      flush: !!(a & et),
+      ttl: i,
+      data: null
+    };
+    switch (o.type) {
+     case e.A:
+      o.data = _.read(t, n);
+      return o;
+
+     case e.NS:
+      o.data = H.read(t, n);
+      return o;
+
+     case e.SOA:
+      o.data = F.read(t, n);
+      return o;
+
+     case e.HINFO:
+      o.data = M.read(t, n);
+      return o;
+
+     case e.MX:
+      o.data = G.read(t, n);
+      return o;
+
+     case e.TXT:
+      o.data = Y.read(t, n);
+      return o;
+
+     case e.RP:
+      o.data = $.read(t, n);
+      return o;
+
+     case e.AAAA:
+      o.data = V.read(t, n);
+      return o;
+
+     case e.SRV:
+      o.data = K.read(t, n);
+      return o;
+
+     case e.NAPTR:
+      o.data = W.read(t, n);
+      return o;
+
+     case e.DS:
+      o.data = z.read(t, n);
+      return o;
+
+     case e.SSHFP:
+      o.data = j.read(t, n);
+      return o;
+
+     case e.RRSIG:
+      o.data = k.read(t, n);
+      return o;
+
+     case e.NSEC:
+      o.data = q.read(t, n);
+      return o;
+
+     case e.DNSKEY:
+      o.data = B.read(t, n);
+      return o;
+
+     case e.NSEC3:
+      o.data = Q.read(t, n);
+      return o;
+
+     case e.TLSA:
+      o.data = Z.read(t, n);
+      return o;
+
+     case e.SVCB:
+     case e.HTTPS:
+      o.data = J.read(t, n);
+      return o;
+
+     case e.CAA:
+      o.data = X.read(t, n);
+      return o;
+
+     default:
+      o.data = v.read(t, n);
+      return o;
+    }
+  }
+};
+
+const readList = (t, e, n, r) => {
+  if (!r) {
+    return;
+  }
+  const {offset: s, length: a} = n;
+  const i = [];
+  for (let o = 0; o < r && n.offset - s < a; o++) {
+    i.push(t.read(e, n));
+  }
+  return i;
+};
+
+const rt = {
+  bytes(t) {
+    const {questions: e, answers: n, authorities: r, additionals: s} = t;
+    let a = 12;
+    let i = 0;
+    for (i = 0; e && i < e.length; i++) {
+      a += h.bytes(e[i]);
+    }
+    for (i = 0; n && i < n.length; i++) {
+      a += nt.bytes(n[i]);
+    }
+    for (i = 0; r && i < r.length; i++) {
+      a += nt.bytes(r[i]);
+    }
+    for (i = 0; s && i < s.length; i++) {
+      a += nt.bytes(s[i]);
+    }
+    return a;
+  },
+  write(e, n, r) {
+    const {questions: s, answers: a, authorities: i, additionals: o} = r;
+    let c = 32767 & (r.flags || 0) | (r.type || t.QUERY) | (r.rtype || 0);
+    e.setUint16(n, r.id || 0);
+    e.setUint16(n + 2, c);
+    e.setUint16(n + 4, r.questions?.length || 0);
+    e.setUint16(n + 6, r.answers?.length || 0);
+    e.setUint16(n + 8, r.authorities?.length || 0);
+    e.setUint16(n + 10, r.additionals?.length || 0);
+    n += 12;
+    let f = 0;
+    for (f = 0; s && f < s.length; f++) {
+      n = h.write(e, n, s[f]);
+    }
+    for (f = 0; a && f < a.length; f++) {
+      n = nt.write(e, n, a[f]);
+    }
+    for (f = 0; i && f < i.length; f++) {
+      n = nt.write(e, n, i[f]);
+    }
+    for (f = 0; o && f < o.length; f++) {
+      n = nt.write(e, n, o[f]);
+    }
+    return n;
+  },
+  read(e, n) {
+    const r = e.getUint16(n.offset);
+    const s = e.getUint16(n.offset + 2);
+    const a = e.getUint16(n.offset + 4);
+    const i = e.getUint16(n.offset + 6);
+    const o = e.getUint16(n.offset + 8);
+    const c = e.getUint16(n.offset + 10);
+    advance(n, 12);
+    return {
+      id: r,
+      flags: s,
+      rtype: 15 & s,
+      type: s & t.RESPONSE ? t.RESPONSE : t.QUERY,
+      questions: readList(h, e, n, a),
+      answers: readList(nt, e, n, i),
+      authorities: readList(nt, e, n, o),
+      additionals: readList(nt, e, n, c)
+    };
+  }
+};
+
+exports.OptCode = s;
+
+exports.PacketFlag = r;
+
+exports.PacketType = t;
+
+exports.RecordClass = n;
+
+exports.RecordType = e;
+
+exports.decode = function decode(t) {
+  const e = "buffer" in t ? new DataView(t.buffer, t.byteOffset, t.byteLength) : new DataView(t);
+  return rt.read(e, {
+    offset: 0,
+    length: e.byteLength
+  });
+};
+
+exports.encode = function encode(t) {
+  const e = new ArrayBuffer(rt.bytes(t));
+  const n = rt.write(new DataView(e), 0, t);
+  return new Uint8Array(e, 0, n);
+};
+
+exports.encodingLength = function encodingLength(t) {
+  return rt.bytes(t);
+};
+
+exports.streamDecode = function streamDecode(t) {
+  const e = "buffer" in t ? new DataView(t.buffer, t.byteOffset, t.byteLength) : new DataView(t);
+  const n = Math.min(e.byteLength, e.getUint16(0)) - 2;
+  return rt.read(e, {
+    offset: 2,
+    length: n
+  });
+};
+
+exports.streamEncode = function streamEncode(t) {
+  const e = new ArrayBuffer(rt.bytes(t) + 2);
+  const n = new DataView(e);
+  const r = rt.write(n, 2, t);
+  n.setUint16(0, r);
+  return new Uint8Array(e, 0, r);
+};
+//# sourceMappingURL=dns-message.js.map