dns-message 1.0.0 → 1.0.1-canary-197f34977c71a09b51a96f1a99eb26e7aa8186a5

package/dist/dns-message.js

@@ -58,7 +58,7 @@ let e = function(t) {
   return t;
 }({});
 
-let n = function(t) {
+let r = function(t) {
   t[t.IN = 1] = "IN";
   t[t.CS = 2] = "CS";
   t[t.CH = 3] = "CH";
@@ -67,7 +67,7 @@ let n = function(t) {
   return t;
 }({});
 
-let r = function(t) {
+let n = function(t) {
   t[t.NOERR = 0] = "NOERR";
   t[t.FORMERR = 1] = "FORMERR";
   t[t.SERVFAIL = 2] = "SERVFAIL";
@@ -115,15 +115,15 @@ 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) {
+  for (let r = e - 1; r >= 0; r--) {
+    const n = t.charCodeAt(r);
+    if (n > 127 && n <= 2047) {
       e++;
-    } else if (r > 2047 && r <= 65535) {
+    } else if (n > 2047 && n <= 65535) {
       e += 2;
     }
-    if (r >= 56320 && r <= 57343) {
-      n--;
+    if (n >= 56320 && n <= 57343) {
+      r--;
     }
   }
   return e;
@@ -145,135 +145,142 @@ const c = {
       if ("." === t[t.length - 1]) {
         e--;
       }
-      return e + t.replace(/\\\./g, ".").length;
+      e += t.replace(/\\\./g, ".").length;
+      if (e > 255) {
+        throw new RangeError(`Name "${t}" is above 255 byte limit.`);
+      }
+      return e;
     }
   },
-  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);
+  write(t, e, r) {
+    const n = a.encode(r);
+    for (let s = 46 === n[0] ? 1 : 0, a = 0; s < n.byteLength; s = a + 1) {
+      a = n.indexOf(46, s);
+      while (a > -1 && 92 === n[a - 1]) {
+        a = n.indexOf(46, a + 1);
       }
-      if (-1 === s) {
-        s = r.byteLength;
+      if (-1 === a) {
+        a = n.byteLength;
       }
-      if (s === n) {
+      if (a === s) {
         continue;
+      } else if (a - s > 63) {
+        throw new RangeError(`Label in "${r}" is above 63 byte limit.`);
       }
-      let a = e + 1;
-      for (let e = n; e < s; e++) {
-        if (92 === r[e] && 46 === r[e + 1]) {
+      let i = e + 1;
+      for (let e = s; e < a; e++) {
+        if (92 === n[e] && 46 === n[e + 1]) {
           e++;
         }
-        t.setUint8(a++, r[e]);
+        t.setUint8(i++, n[e]);
       }
-      t.setUint8(e, a - e - 1);
-      e = a;
-      n = s + 1;
+      t.setUint8(e, i - e - 1);
+      e = i;
+      s = a + 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) {
+    const r = [];
+    let n = e.offset;
+    let s = e;
+    while (1) {
+      const e = t.getUint8(s.offset);
+      if (0 === e) {
+        advance(s, 1);
         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);
+      } else if (!(192 & e)) {
+        advance(s, 1);
+        const n = sliceView(t, s, e);
+        r.push(i.decode(n).replace(/\./g, "\\."));
+      } else {
+        const e = t.getUint16(s.offset) - 49152;
+        advance(s, 2);
+        if (e < n) {
+          s = {
+            offset: n = e,
+            length: 0
+          };
+        } else {
+          advance(s, 2);
+          break;
         }
-        e.offset = n;
-        e.length = r;
-        break;
       }
     }
-    return s.join(".") || ".";
+    return r.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;
+  write(t, e, r) {
+    const n = "string" == typeof r ? a.encode(r) : r;
+    new Uint8Array(t.buffer, t.byteOffset + e, n.byteLength).set(n);
+    return e += n.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);
+  write(t, e, r) {
+    const n = a.encode(r);
+    t.setUint8(e++, n.byteLength);
+    return f.write(t, e, n);
   },
   read(t, e) {
-    const n = t.getUint8(e.offset);
+    const r = t.getUint8(e.offset);
     advance(e, 1);
-    return i.decode(sliceView(t, e, n));
+    return i.decode(sliceView(t, e, r));
   }
 };
 
 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]);
+    for (let r = 0; r < t.length; r++) {
+      e[t[r] >> 8] = Math.max(e[t[r] >> 8] || 0, 255 & t[r]);
     }
-    let n = 0;
+    let r = 0;
     for (let t = 0; t < e.length; t++) {
       if (null != e[t]) {
-        n += 2 + Math.ceil((e[t] + 1) / 8);
+        r += 2 + Math.ceil((e[t] + 1) / 8);
       }
     }
-    return n;
+    return r;
   },
-  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]);
+  write(t, e, r) {
+    const n = [];
+    for (let t = 0; t < r.length; t++) {
+      (n[r[t] >> 8] || (n[r[t] >> 8] = []))[r[t] >> 3 & 31] |= 1 << 7 - (7 & r[t]);
     }
-    for (let n = 0; n < r.length; n++) {
-      const s = r[n];
+    for (let r = 0; r < n.length; r++) {
+      const s = n[r];
       if (null != s) {
-        t.setUint8(e++, n);
+        t.setUint8(e++, r);
         t.setUint8(e++, s.length);
-        for (let n = 0; n < s.length; n++) {
-          t.setUint8(e++, s[n]);
+        for (let r = 0; r < s.length; r++) {
+          t.setUint8(e++, s[r]);
         }
       }
     }
     return e;
   },
   read(t, e) {
-    const {offset: n, length: r} = e;
+    const {offset: r, length: n} = 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);
+    while (e.offset - r < n) {
+      const r = t.getUint8(e.offset);
+      const n = t.getUint8(e.offset + 1);
+      for (let a = 0; a < n; a++) {
+        const n = 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);
+          if (n & 1 << 7 - t) {
+            s.push(r << 8 | a << 3 | t);
           }
         }
       }
-      advance(e, 2 + r);
+      advance(e, 2 + n);
     }
     return s;
   }
@@ -281,155 +288,156 @@ const u = {
 
 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));
+  write(t, e, r) {
+    const n = r.split(".", 4);
+    for (let r = 0; r < 4; r++) {
+      t.setUint8(e++, parseInt(n[r], 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 r = Math.min(e.length, 4);
+    const n = new Array(4).fill(0).map((n, s) => s < r ? t.getUint8(e.offset + s) : 0).join(".");
+    advance(e, r);
+    return n;
   }
 };
 
 const g = {
   bytes: () => 2,
-  write(t, e, n) {
-    t.setUint16(e, n);
+  write(t, e, r) {
+    t.setUint16(e, r);
     return e + 2;
   },
   read(t, e) {
-    const n = t.getUint16(e.offset);
+    const r = t.getUint16(e.offset);
     advance(e, 2);
-    return n;
+    return r;
   }
 };
 
 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(":") : [];
+  write(t, e, r) {
+    const n = r.indexOf("::");
+    const s = (n > -1 ? r.slice(0, n) : r).split(":");
+    const a = n > -1 ? r.slice(n + 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));
+    for (let r = 0; r < s.length; r++) {
+      t.setUint16(e, parseInt(s[r], 16));
       e += 2;
     }
-    for (let n = 8 - (s.length + a.length + (i ? 2 : 0)); n > 0; n--) {
+    for (let r = 8 - (s.length + a.length + (i ? 2 : 0)); r > 0; r--) {
       t.setUint16(e, 0);
       e += 2;
     }
-    for (let n = 0; n < a.length; n++) {
-      t.setUint16(e, parseInt(a[n], 16));
+    for (let r = 0; r < a.length; r++) {
+      t.setUint16(e, parseInt(a[r], 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]);
+      const r = i.split(".", 4).map(t => parseInt(t, 10));
+      t.setUint16(e, r[0] << 8 | r[1]);
+      t.setUint16(e + 2, r[2] << 8 | r[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) {
+    let r = "";
+    const n = Math.min(e.length, 16);
+    for (let s = 0; s < n; s += 2) {
       if (0 !== s) {
-        n += ":";
+        r += ":";
       }
-      n += t.getUint16(e.offset + s).toString(16);
+      r += t.getUint16(e.offset + s).toString(16);
     }
-    advance(e, r);
-    return n.replace(/(^|:)0(:0)*:0(:|$)/, "$1::$3").replace(/:{3,4}/, "::");
+    advance(e, n);
+    return r.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;
+  write(e, r, n) {
+    const s = r;
+    r = t.write(e, r + 2, n);
+    e.setUint16(s, r - s - 2);
+    return r;
   },
-  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;
+  read(e, r) {
+    const {offset: n, length: s} = r;
+    const a = r.length = e.getUint16(r.offset);
+    r.offset += 2;
+    const i = t.read(e, r);
+    r.offset = n + 2 + a;
+    r.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]);
+    let r = 0;
+    for (let n = 0; null != e && n < e.length; n++) {
+      r += t.bytes(e[n]);
     }
-    return n;
+    return r;
   },
-  write(e, n, r) {
-    for (let s = 0; null != r && s < r.length; s++) {
-      n = t.write(e, n, r[s]);
+  write(e, r, n) {
+    for (let s = 0; null != n && s < n.length; s++) {
+      r = t.write(e, r, n[s]);
     }
-    return n;
+    return r;
   },
-  read(e, n) {
-    const {offset: r, length: s} = n;
+  read(e, r) {
+    const {offset: n, length: s} = r;
     const a = [];
-    while (n.offset - r < s) {
-      a.push(t.read(e, n));
+    while (r.offset - n < s) {
+      a.push(t.read(e, r));
     }
     return a;
   }
 });
 
 const advance = (t, e) => {
-  t.offset += e;
-  t.length -= e;
+  t.offset += 0 | e;
+  t.length -= 0 | e;
+  t.length &= ~(t.length >> 31);
 };
 
-const sliceView = (t, e, n = e.length) => {
-  const r = new Uint8Array(t.buffer, t.byteOffset + e.offset, n);
-  advance(e, n);
-  return r;
+const sliceView = (t, e, r = e.length) => {
+  const n = new Uint8Array(t.buffer, t.byteOffset + e.offset, r);
+  advance(e, r);
+  return n;
 };
 
 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) {
+  write(t, e, n) {
+    let s = n.class || r.IN;
+    if (n.qu) {
       s |= U;
     }
-    e = c.write(t, e, r.name);
-    t.setUint16(e, r.type);
+    e = c.write(t, e, n.name);
+    t.setUint16(e, n.type);
     t.setUint16(e + 2, s);
     return e += 4;
   },
   read(t, e) {
-    const r = c.read(t, e);
+    const n = c.read(t, e);
     const s = t.getUint16(e.offset);
-    let a = t.getUint16(e.offset + 2) || n.ANY;
+    let a = t.getUint16(e.offset + 2) || r.ANY;
     let i = !1;
-    if (a !== n.ANY && a & U) {
+    if (a !== r.ANY && a & U) {
       a &= -32769;
       i = !0;
     }
     advance(e, 4);
     return {
-      name: r,
+      name: n,
       type: s,
       class: a,
       qu: i
@@ -437,15 +445,15 @@ const h = {
   }
 };
 
-let p = function(t) {
+let w = function(t) {
   t[t.v4 = 1] = "v4";
   t[t.v6 = 2] = "v6";
   return t;
 }({});
 
-const w = withRDLength({
+const p = withRDLength({
   bytes: t => f.bytes(t.data),
-  write: (t, e, n) => f.write(t, e, n.data),
+  write: (t, e, r) => f.write(t, e, r.data),
   read: (t, e) => ({
     code: s.OPTION_0,
     data: f.read(t, e)
@@ -458,56 +466,56 @@ 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);
+  write(t, e, r) {
+    const n = r.sourcePrefixLength || 0;
+    const s = r.scopePrefixLength || 0;
+    const a = r.family || (E.test(r.ip) ? w.v4 : w.v6);
+    const i = Math.ceil(n / 8);
     t.setUint16(e, a);
-    t.setUint8(e + 2, r);
+    t.setUint8(e + 2, n);
     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]);
+      const r = new ArrayBuffer(t.bytes(e));
+      const n = t.write(new DataView(r), 0, e);
+      return new Uint8Array(r, 0, n);
+    })(a === w.v4 ? l : y, r.ip);
+    for (let r = 0; r < i; r++) {
+      t.setUint8(e++, o[r]);
     }
     return e;
   },
   read(t, e) {
-    const n = t.getUint16(e.offset);
-    const r = t.getUint8(e.offset + 2);
+    const r = t.getUint16(e.offset);
+    const n = t.getUint8(e.offset + 2);
     const a = t.getUint8(e.offset + 3);
     advance(e, 4);
     return {
       code: s.CLIENT_SUBNET,
-      family: n,
-      sourcePrefixLength: r,
+      family: r,
+      sourcePrefixLength: n,
       scopePrefixLength: a,
-      ip: n === p.v4 ? l.read(t, e) : y.read(t, e)
+      ip: r === w.v4 ? l.read(t, e) : y.read(t, e)
     };
   }
 });
 
-const S = withRDLength({
+const N = withRDLength({
   bytes: t => t.timeout ? 2 : 0,
-  write(t, e, n) {
-    if (n.timeout) {
-      t.setUint16(e, n.timeout);
+  write(t, e, r) {
+    if (r.timeout) {
+      t.setUint16(e, r.timeout);
       e += 2;
     }
     return e;
   },
   read(t, e) {
     if (e.length) {
-      const n = t.getUint16(e.offset);
+      const r = t.getUint16(e.offset);
       advance(e, 2);
       return {
         code: s.TCP_KEEPALIVE,
-        timeout: n
+        timeout: r
       };
     } else {
       return {
@@ -518,32 +526,32 @@ const S = withRDLength({
   }
 });
 
-const N = withRDLength({
+const S = withRDLength({
   bytes: t => t.length || 0,
-  write: (t, e, n) => e + (n.length || 0),
+  write: (t, e, r) => e + (r.length || 0),
   read(t, e) {
-    const {length: n} = e;
-    advance(e, n);
+    const {length: r} = e;
+    advance(e, r);
     return {
       code: s.PADDING,
-      length: n
+      length: r
     };
   }
 });
 
 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]);
+  write(t, e, r) {
+    for (let n = 0; n < r.tags.length; n++) {
+      t.setUint16(e, r.tags[n]);
       e += 2;
     }
     return e;
   },
   read(t, e) {
-    const {offset: n, length: r} = e;
+    const {offset: r, length: n} = e;
     const a = [];
-    while (e.offset - n < r) {
+    while (e.offset - r < n) {
       a.push(t.getUint16(e.offset));
       advance(e, 2);
     }
@@ -559,62 +567,62 @@ const isUnknownOpt = t => !!t.data;
 const I = {
   bytes(t) {
     if (isUnknownOpt(t)) {
-      return w.bytes(t) + 2;
+      return p.bytes(t) + 2;
     }
     switch (t.code) {
      case s.CLIENT_SUBNET:
       return A.bytes(t) + 2;
 
      case s.TCP_KEEPALIVE:
-      return S.bytes(t) + 2;
+      return N.bytes(t) + 2;
 
      case s.PADDING:
-      return N.bytes(t) + 2;
+      return S.bytes(t) + 2;
 
      case s.KEY_TAG:
       return T.bytes(t) + 2;
     }
   },
-  write(t, e, n) {
-    t.setUint16(e, n.code);
+  write(t, e, r) {
+    t.setUint16(e, r.code);
     e += 2;
-    if (isUnknownOpt(n)) {
-      return w.write(t, e, n);
+    if (isUnknownOpt(r)) {
+      return p.write(t, e, r);
     }
-    switch (n.code) {
+    switch (r.code) {
      case s.CLIENT_SUBNET:
-      return A.write(t, e, n);
+      return A.write(t, e, r);
 
      case s.TCP_KEEPALIVE:
-      return S.write(t, e, n);
+      return N.write(t, e, r);
 
      case s.PADDING:
-      return N.write(t, e, n);
+      return S.write(t, e, r);
 
      case s.KEY_TAG:
-      return T.write(t, e, n);
+      return T.write(t, e, r);
     }
   },
   read(t, e) {
-    const n = t.getUint16(e.offset);
+    const r = t.getUint16(e.offset);
     advance(e, 2);
-    switch (n) {
+    switch (r) {
      case s.CLIENT_SUBNET:
       return A.read(t, e);
 
      case s.TCP_KEEPALIVE:
-      return S.read(t, e);
+      return N.read(t, e);
 
      case s.PADDING:
-      return N.read(t, e);
+      return S.read(t, e);
 
      case s.KEY_TAG:
       return T.read(t, e);
 
      default:
-      const r = w.read(t, e);
-      r.code = n;
-      return r;
+      const n = p.read(t, e);
+      n.code = r;
+      return n;
     }
   }
 };
@@ -644,7 +652,7 @@ const O = withRDLength(array(y));
 
 const L = withRDLength(f);
 
-const x = {
+const v = {
   bytes(t) {
     let e = 0;
     if (null != t.mandatory) {
@@ -676,47 +684,47 @@ const x = {
     }
     return e;
   },
-  write(t, e, n) {
-    if (null != n.mandatory) {
+  write(t, e, r) {
+    if (null != r.mandatory) {
       t.setUint16(e, P.Mandatory);
-      e = R.write(t, e + 2, n.mandatory);
+      e = R.write(t, e + 2, r.mandatory);
     }
-    if (null != n.alpn) {
+    if (null != r.alpn) {
       t.setUint16(e, P.Alpn);
-      e = D.write(t, e + 2, n.alpn);
+      e = D.write(t, e + 2, r.alpn);
     }
-    if (n["no-default-alpn"]) {
+    if (r["no-default-alpn"]) {
       t.setUint16(e, P.NoDefaultAlpn);
       e += 4;
     }
-    if (null != n.port) {
+    if (null != r.port) {
       t.setUint16(e, P.Port);
-      e = C.write(t, e + 2, n.port);
+      e = C.write(t, e + 2, r.port);
     }
-    if (n.ipv4hint) {
+    if (r.ipv4hint) {
       t.setUint16(e, P.Ipv4Hint);
-      e = m.write(t, e + 2, n.ipv4hint);
+      e = m.write(t, e + 2, r.ipv4hint);
     }
-    if (n.ipv6hint) {
+    if (r.ipv6hint) {
       t.setUint16(e, P.Ipv6Hint);
-      e = O.write(t, e + 2, n.ipv6hint);
+      e = O.write(t, e + 2, r.ipv6hint);
     }
-    if (n.echconfig) {
+    if (r.echconfig) {
       t.setUint16(e, P.EchConfig);
-      e = L.write(t, e + 2, n.echconfig);
+      e = L.write(t, e + 2, r.echconfig);
     }
-    if (n.dohpath) {
+    if (r.dohpath) {
       t.setUint16(e, P.DohPath);
-      e = L.write(t, e + 2, n.dohpath);
+      e = L.write(t, e + 2, r.dohpath);
     }
-    if (n.odoh) {
+    if (r.odoh) {
       t.setUint16(e, P.Odoh);
-      e = L.write(t, e + 2, n.odoh);
+      e = L.write(t, e + 2, r.odoh);
     }
     return e;
   },
   read(t, e) {
-    const {length: n, offset: r} = e;
+    const {length: r, offset: n} = e;
     const s = {
       mandatory: void 0,
       alpn: void 0,
@@ -728,10 +736,10 @@ const x = {
       dohpath: void 0,
       odoh: void 0
     };
-    while (e.offset - r < n) {
-      const n = t.getUint16(e.offset);
+    while (e.offset - n < r) {
+      const r = t.getUint16(e.offset);
       advance(e, 2);
-      switch (n) {
+      switch (r) {
        case P.Mandatory:
         s.mandatory = R.read(t, e);
         break;
@@ -777,45 +785,45 @@ const x = {
   }
 };
 
-const v = withRDLength(f);
+const x = withRDLength(f);
 
 const H = withRDLength(c);
 
 const _ = withRDLength(l);
 
-const V = withRDLength(y);
+const M = withRDLength(y);
 
-const Y = withRDLength(array(d));
+const V = withRDLength(array(d));
 
-const K = withRDLength({
+const Y = 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);
+  write(t, e, r) {
+    t.setUint16(e, r.priority || 0);
+    t.setUint16(e + 2, r.weight || 0);
+    t.setUint16(e + 4, r.port || 0);
+    return c.write(t, e + 6, r.target);
   },
   read(t, e) {
-    const n = {
+    const r = {
       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);
+    r.priority = t.getUint16(e.offset);
+    r.weight = t.getUint16(e.offset + 2);
+    r.port = t.getUint16(e.offset + 4);
     advance(e, 6);
-    n.target = c.read(t, e);
-    return n;
+    r.target = c.read(t, e);
+    return r;
   }
 });
 
-const M = withRDLength({
+const K = 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);
+  write(t, e, r) {
+    e = d.write(t, e, r.cpu);
+    return e = d.write(t, e, r.os);
   },
   read: (t, e) => ({
     cpu: d.read(t, e),
@@ -837,41 +845,41 @@ const toCaaTag = t => {
 
 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;
+  write(t, e, r) {
+    let n = r.flags || 0;
+    if (r.issuerCritical) {
+      n = 128;
     }
-    t.setUint8(e, r);
-    e = d.write(t, e + 1, n.tag);
-    return e = f.write(t, e, n.value);
+    t.setUint8(e, n);
+    e = d.write(t, e + 1, r.tag);
+    return e = f.write(t, e, r.value);
   },
   read(t, e) {
-    const n = t.getUint8(e.offset);
+    const r = t.getUint8(e.offset);
     advance(e, 1);
     return {
-      flags: n,
+      flags: r,
       tag: toCaaTag(d.read(t, e)),
       value: f.read(t, e),
-      issuerCritical: !!(128 & n)
+      issuerCritical: !!(128 & r)
     };
   }
 });
 
 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);
+  write(t, e, r) {
+    e = c.write(t, e, r.mname);
+    e = c.write(t, e, r.rname);
+    t.setUint32(e, r.serial || 0);
+    t.setUint32(e + 4, r.refresh || 0);
+    t.setUint32(e + 8, r.retry || 0);
+    t.setUint32(e + 12, r.expire || 0);
+    t.setUint32(e + 16, r.minimum || 0);
     return e + 20;
   },
   read(t, e) {
-    const n = {
+    const r = {
       mname: c.read(t, e),
       rname: c.read(t, e),
       serial: t.getUint32(e.offset),
@@ -882,42 +890,42 @@ const F = withRDLength({
     };
     e.offset += 20;
     e.length -= 20;
-    return n;
+    return r;
   }
 });
 
 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);
+  write(t, e, r) {
+    t.setUint16(e, r.preference || 0);
+    return c.write(t, e + 2, r.exchange);
   },
   read(t, e) {
-    const n = {
+    const r = {
       preference: t.getUint16(e.offset),
       exchange: ""
     };
     advance(e, 2);
-    n.exchange = c.read(t, e);
-    return n;
+    r.exchange = c.read(t, e);
+    return r;
   }
 });
 
 const B = withRDLength({
   bytes: t => f.bytes(t.key) + 4,
-  write(t, e, n) {
-    t.setUint16(e, n.flags);
+  write(t, e, r) {
+    t.setUint16(e, r.flags);
     t.setUint8(e + 2, 3);
-    t.setUint8(e + 3, n.algorithm);
-    return f.write(t, e + 4, n.key);
+    t.setUint8(e + 3, r.algorithm);
+    return f.write(t, e + 4, r.key);
   },
   read(t, e) {
-    const n = t.getUint16(e.offset);
-    const r = t.getUint8(e.offset + 3);
+    const r = t.getUint16(e.offset);
+    const n = t.getUint8(e.offset + 3);
     advance(e, 4);
     return {
-      flags: n,
-      algorithm: r,
+      flags: r,
+      algorithm: n,
       key: f.read(t, e)
     };
   }
@@ -925,20 +933,20 @@ const B = withRDLength({
 
 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);
+  write(t, e, r) {
+    t.setUint16(e, r.typeCovered);
+    t.setUint8(e + 2, r.algorithm);
+    t.setUint8(e + 3, r.labels);
+    t.setUint32(e + 4, r.originalTTL);
+    t.setUint32(e + 8, r.expiration);
+    t.setUint32(e + 12, r.inception);
+    t.setUint16(e + 16, r.keyTag);
+    e = c.write(t, e + 18, r.signersName);
+    return e = f.write(t, e, r.signature);
   },
   read(t, e) {
-    const n = t.getUint16(e.offset);
-    const r = t.getUint8(e.offset + 2);
+    const r = t.getUint16(e.offset);
+    const n = 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);
@@ -946,8 +954,8 @@ const k = withRDLength({
     const d = t.getUint16(e.offset + 16);
     advance(e, 18);
     return {
-      typeCovered: n,
-      algorithm: r,
+      typeCovered: r,
+      algorithm: n,
       labels: s,
       originalTTL: a,
       expiration: i,
@@ -961,9 +969,9 @@ const k = withRDLength({
 
 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);
+  write(t, e, r) {
+    e = c.write(t, e, r.mbox);
+    return e = c.write(t, e, r.txt);
   },
   read: (t, e) => ({
     mbox: c.read(t, e),
@@ -973,9 +981,9 @@ const $ = withRDLength({
 
 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);
+  write(t, e, r) {
+    e = c.write(t, e, r.nextDomain);
+    return e = u.write(t, e, r.rrtypes);
   },
   read: (t, e) => ({
     nextDomain: c.read(t, e),
@@ -985,22 +993,22 @@ const q = withRDLength({
 
 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);
+  write(t, e, r) {
+    t.setUint8(e, r.algorithm);
+    t.setUint8(e + 1, r.flags);
+    t.setUint16(e + 2, r.iterations);
+    e = d.write(t, e + 4, r.salt);
+    e = d.write(t, e, r.nextDomain);
+    return e = u.write(t, e, r.rrtypes);
   },
   read(t, e) {
-    const n = t.getUint8(e.offset);
-    const r = t.getUint8(e.offset + 1);
+    const r = t.getUint8(e.offset);
+    const n = t.getUint8(e.offset + 1);
     const s = t.getUint16(e.offset + 2);
     advance(e, 4);
     return {
-      algorithm: n,
-      flags: r,
+      algorithm: r,
+      flags: n,
       iterations: s,
       salt: d.read(t, e),
       nextDomain: d.read(t, e),
@@ -1011,18 +1019,18 @@ const Q = withRDLength({
 
 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);
+  write(t, e, r) {
+    t.setUint8(e, r.algorithm);
+    t.setUint8(e + 1, r.hash);
+    return f.write(t, e + 2, r.fingerprint);
   },
   read(t, e) {
-    const n = t.getUint8(e.offset);
-    const r = t.getUint8(e.offset + 1);
+    const r = t.getUint8(e.offset);
+    const n = t.getUint8(e.offset + 1);
     advance(e, 2);
     return {
-      algorithm: n,
-      hash: r,
+      algorithm: r,
+      hash: n,
       fingerprint: f.read(t, e)
     };
   }
@@ -1030,20 +1038,20 @@ const j = withRDLength({
 
 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);
+  write(t, e, r) {
+    t.setUint16(e, r.keyTag);
+    t.setUint8(e + 2, r.algorithm);
+    t.setUint8(e + 3, r.digestType);
+    return e = f.write(t, e + 4, r.digest);
   },
   read(t, e) {
-    const n = t.getUint16(e.offset);
-    const r = t.getUint8(e.offset + 2);
+    const r = t.getUint16(e.offset);
+    const n = t.getUint8(e.offset + 2);
     const s = t.getUint8(e.offset + 3);
     advance(e, 4);
     return {
-      keyTag: n,
-      algorithm: r,
+      keyTag: r,
+      algorithm: n,
       digestType: s,
       digest: f.read(t, e)
     };
@@ -1052,21 +1060,21 @@ const z = withRDLength({
 
 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);
+  write(t, e, r) {
+    t.setUint16(e, r.order);
+    t.setUint16(e + 2, r.preference);
+    e = d.write(t, e + 4, r.flags);
+    e = d.write(t, e, r.services);
+    e = d.write(t, e, r.regexp);
+    return e = c.write(t, e, r.replacement);
   },
   read(t, e) {
-    const n = t.getUint16(e.offset);
-    const r = t.getUint16(e.offset + 2);
+    const r = t.getUint16(e.offset);
+    const n = t.getUint16(e.offset + 2);
     advance(e, 4);
     return {
-      order: n,
-      preference: r,
+      order: r,
+      preference: n,
       flags: d.read(t, e),
       services: d.read(t, e),
       regexp: d.read(t, e),
@@ -1077,20 +1085,20 @@ const W = withRDLength({
 
 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);
+  write(t, e, r) {
+    t.setUint8(e, r.usage);
+    t.setUint8(e + 1, r.selector);
+    t.setUint8(e + 2, r.matchingType);
+    return f.write(t, e + 3, r.certificate);
   },
   read(t, e) {
-    const n = t.getUint8(e.offset);
-    const r = t.getUint8(e.offset + 1);
+    const r = t.getUint8(e.offset);
+    const n = t.getUint8(e.offset + 1);
     const s = t.getUint8(e.offset + 2);
     advance(e, 3);
     return {
-      usage: n,
-      selector: r,
+      usage: r,
+      selector: n,
       matchingType: s,
       certificate: f.read(t, e)
     };
@@ -1098,19 +1106,19 @@ const Z = withRDLength({
 });
 
 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);
+  bytes: t => c.bytes(t.name) + v.bytes(t.params) + 2,
+  write(t, e, r) {
+    t.setUint16(e, r.priority || 0);
+    e = c.write(t, e + 2, r.name);
+    return e = v.write(t, e, r.params);
   },
   read(t, e) {
-    const n = t.getUint16(e.offset);
+    const r = t.getUint16(e.offset);
     advance(e, 2);
     return {
       name: c.read(t, e),
-      priority: n,
-      params: x.read(t, e)
+      priority: r,
+      params: v.read(t, e)
     };
   }
 });
@@ -1119,176 +1127,186 @@ const tt = withRDLength(array(I));
 
 const et = 32768;
 
-const nt = {
+const rt = {
   bytes(t) {
-    const n = 8 + c.bytes(t.type === e.OPT ? "." : t.name);
+    const r = 8 + c.bytes(t.type === e.OPT ? "." : t.name);
     switch (t.type) {
      case e.A:
-      return n + _.bytes(t.data);
+      return r + _.bytes(t.data);
 
      case e.NS:
-      return n + H.bytes(t.data);
+      return r + H.bytes(t.data);
 
      case e.SOA:
-      return n + F.bytes(t.data);
+      return r + F.bytes(t.data);
 
      case e.HINFO:
-      return n + M.bytes(t.data);
+      return r + K.bytes(t.data);
 
      case e.MX:
-      return n + G.bytes(t.data);
+      return r + G.bytes(t.data);
 
      case e.TXT:
-      return n + Y.bytes(t.data);
+      return r + V.bytes(t.data);
 
      case e.RP:
-      return n + $.bytes(t.data);
+      return r + $.bytes(t.data);
 
      case e.AAAA:
-      return n + V.bytes(t.data);
+      return r + M.bytes(t.data);
 
      case e.SRV:
-      return n + K.bytes(t.data);
+      return r + Y.bytes(t.data);
 
      case e.NAPTR:
-      return n + W.bytes(t.data);
+      return r + W.bytes(t.data);
 
      case e.OPT:
-      return n + tt.bytes(t.data);
+      return r + tt.bytes(t.data);
 
      case e.DS:
-      return n + z.bytes(t.data);
+      return r + z.bytes(t.data);
 
      case e.SSHFP:
-      return n + j.bytes(t.data);
+      return r + j.bytes(t.data);
 
      case e.RRSIG:
-      return n + k.bytes(t.data);
+      return r + k.bytes(t.data);
 
      case e.NSEC:
-      return n + q.bytes(t.data);
+      return r + q.bytes(t.data);
 
      case e.DNSKEY:
-      return n + B.bytes(t.data);
+      return r + B.bytes(t.data);
 
      case e.NSEC3:
-      return n + Q.bytes(t.data);
+      return r + Q.bytes(t.data);
 
      case e.TLSA:
-      return n + Z.bytes(t.data);
+      return r + Z.bytes(t.data);
 
      case e.SVCB:
      case e.HTTPS:
-      return n + J.bytes(t.data);
+      return r + J.bytes(t.data);
 
      case e.CAA:
-      return n + X.bytes(t.data);
+      return r + X.bytes(t.data);
+
+     case e.PTR:
+     case e.CNAME:
+     case e.DNAME:
+      return r + H.bytes(t.data);
 
      default:
-      return n + v.bytes(t.data);
+      return r + x.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) {
+  write(t, r, n) {
+    if (n.type === e.OPT) {
+      r = c.write(t, r, ".");
+      t.setUint16(r, n.type);
+      t.setUint16(r + 2, n.udpPayloadSize || 4096);
+      t.setUint8(r + 4, n.extendedRcode || 0);
+      t.setUint8(r + 5, n.ednsVersion || 0);
+      t.setUint16(r + 6, n.flags || 0);
+      return tt.write(t, r += 8, n.data);
+    }
+    r = c.write(t, r, n.name);
+    t.setUint16(r, n.type);
+    t.setUint16(r + 2, (n.class || 0) | (n.flush ? et : 0));
+    t.setUint32(r + 4, n.ttl || 0);
+    r += 8;
+    switch (n.type) {
      case e.A:
-      return _.write(t, n, r.data);
+      return _.write(t, r, n.data);
 
      case e.NS:
-      return H.write(t, n, r.data);
+      return H.write(t, r, n.data);
 
      case e.SOA:
-      return F.write(t, n, r.data);
+      return F.write(t, r, n.data);
 
      case e.HINFO:
-      return M.write(t, n, r.data);
+      return K.write(t, r, n.data);
 
      case e.MX:
-      return G.write(t, n, r.data);
+      return G.write(t, r, n.data);
 
      case e.TXT:
-      return Y.write(t, n, r.data);
+      return V.write(t, r, n.data);
 
      case e.RP:
-      return $.write(t, n, r.data);
+      return $.write(t, r, n.data);
 
      case e.AAAA:
-      return V.write(t, n, r.data);
+      return M.write(t, r, n.data);
 
      case e.SRV:
-      return K.write(t, n, r.data);
+      return Y.write(t, r, n.data);
 
      case e.NAPTR:
-      return W.write(t, n, r.data);
+      return W.write(t, r, n.data);
 
      case e.DS:
-      return z.write(t, n, r.data);
+      return z.write(t, r, n.data);
 
      case e.SSHFP:
-      return j.write(t, n, r.data);
+      return j.write(t, r, n.data);
 
      case e.RRSIG:
-      return k.write(t, n, r.data);
+      return k.write(t, r, n.data);
 
      case e.NSEC:
-      return q.write(t, n, r.data);
+      return q.write(t, r, n.data);
 
      case e.DNSKEY:
-      return B.write(t, n, r.data);
+      return B.write(t, r, n.data);
 
      case e.NSEC3:
-      return Q.write(t, n, r.data);
+      return Q.write(t, r, n.data);
 
      case e.TLSA:
-      return Z.write(t, n, r.data);
+      return Z.write(t, r, n.data);
 
      case e.SVCB:
      case e.HTTPS:
-      return J.write(t, n, r.data);
+      return J.write(t, r, n.data);
 
      case e.CAA:
-      return X.write(t, n, r.data);
+      return X.write(t, r, n.data);
+
+     case e.PTR:
+     case e.CNAME:
+     case e.DNAME:
+      return H.write(t, r, n.data);
 
      default:
-      return v.write(t, n, r.data);
+      return x.write(t, r, n.data);
     }
   },
-  read(t, n) {
-    const r = c.read(t, n);
-    const s = t.getUint16(n.offset);
+  read(t, r) {
+    const n = c.read(t, r);
+    const s = t.getUint16(r.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);
+      const e = t.getUint16(r.offset + 2) || 4096;
+      const n = t.getUint8(r.offset + 4);
+      const a = t.getUint8(r.offset + 5);
+      const i = t.getUint16(r.offset + 6);
+      advance(r, 8);
       return {
         type: s,
         udpPayloadSize: e,
-        extendedRcode: r,
+        extendedRcode: n,
         ednsVersion: a,
         flags: i,
-        data: tt.read(t, n)
+        data: tt.read(t, r)
       };
     }
-    const a = t.getUint16(n.offset + 2);
-    const i = t.getUint32(n.offset + 4);
-    advance(n, 8);
+    const a = t.getUint16(r.offset + 2);
+    const i = t.getUint32(r.offset + 4);
+    advance(r, 8);
     const o = {
-      name: r,
+      name: n,
       type: s,
       class: -32769 & a,
       flush: !!(a & et),
@@ -1297,208 +1315,214 @@ const nt = {
     };
     switch (o.type) {
      case e.A:
-      o.data = _.read(t, n);
+      o.data = _.read(t, r);
       return o;
 
      case e.NS:
-      o.data = H.read(t, n);
+      o.data = H.read(t, r);
       return o;
 
      case e.SOA:
-      o.data = F.read(t, n);
+      o.data = F.read(t, r);
       return o;
 
      case e.HINFO:
-      o.data = M.read(t, n);
+      o.data = K.read(t, r);
       return o;
 
      case e.MX:
-      o.data = G.read(t, n);
+      o.data = G.read(t, r);
       return o;
 
      case e.TXT:
-      o.data = Y.read(t, n);
+      o.data = V.read(t, r);
       return o;
 
      case e.RP:
-      o.data = $.read(t, n);
+      o.data = $.read(t, r);
       return o;
 
      case e.AAAA:
-      o.data = V.read(t, n);
+      o.data = M.read(t, r);
       return o;
 
      case e.SRV:
-      o.data = K.read(t, n);
+      o.data = Y.read(t, r);
       return o;
 
      case e.NAPTR:
-      o.data = W.read(t, n);
+      o.data = W.read(t, r);
       return o;
 
      case e.DS:
-      o.data = z.read(t, n);
+      o.data = z.read(t, r);
       return o;
 
      case e.SSHFP:
-      o.data = j.read(t, n);
+      o.data = j.read(t, r);
       return o;
 
      case e.RRSIG:
-      o.data = k.read(t, n);
+      o.data = k.read(t, r);
       return o;
 
      case e.NSEC:
-      o.data = q.read(t, n);
+      o.data = q.read(t, r);
       return o;
 
      case e.DNSKEY:
-      o.data = B.read(t, n);
+      o.data = B.read(t, r);
       return o;
 
      case e.NSEC3:
-      o.data = Q.read(t, n);
+      o.data = Q.read(t, r);
       return o;
 
      case e.TLSA:
-      o.data = Z.read(t, n);
+      o.data = Z.read(t, r);
       return o;
 
      case e.SVCB:
      case e.HTTPS:
-      o.data = J.read(t, n);
+      o.data = J.read(t, r);
       return o;
 
      case e.CAA:
-      o.data = X.read(t, n);
+      o.data = X.read(t, r);
+      return o;
+
+     case e.PTR:
+     case e.CNAME:
+     case e.DNAME:
+      o.data = H.read(t, r);
       return o;
 
      default:
-      o.data = v.read(t, n);
+      o.data = x.read(t, r);
       return o;
     }
   }
 };
 
-const readList = (t, e, n, r) => {
-  if (!r) {
+const readList = (t, e, r, n) => {
+  if (!n) {
     return;
   }
-  const {offset: s, length: a} = n;
+  const {offset: s, length: a} = r;
   const i = [];
-  for (let o = 0; o < r && n.offset - s < a; o++) {
-    i.push(t.read(e, n));
+  for (let o = 0; o < n && r.offset - s < a; o++) {
+    i.push(t.read(e, r));
   }
   return i;
 };
 
-const rt = {
+const nt = {
   bytes(t) {
-    const {questions: e, answers: n, authorities: r, additionals: s} = t;
+    const {questions: e, answers: r, authorities: n, 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]);
+      a += rt.bytes(r[i]);
+    }
+    for (i = 0; n && i < n.length; i++) {
+      a += rt.bytes(n[i]);
     }
     for (i = 0; s && i < s.length; i++) {
-      a += nt.bytes(s[i]);
+      a += rt.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;
+  write(e, r, n) {
+    const {questions: s, answers: a, authorities: i, additionals: o} = n;
+    let c = 32767 & (n.flags || 0) | (n.type || t.QUERY) | (n.rtype || 0);
+    e.setUint16(r, n.id || 0);
+    e.setUint16(r + 2, c);
+    e.setUint16(r + 4, n.questions?.length || 0);
+    e.setUint16(r + 6, n.answers?.length || 0);
+    e.setUint16(r + 8, n.authorities?.length || 0);
+    e.setUint16(r + 10, n.additionals?.length || 0);
+    r += 12;
     let f = 0;
     for (f = 0; s && f < s.length; f++) {
-      n = h.write(e, n, s[f]);
+      r = h.write(e, r, s[f]);
     }
     for (f = 0; a && f < a.length; f++) {
-      n = nt.write(e, n, a[f]);
+      r = rt.write(e, r, a[f]);
     }
     for (f = 0; i && f < i.length; f++) {
-      n = nt.write(e, n, i[f]);
+      r = rt.write(e, r, i[f]);
     }
     for (f = 0; o && f < o.length; f++) {
-      n = nt.write(e, n, o[f]);
+      r = rt.write(e, r, o[f]);
     }
-    return n;
+    return r;
   },
-  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);
+  read(e, r) {
+    const n = e.getUint16(r.offset);
+    const s = e.getUint16(r.offset + 2);
+    const a = e.getUint16(r.offset + 4);
+    const i = e.getUint16(r.offset + 6);
+    const o = e.getUint16(r.offset + 8);
+    const c = e.getUint16(r.offset + 10);
+    advance(r, 12);
     return {
-      id: r,
+      id: n,
       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)
+      questions: readList(h, e, r, a),
+      answers: readList(rt, e, r, i),
+      authorities: readList(rt, e, r, o),
+      additionals: readList(rt, e, r, c)
     };
   }
 };
 
 exports.OptCode = s;
 
-exports.PacketFlag = r;
+exports.PacketFlag = n;
 
 exports.PacketType = t;
 
-exports.RecordClass = n;
+exports.RecordClass = r;
 
 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, {
+  return nt.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);
+  const e = new ArrayBuffer(nt.bytes(t));
+  const r = nt.write(new DataView(e), 0, t);
+  return new Uint8Array(e, 0, r);
 };
 
 exports.encodingLength = function encodingLength(t) {
-  return rt.bytes(t);
+  return nt.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, {
+  const r = Math.min(e.byteLength, e.getUint16(0)) - 2;
+  return nt.read(e, {
     offset: 2,
-    length: n
+    length: r
   });
 };
 
 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);
+  const e = new ArrayBuffer(nt.bytes(t) + 2);
+  const r = new DataView(e);
+  const n = nt.write(r, 2, t);
+  r.setUint16(0, n);
+  return new Uint8Array(e, 0, n);
 };
 //# sourceMappingURL=dns-message.js.map