index.js

/*
 * Copyright (c) 2021 RethinkDNS and its authors.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * The MIT License (MIT)
 *
 * Copyright (c) 2016 Mathias Buus
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

//forked with minor changes from https://github.com/mafintosh/dns-packet
"use strict";

import * as types from "./types.js";
import * as rcodes from "./rcodes.js";
import * as opcodes from "./opcodes.js";
import * as classes from "./classes.js";
import * as optioncodes from "./optioncodes.js";
import * as serviceParamKey from "./svcparamkey.js";
import { ip as ip } from "./lib/ip.js";
import { Buffer } from "buffer";

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;

export const name = {};

name.encode = function (str, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(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 = buf.write(list[i], offset + 1);
      buf[offset] = len;
      offset += len + 1;
    }
  }

  buf[offset++] = 0;

  name.encode.bytes = offset - oldOffset;
  return buf;
};

name.encode.bytes = 0;

name.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const list = [];
  const oldOffset = offset;
  let len = buf[offset++];

  if (len === 0) {
    name.decode.bytes = 1;
    return ".";
  }
  if (len >= 0xc0) {
    const res = name.decode(buf, buf.readUInt16BE(offset - 1) - 0xc000);
    name.decode.bytes = 2;
    return res;
  }

  while (len) {
    if (len >= 0xc0) {
      list.push(name.decode(buf, buf.readUInt16BE(offset - 1) - 0xc000));
      offset++;
      break;
    }

    list.push(buf.toString("utf-8", offset, offset + len));
    offset += len;
    len = buf[offset++];
  }

  name.decode.bytes = offset - oldOffset;
  return list.join(".");
};

name.decode.bytes = 0;

name.encodingLength = function (n) {
  if (n === ".") return 1;
  return Buffer.byteLength(n) + 2;
};

const string = {};

string.encode = function (s, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(string.encodingLength(s));
  if (!offset) offset = 0;

  const len = buf.write(s, offset + 1);
  buf[offset] = len;
  string.encode.bytes = len + 1;
  return buf;
};

string.encode.bytes = 0;

string.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const len = buf[offset];
  const s = buf.toString("utf-8", offset + 1, offset + 1 + len);
  string.decode.bytes = len + 1;
  return s;
};

string.decode.bytes = 0;

string.encodingLength = function (s) {
  return Buffer.byteLength(s) + 1;
};

const header = {};

header.encode = function (h, buf, offset) {
  if (!buf) buf = header.encodingLength(h);
  if (!offset) offset = 0;

  const flags = (h.flags || 0) & 32767;
  const type = h.type === "response" ? RESPONSE_FLAG : QUERY_FLAG;

  buf.writeUInt16BE(h.id || 0, offset);
  buf.writeUInt16BE(flags | type, offset + 2);
  buf.writeUInt16BE(h.questions.length, offset + 4);
  buf.writeUInt16BE(h.answers.length, offset + 6);
  buf.writeUInt16BE(h.authorities.length, offset + 8);
  buf.writeUInt16BE(h.additionals.length, offset + 10);

  return buf;
};

header.encode.bytes = 12;

header.decode = function (buf, offset) {
  if (!offset) offset = 0;
  if (buf.length < 12) throw new Error("Header must be 12 bytes");
  const flags = buf.readUInt16BE(offset + 2);

  return {
    id: buf.readUInt16BE(offset),
    type: flags & RESPONSE_FLAG ? "response" : "query",
    flags: flags & 32767,
    flag_qr: ((flags >> 15) & 0x1) === 1,
    opcode: opcodes.toString((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: rcodes.toString(flags & 0xf),
    questions: new Array(buf.readUInt16BE(offset + 4)),
    answers: new Array(buf.readUInt16BE(offset + 6)),
    authorities: new Array(buf.readUInt16BE(offset + 8)),
    additionals: new Array(buf.readUInt16BE(offset + 10)),
  };
};

header.decode.bytes = 12;

header.encodingLength = function () {
  return 12;
};

const runknown = {};
export { runknown as unknown };

runknown.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(runknown.encodingLength(data));
  if (!offset) offset = 0;

  buf.writeUInt16BE(data.length, offset);
  data.copy(buf, offset + 2);

  runknown.encode.bytes = data.length + 2;
  return buf;
};

runknown.encode.bytes = 0;

runknown.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const len = buf.readUInt16BE(offset);
  const data = buf.slice(offset + 2, offset + 2 + len);
  runknown.decode.bytes = len + 2;
  return data;
};

runknown.decode.bytes = 0;

runknown.encodingLength = function (data) {
  return data.length + 2;
};

const rns = {};
export { rns as ns };

rns.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rns.encodingLength(data));
  if (!offset) offset = 0;

  name.encode(data, buf, offset + 2);
  buf.writeUInt16BE(name.encode.bytes, offset);
  rns.encode.bytes = name.encode.bytes + 2;
  return buf;
};

rns.encode.bytes = 0;

rns.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const len = buf.readUInt16BE(offset);
  const dd = name.decode(buf, offset + 2);

  rns.decode.bytes = len + 2;
  return dd;
};

rns.decode.bytes = 0;

rns.encodingLength = function (data) {
  return name.encodingLength(data) + 2;
};

const rsoa = {};
export { rsoa as soa };

rsoa.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(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;
  buf.writeUInt32BE(data.serial || 0, offset);
  offset += 4;
  buf.writeUInt32BE(data.refresh || 0, offset);
  offset += 4;
  buf.writeUInt32BE(data.retry || 0, offset);
  offset += 4;
  buf.writeUInt32BE(data.expire || 0, offset);
  offset += 4;
  buf.writeUInt32BE(data.minimum || 0, offset);
  offset += 4;

  buf.writeUInt16BE(offset - oldOffset - 2, oldOffset);
  rsoa.encode.bytes = offset - oldOffset;
  return buf;
};

rsoa.encode.bytes = 0;

rsoa.decode = function (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 = buf.readUInt32BE(offset);
  offset += 4;
  data.refresh = buf.readUInt32BE(offset);
  offset += 4;
  data.retry = buf.readUInt32BE(offset);
  offset += 4;
  data.expire = buf.readUInt32BE(offset);
  offset += 4;
  data.minimum = buf.readUInt32BE(offset);
  offset += 4;

  rsoa.decode.bytes = offset - oldOffset;
  return data;
};

rsoa.decode.bytes = 0;

rsoa.encodingLength = function (data) {
  return 22 + name.encodingLength(data.mname) + name.encodingLength(data.rname);
};

const rtxt = {};
export { rtxt as txt };

rtxt.encode = function (data, buf, offset) {
  if (!Array.isArray(data)) data = [data];
  for (let i = 0; i < data.length; i++) {
    if (typeof data[i] === "string") {
      data[i] = Buffer.from(data[i]);
    }
    if (!Buffer.isBuffer(data[i])) {
      throw new Error("Must be a Buffer");
    }
  }

  if (!buf) buf = Buffer.allocUnsafe(rtxt.encodingLength(data));
  if (!offset) offset = 0;

  const oldOffset = offset;
  offset += 2;

  data.forEach(function (d) {
    buf[offset++] = d.length;
    d.copy(buf, offset, 0, d.length);
    offset += d.length;
  });

  buf.writeUInt16BE(offset - oldOffset - 2, oldOffset);
  rtxt.encode.bytes = offset - oldOffset;
  return buf;
};

rtxt.encode.bytes = 0;

rtxt.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;
  let remaining = buf.readUInt16BE(offset);
  offset += 2;

  let 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;
};

rtxt.decode.bytes = 0;

rtxt.encodingLength = function (data) {
  if (!Array.isArray(data)) data = [data];
  let length = 2;
  data.forEach(function (buf) {
    if (typeof buf === "string") {
      length += Buffer.byteLength(buf) + 1;
    } else {
      length += buf.length + 1;
    }
  });
  return length;
};

const rnull = {};
export { rnull as null };

rnull.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rnull.encodingLength(data));
  if (!offset) offset = 0;

  if (typeof data === "string") data = Buffer.from(data);
  if (!data) data = Buffer.allocUnsafe(0);

  const oldOffset = offset;
  offset += 2;

  const len = data.length;
  data.copy(buf, offset, 0, len);
  offset += len;

  buf.writeUInt16BE(offset - oldOffset - 2, oldOffset);
  rnull.encode.bytes = offset - oldOffset;
  return buf;
};

rnull.encode.bytes = 0;

rnull.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;
  const len = buf.readUInt16BE(offset);

  offset += 2;

  const data = buf.slice(offset, offset + len);
  offset += len;

  rnull.decode.bytes = offset - oldOffset;
  return data;
};

rnull.decode.bytes = 0;

rnull.encodingLength = function (data) {
  if (!data) return 2;
  return (Buffer.isBuffer(data) ? data.length : Buffer.byteLength(data)) + 2;
};

const rhinfo = {};
export { rhinfo as hinfo };

rhinfo.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(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;
  buf.writeUInt16BE(offset - oldOffset - 2, oldOffset);
  rhinfo.encode.bytes = offset - oldOffset;
  return buf;
};

rhinfo.encode.bytes = 0;

rhinfo.decode = function (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;
};

rhinfo.decode.bytes = 0;

rhinfo.encodingLength = function (data) {
  return string.encodingLength(data.cpu) + string.encodingLength(data.os) + 2;
};

const rptr = {};
const rcname = rptr;
const rdname = rptr;
export { rcname as cname, rdname as dname, rptr as ptr };

rptr.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rptr.encodingLength(data));
  if (!offset) offset = 0;

  name.encode(data, buf, offset + 2);
  buf.writeUInt16BE(name.encode.bytes, offset);
  rptr.encode.bytes = name.encode.bytes + 2;
  return buf;
};

rptr.encode.bytes = 0;

rptr.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const data = name.decode(buf, offset + 2);
  rptr.decode.bytes = name.decode.bytes + 2;
  return data;
};

rptr.decode.bytes = 0;

rptr.encodingLength = function (data) {
  return name.encodingLength(data) + 2;
};

const rsrv = {};
export { rsrv as srv };

rsrv.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rsrv.encodingLength(data));
  if (!offset) offset = 0;

  buf.writeUInt16BE(data.priority || 0, offset + 2);
  buf.writeUInt16BE(data.weight || 0, offset + 4);
  buf.writeUInt16BE(data.port || 0, offset + 6);
  name.encode(data.target, buf, offset + 8);

  const len = name.encode.bytes + 6;
  buf.writeUInt16BE(len, offset);

  rsrv.encode.bytes = len + 2;
  return buf;
};

rsrv.encode.bytes = 0;

rsrv.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const len = buf.readUInt16BE(offset);

  const data = {};
  data.priority = buf.readUInt16BE(offset + 2);
  data.weight = buf.readUInt16BE(offset + 4);
  data.port = buf.readUInt16BE(offset + 6);
  data.target = name.decode(buf, offset + 8);

  rsrv.decode.bytes = len + 2;
  return data;
};

rsrv.decode.bytes = 0;

rsrv.encodingLength = function (data) {
  return 8 + name.encodingLength(data.target);
};

const rcaa = {};
export { rcaa as caa };

rcaa.ISSUER_CRITICAL = 1 << 7;

rcaa.encode = function (data, buf, offset) {
  const len = rcaa.encodingLength(data);

  if (!buf) buf = Buffer.allocUnsafe(rcaa.encodingLength(data));
  if (!offset) offset = 0;

  if (data.issuerCritical) {
    data.flags = rcaa.ISSUER_CRITICAL;
  }

  buf.writeUInt16BE(len - 2, offset);
  offset += 2;
  buf.writeUInt8(data.flags || 0, offset);
  offset += 1;
  string.encode(data.tag, buf, offset);
  offset += string.encode.bytes;
  buf.write(data.value, offset);
  offset += Buffer.byteLength(data.value);

  rcaa.encode.bytes = len;
  return buf;
};

rcaa.encode.bytes = 0;

rcaa.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const len = buf.readUInt16BE(offset);
  offset += 2;

  const oldOffset = offset;
  const data = {};
  data.flags = buf.readUInt8(offset);
  offset += 1;
  data.tag = string.decode(buf, offset);
  offset += string.decode.bytes;
  data.value = buf.toString("utf-8", offset, oldOffset + len);

  data.issuerCritical = !!(data.flags & rcaa.ISSUER_CRITICAL);

  rcaa.decode.bytes = len + 2;

  return data;
};

rcaa.decode.bytes = 0;

rcaa.encodingLength = function (data) {
  return string.encodingLength(data.tag) + string.encodingLength(data.value) +
    2;
};

const rmx = {};
export { rmx as mx };

rmx.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rmx.encodingLength(data));
  if (!offset) offset = 0;

  const oldOffset = offset;
  offset += 2;
  buf.writeUInt16BE(data.preference || 0, offset);
  offset += 2;
  name.encode(data.exchange, buf, offset);
  offset += name.encode.bytes;

  buf.writeUInt16BE(offset - oldOffset - 2, oldOffset);
  rmx.encode.bytes = offset - oldOffset;
  return buf;
};

rmx.encode.bytes = 0;

rmx.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const oldOffset = offset;

  const data = {};
  offset += 2;
  data.preference = buf.readUInt16BE(offset);
  offset += 2;
  data.exchange = name.decode(buf, offset);
  offset += name.decode.bytes;

  rmx.decode.bytes = offset - oldOffset;
  return data;
};

rmx.encodingLength = function (data) {
  return 4 + name.encodingLength(data.exchange);
};

const ra = {};
export { ra as a };

ra.encode = function (host, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(ra.encodingLength(host));
  if (!offset) offset = 0;

  buf.writeUInt16BE(4, offset);
  offset += 2;
  ip.toBuffer(host, buf, offset);
  ra.encode.bytes = 6;
  return buf;
};

ra.encode.bytes = 0;

ra.decode = function (buf, offset) {
  if (!offset) offset = 0;

  offset += 2;
  const host = ip.toString(buf, offset, 4);
  ra.decode.bytes = 6;
  return host;
};

ra.decode.bytes = 0;

ra.encodingLength = function () {
  return 6;
};

const raaaa = {};
export { raaaa as aaaa };

raaaa.encode = function (host, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(raaaa.encodingLength(host));
  if (!offset) offset = 0;

  buf.writeUInt16BE(16, offset);
  offset += 2;
  ip.toBuffer(host, buf, offset);
  raaaa.encode.bytes = 18;
  return buf;
};

raaaa.encode.bytes = 0;

raaaa.decode = function (buf, offset) {
  if (!offset) offset = 0;

  offset += 2;
  const host = ip.toString(buf, offset, 16);
  raaaa.decode.bytes = 18;
  return host;
};

raaaa.decode.bytes = 0;

raaaa.encodingLength = function () {
  return 18;
};

const roption = {};
export { roption as option };

roption.encode = function (option, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(roption.encodingLength(option));
  if (!offset) offset = 0;
  const oldOffset = offset;

  const code = optioncodes.toCode(option.code);
  buf.writeUInt16BE(code, offset);
  offset += 2;
  if (option.data) {
    buf.writeUInt16BE(option.data.length, offset);
    offset += 2;
    option.data.copy(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 || (ip.isV4Format(option.ip) ? 1 : 2);
        const ipBuf = ip.toBuffer(option.ip);
        const ipLen = Math.ceil(spl / 8);
        buf.writeUInt16BE(ipLen + 4, offset);
        offset += 2;
        buf.writeUInt16BE(fam, offset);
        offset += 2;
        buf.writeUInt8(spl, offset++);
        buf.writeUInt8(option.scopePrefixLength || 0, offset++);

        ipBuf.copy(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) {
          buf.writeUInt16BE(2, offset);
          offset += 2;
          buf.writeUInt16BE(option.timeout, offset);
          offset += 2;
        } else {
          buf.writeUInt16BE(0, offset);
          offset += 2;
        }
        break;
      case 12: // PADDING
        const len = option.length || 0;
        buf.writeUInt16BE(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;
        buf.writeUInt16BE(tagsLen, offset);
        offset += 2;
        for (const tag of option.tags) {
          buf.writeUInt16BE(tag, offset);
          offset += 2;
        }
        break;
      default:
        throw new Error(`Unknown roption code: ${option.code}`);
    }
  }

  roption.encode.bytes = offset - oldOffset;
  return buf;
};

roption.encode.bytes = 0;

roption.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const option = {};
  option.code = buf.readUInt16BE(offset);
  option.type = optioncodes.toString(option.code);
  offset += 2;
  const len = buf.readUInt16BE(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 = buf.readUInt16BE(offset);
      offset += 2;
      option.sourcePrefixLength = buf.readUInt8(offset++);
      option.scopePrefixLength = buf.readUInt8(offset++);
      const padded = Buffer.alloc((option.family === 1) ? 4 : 16);
      buf.copy(padded, 0, offset, offset + len - 4);
      option.ip = ip.toString(padded);
      break;
    // case 12: Padding.  No decode makes sense.
    case 11: // KEEP-ALIVE
      if (len > 0) {
        option.timeout = buf.readUInt16BE(offset);
        offset += 2;
      }
      break;
    case 14:
      option.tags = [];
      for (let i = 0; i < len; i += 2) {
        option.tags.push(buf.readUInt16BE(offset));
        offset += 2;
      }
      // don't worry about default.  caller will use data if desired
  }

  roption.decode.bytes = len + 4;
  return option;
};

roption.decode.bytes = 0;

roption.encodingLength = function (option) {
  if (option.data) {
    return option.data.length + 4;
  }
  const code = optioncodes.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 = {};
export { ropt as opt };

ropt.encode = function (options, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(ropt.encodingLength(options));
  if (!offset) offset = 0;
  const oldOffset = offset;

  const rdlen = encodingLengthList(options, roption);
  buf.writeUInt16BE(rdlen, offset);
  offset = encodeList(options, roption, buf, offset + 2);

  ropt.encode.bytes = offset - oldOffset;
  return buf;
};

ropt.encode.bytes = 0;

ropt.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;

  const options = [];
  let rdlen = buf.readUInt16BE(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;
};

ropt.decode.bytes = 0;

ropt.encodingLength = function (options) {
  return 2 + encodingLengthList(options || [], roption);
};

const rdnskey = {};
export { rdnskey as dnskey };

rdnskey.PROTOCOL_DNSSEC = 3;
rdnskey.ZONE_KEY = 0x80;
rdnskey.SECURE_ENTRYPOINT = 0x8000;

rdnskey.encode = function (key, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rdnskey.encodingLength(key));
  if (!offset) offset = 0;
  const oldOffset = offset;

  const keydata = key.key;
  if (!Buffer.isBuffer(keydata)) {
    throw new Error("Key must be a Buffer");
  }

  offset += 2; // Leave space for length
  buf.writeUInt16BE(key.flags, offset);
  offset += 2;
  buf.writeUInt8(rdnskey.PROTOCOL_DNSSEC, offset);
  offset += 1;
  buf.writeUInt8(key.algorithm, offset);
  offset += 1;
  keydata.copy(buf, offset, 0, keydata.length);
  offset += keydata.length;

  rdnskey.encode.bytes = offset - oldOffset;
  buf.writeUInt16BE(rdnskey.encode.bytes - 2, oldOffset);
  return buf;
};

rdnskey.encode.bytes = 0;

rdnskey.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;

  var key = {};
  var length = buf.readUInt16BE(offset);
  offset += 2;
  key.flags = buf.readUInt16BE(offset);
  offset += 2;
  if (buf.readUInt8(offset) !== rdnskey.PROTOCOL_DNSSEC) {
    throw new Error("Protocol must be 3");
  }
  offset += 1;
  key.algorithm = buf.readUInt8(offset);
  offset += 1;
  key.key = buf.slice(offset, oldOffset + length + 2);
  offset += key.key.length;
  rdnskey.decode.bytes = offset - oldOffset;
  return key;
};

rdnskey.decode.bytes = 0;

rdnskey.encodingLength = function (key) {
  return 6 + Buffer.byteLength(key.key);
};

const rrrsig = {};
export { rrrsig as rrsig };

rrrsig.encode = function (sig, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rrrsig.encodingLength(sig));
  if (!offset) offset = 0;
  const oldOffset = offset;

  const signature = sig.signature;
  if (!Buffer.isBuffer(signature)) {
    throw new Error("Signature must be a Buffer");
  }

  offset += 2; // Leave space for length
  buf.writeUInt16BE(types.toType(sig.typeCovered), offset);
  offset += 2;
  buf.writeUInt8(sig.algorithm, offset);
  offset += 1;
  buf.writeUInt8(sig.labels, offset);
  offset += 1;
  buf.writeUInt32BE(sig.originalTTL, offset);
  offset += 4;
  buf.writeUInt32BE(sig.expiration, offset);
  offset += 4;
  buf.writeUInt32BE(sig.inception, offset);
  offset += 4;
  buf.writeUInt16BE(sig.keyTag, offset);
  offset += 2;
  name.encode(sig.signersName, buf, offset);
  offset += name.encode.bytes;
  signature.copy(buf, offset, 0, signature.length);
  offset += signature.length;

  rrrsig.encode.bytes = offset - oldOffset;
  buf.writeUInt16BE(rrrsig.encode.bytes - 2, oldOffset);
  return buf;
};

rrrsig.encode.bytes = 0;

rrrsig.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;

  var sig = {};
  var length = buf.readUInt16BE(offset);
  offset += 2;
  sig.typeCovered = types.toString(buf.readUInt16BE(offset));
  offset += 2;
  sig.algorithm = buf.readUInt8(offset);
  offset += 1;
  sig.labels = buf.readUInt8(offset);
  offset += 1;
  sig.originalTTL = buf.readUInt32BE(offset);
  offset += 4;
  sig.expiration = buf.readUInt32BE(offset);
  offset += 4;
  sig.inception = buf.readUInt32BE(offset);
  offset += 4;
  sig.keyTag = buf.readUInt16BE(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;
};

rrrsig.decode.bytes = 0;

rrrsig.encodingLength = function (sig) {
  return 20 +
    name.encodingLength(sig.signersName) +
    Buffer.byteLength(sig.signature);
};

const rrp = {};
export { rrp as rp };

rrp.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(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;
  buf.writeUInt16BE(rrp.encode.bytes - 2, oldOffset);
  return buf;
};

rrp.encode.bytes = 0;

rrp.decode = function (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;
};

rrp.decode.bytes = 0;

rrp.encodingLength = function (data) {
  return 2 + name.encodingLength(data.mbox || ".") +
    name.encodingLength(data.txt || ".");
};

const typebitmap = {};

typebitmap.encode = function (typelist, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(typebitmap.encodingLength(typelist));
  if (!offset) offset = 0;
  const oldOffset = offset;

  var typesByWindow = [];
  for (var i = 0; i < typelist.length; i++) {
    var typeid = types.toType(typelist[i]);
    if (typesByWindow[typeid >> 8] === undefined) {
      typesByWindow[typeid >> 8] = [];
    }
    typesByWindow[typeid >> 8][(typeid >> 3) & 0x1F] |= 1 <<
      (7 - (typeid & 0x7));
  }

  for (i = 0; i < typesByWindow.length; i++) {
    if (typesByWindow[i] !== undefined) {
      var windowBuf = Buffer.from(typesByWindow[i]);
      buf.writeUInt8(i, offset);
      offset += 1;
      buf.writeUInt8(windowBuf.length, offset);
      offset += 1;
      windowBuf.copy(buf, offset);
      offset += windowBuf.length;
    }
  }

  typebitmap.encode.bytes = offset - oldOffset;
  return buf;
};

typebitmap.encode.bytes = 0;

typebitmap.decode = function (buf, offset, length) {
  if (!offset) offset = 0;
  const oldOffset = offset;

  var typelist = [];
  while (offset - oldOffset < length) {
    var window = buf.readUInt8(offset);
    offset += 1;
    var windowLength = buf.readUInt8(offset);
    offset += 1;
    for (var i = 0; i < windowLength; i++) {
      var b = buf.readUInt8(offset + i);
      for (var j = 0; j < 8; j++) {
        if (b & (1 << (7 - j))) {
          var typeid = types.toString((window << 8) | (i << 3) | j);
          typelist.push(typeid);
        }
      }
    }
    offset += windowLength;
  }

  typebitmap.decode.bytes = offset - oldOffset;
  return typelist;
};

typebitmap.decode.bytes = 0;

typebitmap.encodingLength = function (typelist) {
  var extents = [];
  for (var i = 0; i < typelist.length; i++) {
    var typeid = types.toType(typelist[i]);
    extents[typeid >> 8] = Math.max(extents[typeid >> 8] || 0, typeid & 0xFF);
  }

  var len = 0;
  for (i = 0; i < extents.length; i++) {
    if (extents[i] !== undefined) {
      len += 2 + Math.ceil((extents[i] + 1) / 8);
    }
  }

  return len;
};

const rnsec = {};
export { rnsec as nsec };

rnsec.encode = function (record, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(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;
  buf.writeUInt16BE(rnsec.encode.bytes - 2, oldOffset);
  return buf;
};

rnsec.encode.bytes = 0;

rnsec.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;

  var record = {};
  var length = buf.readUInt16BE(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;
};

rnsec.decode.bytes = 0;

rnsec.encodingLength = function (record) {
  return 2 +
    name.encodingLength(record.nextDomain) +
    typebitmap.encodingLength(record.rrtypes);
};

const rnsec3 = {};
export { rnsec3 as nsec3 };

rnsec3.encode = function (record, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rnsec3.encodingLength(record));
  if (!offset) offset = 0;
  const oldOffset = offset;

  const salt = record.salt;
  if (!Buffer.isBuffer(salt)) {
    throw new Error("salt must be a Buffer");
  }

  const nextDomain = record.nextDomain;
  if (!Buffer.isBuffer(nextDomain)) {
    throw new Error("nextDomain must be a Buffer");
  }

  offset += 2; // Leave space for length
  buf.writeUInt8(record.algorithm, offset);
  offset += 1;
  buf.writeUInt8(record.flags, offset);
  offset += 1;
  buf.writeUInt16BE(record.iterations, offset);
  offset += 2;
  buf.writeUInt8(salt.length, offset);
  offset += 1;
  salt.copy(buf, offset, 0, salt.length);
  offset += salt.length;
  buf.writeUInt8(nextDomain.length, offset);
  offset += 1;
  nextDomain.copy(buf, offset, 0, nextDomain.length);
  offset += nextDomain.length;
  typebitmap.encode(record.rrtypes, buf, offset);
  offset += typebitmap.encode.bytes;

  rnsec3.encode.bytes = offset - oldOffset;
  buf.writeUInt16BE(rnsec3.encode.bytes - 2, oldOffset);
  return buf;
};

rnsec3.encode.bytes = 0;

rnsec3.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;

  var record = {};
  var length = buf.readUInt16BE(offset);
  offset += 2;
  record.algorithm = buf.readUInt8(offset);
  offset += 1;
  record.flags = buf.readUInt8(offset);
  offset += 1;
  record.iterations = buf.readUInt16BE(offset);
  offset += 2;
  const saltLength = buf.readUInt8(offset);
  offset += 1;
  record.salt = buf.slice(offset, offset + saltLength);
  offset += saltLength;
  const hashLength = buf.readUInt8(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;
};

rnsec3.decode.bytes = 0;

rnsec3.encodingLength = function (record) {
  return 8 +
    record.salt.length +
    record.nextDomain.length +
    typebitmap.encodingLength(record.rrtypes);
};

const rds = {};
export { rds as ds };

rds.encode = function (digest, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rds.encodingLength(digest));
  if (!offset) offset = 0;
  const oldOffset = offset;

  const digestdata = digest.digest;
  if (!Buffer.isBuffer(digestdata)) {
    throw new Error("Digest must be a Buffer");
  }

  offset += 2; // Leave space for length
  buf.writeUInt16BE(digest.keyTag, offset);
  offset += 2;
  buf.writeUInt8(digest.algorithm, offset);
  offset += 1;
  buf.writeUInt8(digest.digestType, offset);
  offset += 1;
  digestdata.copy(buf, offset, 0, digestdata.length);
  offset += digestdata.length;

  rds.encode.bytes = offset - oldOffset;
  buf.writeUInt16BE(rds.encode.bytes - 2, oldOffset);
  return buf;
};

rds.encode.bytes = 0;

rds.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;

  var digest = {};
  var length = buf.readUInt16BE(offset);
  offset += 2;
  digest.keyTag = buf.readUInt16BE(offset);
  offset += 2;
  digest.algorithm = buf.readUInt8(offset);
  offset += 1;
  digest.digestType = buf.readUInt8(offset);
  offset += 1;
  digest.digest = buf.slice(offset, oldOffset + length + 2);
  offset += digest.digest.length;
  rds.decode.bytes = offset - oldOffset;
  return digest;
};

rds.decode.bytes = 0;

rds.encodingLength = function (digest) {
  return 6 + Buffer.byteLength(digest.digest);
};

//https svcb code change http-64 and svcb-65 record type encode and decode
const rhttpsvcb = {};
export { rhttpsvcb as httpsvcb };

rhttpsvcb.decode = function (buf, offset) {
  if (!offset) offset = 0;
  let oldOffset = offset;

  const rLen = buf.readUInt16BE(offset) + 2;
  offset += 2;
  let data = {};
  data.svcPriority = buf.readUInt16BE(offset);
  offset += 2;
  data.targetName = name.decode(buf, offset);
  offset += name.decode.bytes;
  data.svcParams = {};
  let svcKeyDecode;
  let svcParamKey;
  let svcKeyStr;
  while (offset != (oldOffset + rLen)) {
    svcParamKey = buf.readUInt16BE(offset);
    svcKeyStr = serviceParamKey.toString(svcParamKey);
    svcKeyDecode = svcbKeyObj(svcKeyStr);
    offset += 2;
    data.svcParams[svcKeyStr] = svcKeyDecode.decode(buf, offset);
    offset += svcKeyDecode.decode.bytes;
  }
  rhttpsvcb.decode.bytes = offset - oldOffset;
  return data;
};

rhttpsvcb.decode.bytes = 0;

rhttpsvcb.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(rhttpsvcb.encodingLength(data));
  if (!offset) offset = 0;
  const oldOffset = offset;
  //buf.writeUInt16BE(rhttpsvcb.encodingLength(data) - 2, offset);
  offset += 2;
  buf.writeUInt16BE(data.svcPriority, offset);
  offset += 2;
  name.encode(data.targetName, buf, offset);
  offset += name.encode.bytes;
  let svcbObj;
  for (let key of Object.keys(data.svcParams)) {
    buf.writeUInt16BE(serviceParamKey.toKey(key), offset);
    offset += 2;
    svcbObj = svcbKeyObj(key);
    svcbObj.encode(data.svcParams[key], buf, offset);
    offset += svcbObj.encode.bytes;
  }
  //writing httpsvcb recode length after writing body part changed for performance
  //to avoid calculating encodingLength part
  buf.writeUInt16BE(offset - oldOffset - 2, oldOffset); 
  rhttpsvcb.encode.bytes = offset - oldOffset;
  return buf;
};
rhttpsvcb.encode.bytes = 0;

rhttpsvcb.encodingLength = function (data) {
  var encLen = 4 + name.encodingLength(data.targetName);
  let svcbObj;
  for (let key of Object.keys(data.svcParams)) {
    svcbObj = svcbKeyObj(key);
    encLen += (2 + svcbObj.encodingLength(data.svcParams[key]));
  }
  return encLen;
};

const svcAlpn = {};
export { svcAlpn as svcAlpn };
svcAlpn.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;

  var data = [];
  var length = buf.readUInt16BE(offset);
  offset += 2;
  var valueLength = 0;
  while (length != 0) {
    valueLength = buf.readUInt8(offset);
    offset += 1;
    length -= 1;
    data.push(buf.toString("utf-8", offset, offset + valueLength));
    offset += valueLength;
    length -= valueLength;
  }
  svcAlpn.decode.bytes = offset - oldOffset;
  return data;
};

svcAlpn.decode.bytes = 0;

svcAlpn.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(svcAlpn.encodingLength(data));
  if (!offset) offset = 0;
  const oldOffset = offset;

  //buf.writeUInt16BE(svcAlpn.encodingLength(data) - 2, offset);
  offset += 2;
  for (let value of data) {
    buf.writeUInt8(Buffer.byteLength(value), offset);
    offset += 1;
    offset += buf.write(value, offset);
  }
  //writing alpn value length after writing body part changed for performance
  //to avoid calculating encodingLength part
  buf.writeUInt16BE(offset - oldOffset - 2, oldOffset);
  svcAlpn.encode.bytes = offset - oldOffset;
  return buf;
};
svcAlpn.encode.bytes = 0;

svcAlpn.encodingLength = function (data) {
  var encLen = 2;
  for (let value of data) {
    encLen += (1 + Buffer.byteLength(value));
  }
  return encLen;
};

const svcIpv6 = {};
export { svcIpv6 as svcIpv6 };
svcIpv6.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;
  var data = [];
  var length = buf.readUInt16BE(offset);
  offset += 2;
  while (length != 0) {
    data.push(ip.toString(buf, offset, 16));
    offset += 16;
    length -= 16;
  }
  svcIpv6.decode.bytes = offset - oldOffset;
  return data;
};

svcIpv6.decode.bytes = 0;

svcIpv6.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(svcIpv6.encodingLength(data));
  if (!offset) offset = 0;
  const oldOffset = offset;

  buf.writeUInt16BE(data.length * 16, offset);
  offset += 2;
  for (let value of data) {
    ip.toBuffer(value, buf, offset);
    offset += 16;
  }
  svcIpv6.encode.bytes = offset - oldOffset;
  return buf;
};
svcIpv6.encode.bytes = 0;

svcIpv6.encodingLength = function (data) {
  return (2 + (data.length * 16));
};

const svcIpv4 = {};
export { svcIpv4 as svcIpv4 };
svcIpv4.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;
  var data = [];
  var length = buf.readUInt16BE(offset);
  offset += 2;
  while (length != 0) {
    data.push(ip.toString(buf, offset, 4));
    offset += 4;
    length -= 4;
  }
  svcIpv4.decode.bytes = offset - oldOffset;
  return data;
};

svcIpv4.decode.bytes = 0;

svcIpv4.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(svcIpv4.encodingLength(data));
  if (!offset) offset = 0;
  const oldOffset = offset;

  buf.writeUInt16BE(data.length * 4, offset);
  offset += 2;
  for (let value of data) {
    ip.toBuffer(value, buf, offset);
    offset += 4;
  }
  svcIpv4.encode.bytes = offset - oldOffset;
  return buf;
};
svcIpv4.encode.bytes = 0;

svcIpv4.encodingLength = function (data) {
  return (2 + (data.length * 4));
};

const svcMandatory = {};
export { svcMandatory as svcMandatory };
svcMandatory.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;
  var data = [];
  var length = buf.readUInt16BE(offset);
  offset += 2;
  while (length != 0) {
    data.push(serviceParamKey.toString(buf.readUInt16BE(offset)));
    offset += 2;
    length -= 2;
  }
  svcMandatory.decode.bytes = offset - oldOffset;
  return data;
};

svcMandatory.decode.bytes = 0;

svcMandatory.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(svcMandatory.encodingLength(data));
  if (!offset) offset = 0;
  const oldOffset = offset;
  buf.writeUInt16BE(data.length * 2, offset);
  offset += 2;
  for (let value of data) {
    buf.writeUInt16BE(serviceParamKey.toKey(value), offset);
    offset += 2;
  }
  svcMandatory.encode.bytes = offset - oldOffset;
  return buf;
};
svcMandatory.encode.bytes = 0;

svcMandatory.encodingLength = function (data) {
  return (2 + (data.length * 2));
};

const svcPort = {};
export { svcPort as svcPort };
svcPort.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;
  var data = [];
  var length = buf.readUInt16BE(offset);
  offset += 2;
  while (length != 0) {
    data.push(buf.readUInt16BE(offset));
    offset += 2;
    length -= 2;
  }
  svcPort.decode.bytes = offset - oldOffset;
  return data;
};

svcPort.decode.bytes = 0;

svcPort.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(svcPort.encodingLength(data));
  if (!offset) offset = 0;
  const oldOffset = offset;
  buf.writeUInt16BE(data.length * 2, offset);
  offset += 2;
  for (let value of data) {
    buf.writeUInt16BE(value, offset);
    offset += 2;
  }
  svcPort.encode.bytes = offset - oldOffset;
  return buf;
};
svcPort.encode.bytes = 0;

svcPort.encodingLength = function (data) {
  return (2 + data.length * 2);
};

const svcEch = {};
export { svcEch as svcEch };
svcEch.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;
  var data;
  var length = buf.readUInt16BE(offset);
  offset += 2;
  data = buf.toString("base64", offset, offset + length);
  offset += length;
  svcEch.decode.bytes = offset - oldOffset;
  return data;
};

svcEch.decode.bytes = 0;

svcEch.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(svcEch.encodingLength(data));
  if (!offset) offset = 0;
  const oldOffset = offset;
  //buf.writeUInt16BE(svcEch.encodingLength(data) - 2, offset);
  offset += 2;
  offset += buf.write(data, offset, "base64");
  //writing ech value length after writing body part changed for performance
  //to avoid calculating encodingLength part
  buf.writeUInt16BE(offset - oldOffset - 2, oldOffset);
  svcEch.encode.bytes = offset - oldOffset;
  return buf;
};
svcEch.encode.bytes = 0;

svcEch.encodingLength = function (data) {
  return 2 + (Buffer.from(data, "base64")).byteLength;
};

const svcOther = {};
export { svcOther as svcOther };
svcOther.decode = function (buf, offset) {
  if (!offset) offset = 0;
  const oldOffset = offset;
  var data;
  var length = buf.readUInt16BE(offset);
  offset += 2;
  data = buf.slice(offset, offset + length);
  offset += length;
  svcOther.decode.bytes = offset - oldOffset;
  return data;
};

svcOther.decode.bytes = 0;

svcOther.encode = function (data, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(svcOther.encodingLength(data));
  if (!offset) offset = 0;
  const oldOffset = offset;
  buf.writeUInt16BE(data.byteLength, offset);
  offset += 2;
  offset += data.copy(buf, offset);
  svcOther.encode.bytes = offset - oldOffset;
  return buf;
};
svcOther.encode.bytes = 0;

svcOther.encodingLength = function (data) {
  return 2 + data.byteLength;
};

const svcbKeyObj = function (type) {
  switch (type.toLowerCase()) {
    case "mandatory":
      return svcMandatory;
    case "alpn":
      return svcAlpn;
    case "no-default-alpn":
      return svcAlpn;
    case "port":
      return svcPort;
    case "ipv4hint":
      return svcIpv4;
    case "ech":
      return svcEch;
    case "ipv6hint":
      return svcIpv6;
    default:
      return svcOther;
  }
};
export { svcbKeyObj as svcbKeyObj };
const renc = function (type) {
  switch (type.toUpperCase()) {
    case "A":
      return ra;
    case "PTR":
      return rptr;
    case "CNAME":
      return rcname;
    case "DNAME":
      return rdname;
    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;
    case "HTTPS": //https svcb code change
      return rhttpsvcb;
    case "SVCB": // https svcb code change
      return rhttpsvcb;
  }
  return runknown;
};

export { renc as record };

export const answer = {};

answer.encode = function (a, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(answer.encodingLength(a));
  if (!offset) offset = 0;

  const oldOffset = offset;

  name.encode(a.name, buf, offset);
  offset += name.encode.bytes;

  buf.writeUInt16BE(types.toType(a.type), offset);

  if (a.type.toUpperCase() === "OPT") {
    if (a.name !== ".") {
      throw new Error("OPT name must be root.");
    }
    buf.writeUInt16BE(a.udpPayloadSize || 4096, offset + 2);
    buf.writeUInt8(a.extendedRcode || 0, offset + 4);
    buf.writeUInt8(a.ednsVersion || 0, offset + 5);
    buf.writeUInt16BE(a.flags || 0, offset + 6);

    offset += 8;
    ropt.encode(a.options || [], buf, offset);
    offset += ropt.encode.bytes;
  } else {
    let klass = classes.toClass(a.class === undefined ? "IN" : a.class);
    if (a.flush) klass |= FLUSH_MASK; // the 1st bit of the class is the flush bit
    buf.writeUInt16BE(klass, offset + 2);
    buf.writeUInt32BE(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;
};

answer.encode.bytes = 0;

answer.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const a = {};
  const oldOffset = offset;

  a.name = name.decode(buf, offset);
  offset += name.decode.bytes;
  a.type = types.toString(buf.readUInt16BE(offset));
  if (a.type === "OPT") {
    a.udpPayloadSize = buf.readUInt16BE(offset + 2);
    a.extendedRcode = buf.readUInt8(offset + 4);
    a.ednsVersion = buf.readUInt8(offset + 5);
    a.flags = buf.readUInt16BE(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 = buf.readUInt16BE(offset + 2);
    a.ttl = buf.readUInt32BE(offset + 4);

    a.class = classes.toString(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;
};

answer.decode.bytes = 0;

answer.encodingLength = function (a) {
  const data = (a.data !== null && a.data !== undefined) ? a.data : a.options;
  return name.encodingLength(a.name) + 8 + renc(a.type).encodingLength(data);
};

export const question = {};

question.encode = function (q, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(question.encodingLength(q));
  if (!offset) offset = 0;

  const oldOffset = offset;

  name.encode(q.name, buf, offset);
  offset += name.encode.bytes;

  buf.writeUInt16BE(types.toType(q.type), offset);
  offset += 2;

  buf.writeUInt16BE(
    classes.toClass(q.class === undefined ? "IN" : q.class),
    offset,
  );
  offset += 2;

  question.encode.bytes = offset - oldOffset;
  return q;
};

question.encode.bytes = 0;

question.decode = function (buf, offset) {
  if (!offset) offset = 0;

  const oldOffset = offset;
  const q = {};

  q.name = name.decode(buf, offset);
  offset += name.decode.bytes;

  q.type = types.toString(buf.readUInt16BE(offset));
  offset += 2;

  q.class = classes.toString(buf.readUInt16BE(offset));
  offset += 2;

  const qu = !!(q.class & QU_MASK);
  if (qu) q.class &= NOT_QU_MASK;

  question.decode.bytes = offset - oldOffset;
  return q;
};

question.decode.bytes = 0;

question.encodingLength = function (q) {
  return name.encodingLength(q.name) + 4;
};

export const AUTHORITATIVE_ANSWER = 1 << 10;
export const TRUNCATED_RESPONSE = 1 << 9;
export const RECURSION_DESIRED = 1 << 8;
export const RECURSION_AVAILABLE = 1 << 7;
export const AUTHENTIC_DATA = 1 << 5;
export const CHECKING_DISABLED = 1 << 4;
export const DNSSEC_OK = 1 << 15;

export const encode = function (result, buf, offset) {
  if (!buf) buf = Buffer.allocUnsafe(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);

  encode.bytes = offset - oldOffset;

  return buf;
};

encode.bytes = 0;

export const 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);

  decode.bytes = offset - oldOffset;

  return result;
};

decode.bytes = 0;

export const encodingLength = function (result) {
  return header.encodingLength(result) +
    encodingLengthList(result.questions || [], question) +
    encodingLengthList(result.answers || [], answer) +
    encodingLengthList(result.authorities || [], answer) +
    encodingLengthList(result.additionals || [], answer);
};

export const streamEncode = function (result) {
  const buf = encode(result);
  const sbuf = Buffer.allocUnsafe(2);
  sbuf.writeUInt16BE(buf.byteLength);
  const combine = Buffer.concat([sbuf, buf]);
  streamEncode.bytes = combine.byteLength;
  return combine;
};

streamEncode.bytes = 0;

export const streamDecode = function (sbuf) {
  const len = sbuf.readUInt16BE(0);
  if (sbuf.byteLength < len + 2) {
    // not enough data
    return null;
  }
  const result = decode(sbuf.slice(2));
  streamDecode.bytes = decode.bytes;
  return result;
};

streamDecode.bytes = 0;

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;
}