dnssd-advertise 0.1.0

package/dist/dnssd-advertise.js

@@ -0,0 +1,2552 @@
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+
+var e = require("node:os");
+
+var t = require("node:dgram");
+
+let n = function(e) {
+  e[e.QUERY = 0] = "QUERY";
+  e[e.RESPONSE = 32768] = "RESPONSE";
+  return e;
+}({});
+
+let r = function(e) {
+  e[e.A = 1] = "A";
+  e[e.NS = 2] = "NS";
+  e[e.CNAME = 5] = "CNAME";
+  e[e.SOA = 6] = "SOA";
+  e[e.NULL = 10] = "NULL";
+  e[e.PTR = 12] = "PTR";
+  e[e.HINFO = 13] = "HINFO";
+  e[e.MX = 15] = "MX";
+  e[e.TXT = 16] = "TXT";
+  e[e.RP = 17] = "RP";
+  e[e.AFSDB = 18] = "AFSDB";
+  e[e.SIG = 24] = "SIG";
+  e[e.KEY = 25] = "KEY";
+  e[e.AAAA = 28] = "AAAA";
+  e[e.LOC = 29] = "LOC";
+  e[e.SRV = 33] = "SRV";
+  e[e.NAPTR = 35] = "NAPTR";
+  e[e.KX = 36] = "KX";
+  e[e.CERT = 37] = "CERT";
+  e[e.DNAME = 39] = "DNAME";
+  e[e.OPT = 41] = "OPT";
+  e[e.APL = 42] = "APL";
+  e[e.DS = 43] = "DS";
+  e[e.SSHFP = 44] = "SSHFP";
+  e[e.IPSECKEY = 45] = "IPSECKEY";
+  e[e.RRSIG = 46] = "RRSIG";
+  e[e.NSEC = 47] = "NSEC";
+  e[e.DNSKEY = 48] = "DNSKEY";
+  e[e.DHCID = 49] = "DHCID";
+  e[e.NSEC3 = 50] = "NSEC3";
+  e[e.NSEC3PARAM = 51] = "NSEC3PARAM";
+  e[e.TLSA = 52] = "TLSA";
+  e[e.HIP = 55] = "HIP";
+  e[e.CDS = 59] = "CDS";
+  e[e.CDNSKEY = 60] = "CDNSKEY";
+  e[e.SVCB = 64] = "SVCB";
+  e[e.HTTPS = 65] = "HTTPS";
+  e[e.SPF = 99] = "SPF";
+  e[e.TKEY = 249] = "TKEY";
+  e[e.TSIG = 250] = "TSIG";
+  e[e.IXFR = 251] = "IXFR";
+  e[e.AXFR = 252] = "AXFR";
+  e[e.ANY = 255] = "ANY";
+  e[e.CAA = 257] = "CAA";
+  e[e.TA = 32768] = "TA";
+  e[e.DLV = 32769] = "DLV";
+  return e;
+}({});
+
+let s = function(e) {
+  e[e.IN = 1] = "IN";
+  e[e.CS = 2] = "CS";
+  e[e.CH = 3] = "CH";
+  e[e.HS = 4] = "HS";
+  e[e.ANY = 255] = "ANY";
+  return e;
+}({});
+
+let a = function(e) {
+  e[e.NOERR = 0] = "NOERR";
+  e[e.FORMERR = 1] = "FORMERR";
+  e[e.SERVFAIL = 2] = "SERVFAIL";
+  e[e.NXDOMAIN = 3] = "NXDOMAIN";
+  e[e.NOTIMP = 4] = "NOTIMP";
+  e[e.REFUSED = 5] = "REFUSED";
+  e[e.YXDOMAIN = 6] = "YXDOMAIN";
+  e[e.YXRRSET = 7] = "YXRRSET";
+  e[e.NXRRSET = 8] = "NXRRSET";
+  e[e.NOTAUTH = 9] = "NOTAUTH";
+  e[e.NOTZONE = 10] = "NOTZONE";
+  e[e.CHECKING_DISABLED = 16] = "CHECKING_DISABLED";
+  e[e.AUTHENTIC_DATA = 32] = "AUTHENTIC_DATA";
+  e[e.RECURSION_AVAILABLE = 128] = "RECURSION_AVAILABLE";
+  e[e.RECURSION_DESIRED = 256] = "RECURSION_DESIRED";
+  e[e.TRUNCATED_RESPONSE = 512] = "TRUNCATED_RESPONSE";
+  e[e.AUTHORITATIVE_ANSWER = 1024] = "AUTHORITATIVE_ANSWER";
+  return e;
+}({});
+
+let o = function(e) {
+  e[e.OPTION_0 = 0] = "OPTION_0";
+  e[e.LLQ = 1] = "LLQ";
+  e[e.UL = 2] = "UL";
+  e[e.NSID = 3] = "NSID";
+  e[e.OPTION_4 = 4] = "OPTION_4";
+  e[e.DAU = 5] = "DAU";
+  e[e.DHU = 6] = "DHU";
+  e[e.N3U = 7] = "N3U";
+  e[e.CLIENT_SUBNET = 8] = "CLIENT_SUBNET";
+  e[e.EXPIRE = 9] = "EXPIRE";
+  e[e.COOKIE = 10] = "COOKIE";
+  e[e.TCP_KEEPALIVE = 11] = "TCP_KEEPALIVE";
+  e[e.PADDING = 12] = "PADDING";
+  e[e.CHAIN = 13] = "CHAIN";
+  e[e.KEY_TAG = 14] = "KEY_TAG";
+  e[e.DEVICEID = 26946] = "DEVICEID";
+  e[e.OPTION_65535 = 65535] = "OPTION_65535";
+  return e;
+}({});
+
+const i = new TextEncoder;
+
+const c = new TextDecoder;
+
+const f = "undefined" != typeof Buffer ? e => Buffer.byteLength(e) : e => {
+  let t = e.length;
+  for (let n = t - 1; n >= 0; n--) {
+    const r = e.charCodeAt(n);
+    if (r > 127 && r <= 2047) {
+      t++;
+    } else if (r > 2047 && r <= 65535) {
+      t += 2;
+    }
+    if (r >= 56320 && r <= 57343) {
+      n--;
+    }
+  }
+  return t;
+};
+
+const l = {
+  bytes(e) {
+    let t = 2;
+    switch (e) {
+     case "":
+     case ".":
+     case "..":
+      return 1;
+
+     default:
+      if ("." === e[0]) {
+        t--;
+      }
+      if ("." === e[e.length - 1]) {
+        t--;
+      }
+      t += e.replace(/\\\./g, ".").length;
+      if (t > 255) {
+        throw new RangeError(`Name "${e}" is above 255 byte limit.`);
+      }
+      return t;
+    }
+  },
+  write(e, t, n) {
+    const r = i.encode(n);
+    for (let s = 46 === r[0] ? 1 : 0, a = 0; s < r.byteLength; s = a + 1) {
+      a = r.indexOf(46, s);
+      while (a > -1 && 92 === r[a - 1]) {
+        a = r.indexOf(46, a + 1);
+      }
+      if (-1 === a) {
+        a = r.byteLength;
+      }
+      if (a === s) {
+        continue;
+      } else if (a - s > 63) {
+        throw new RangeError(`Label in "${n}" is above 63 byte limit.`);
+      }
+      let o = t + 1;
+      for (let t = s; t < a; t++) {
+        if (92 === r[t] && 46 === r[t + 1]) {
+          t++;
+        }
+        e.setUint8(o++, r[t]);
+      }
+      e.setUint8(t, o - t - 1);
+      t = o;
+      s = a + 1;
+    }
+    return t + 1;
+  },
+  read(e, t) {
+    const n = [];
+    let r = t.offset;
+    let s = t;
+    while (1) {
+      const t = e.getUint8(s.offset);
+      if (0 === t) {
+        advance(s, 1);
+        break;
+      } else if (!(192 & t)) {
+        advance(s, 1);
+        const r = sliceView(e, s, t);
+        n.push(c.decode(r).replace(/\./g, "\\."));
+      } else {
+        const t = e.getUint16(s.offset) - 49152;
+        advance(s, 2);
+        if (t < r) {
+          s = {
+            offset: r = t,
+            length: 0
+          };
+        } else {
+          break;
+        }
+      }
+    }
+    return n.join(".") || ".";
+  }
+};
+
+const u = {
+  bytes: e => "string" == typeof e ? f(e) : e.byteLength,
+  write(e, t, n) {
+    const r = "string" == typeof n ? i.encode(n) : n;
+    new Uint8Array(e.buffer, e.byteOffset + t, r.byteLength).set(r);
+    return t + r.byteLength;
+  },
+  read: (e, t) => sliceView(e, t)
+};
+
+const d = {
+  bytes: e => e.byteLength + 1,
+  write(e, t, n) {
+    e.setUint8(t++, n.byteLength);
+    new Uint8Array(e.buffer, e.byteOffset + t, n.byteLength).set(n);
+    return t + n.byteLength;
+  },
+  read(e, t) {
+    const n = e.getUint8(t.offset);
+    advance(t, 1);
+    return sliceView(e, t, n);
+  }
+};
+
+const h = {
+  bytes: e => f(e) + 1,
+  write(e, t, n) {
+    const r = i.encode(n);
+    e.setUint8(t++, r.byteLength);
+    return u.write(e, t, r);
+  },
+  read(e, t) {
+    const n = e.getUint8(t.offset);
+    advance(t, 1);
+    return c.decode(sliceView(e, t, n));
+  }
+};
+
+const y = {
+  bytes(e) {
+    const t = [];
+    for (let n = 0; n < e.length; n++) {
+      t[e[n] >> 8] = Math.max(t[e[n] >> 8] || 0, 255 & e[n]);
+    }
+    let n = 0;
+    for (let e = 0; e < t.length; e++) {
+      if (null != t[e]) {
+        n += 2 + Math.ceil((t[e] + 1) / 8);
+      }
+    }
+    return n;
+  },
+  write(e, t, n) {
+    const r = [];
+    for (let e = 0; e < n.length; e++) {
+      (r[n[e] >> 8] || (r[n[e] >> 8] = []))[n[e] >> 3 & 31] |= 1 << 7 - (7 & n[e]);
+    }
+    for (let n = 0; n < r.length; n++) {
+      const s = r[n];
+      if (null != s) {
+        e.setUint8(t++, n);
+        e.setUint8(t++, s.length);
+        for (let n = 0; n < s.length; n++) {
+          e.setUint8(t++, s[n]);
+        }
+      }
+    }
+    return t;
+  },
+  read(e, t) {
+    const {offset: n, length: r} = t;
+    const s = [];
+    while (t.offset - n < r) {
+      const n = e.getUint8(t.offset);
+      const r = e.getUint8(t.offset + 1);
+      for (let a = 0; a < r; a++) {
+        const r = e.getUint8(t.offset + 2 + a);
+        for (let e = 0; e < 8; e++) {
+          if (r & 1 << 7 - e) {
+            s.push(n << 8 | a << 3 | e);
+          }
+        }
+      }
+      advance(t, 2 + r);
+    }
+    return s;
+  }
+};
+
+const p = {
+  bytes: () => 4,
+  write(e, t, n) {
+    const r = n.split(".", 4);
+    for (let n = 0; n < 4; n++) {
+      e.setUint8(t++, parseInt(r[n], 10));
+    }
+    return t;
+  },
+  read(e, t) {
+    const n = Math.min(t.length, 4);
+    const r = new Array(4).fill(0).map((r, s) => s < n ? e.getUint8(t.offset + s) : 0).join(".");
+    advance(t, n);
+    return r;
+  }
+};
+
+const g = {
+  bytes: () => 2,
+  write(e, t, n) {
+    e.setUint16(t, n);
+    return t + 2;
+  },
+  read(e, t) {
+    const n = e.getUint16(t.offset);
+    advance(t, 2);
+    return n;
+  }
+};
+
+const E = {
+  bytes: () => 16,
+  write(e, t, n) {
+    const r = n.indexOf("::");
+    const s = (r > -1 ? n.slice(0, r) : n).split(":");
+    const a = r > -1 ? n.slice(r + 2).split(":") : [];
+    const o = a.length > 0 && a[a.length - 1].includes(".") ? a.pop() : void 0;
+    for (let n = 0; n < s.length; n++) {
+      e.setUint16(t, parseInt(s[n], 16));
+      t += 2;
+    }
+    for (let n = 8 - (s.length + a.length + (o ? 2 : 0)); n > 0; n--) {
+      e.setUint16(t, 0);
+      t += 2;
+    }
+    for (let n = 0; n < a.length; n++) {
+      e.setUint16(t, parseInt(a[n], 16));
+      t += 2;
+    }
+    if (o) {
+      const n = o.split(".", 4).map(e => parseInt(e, 10));
+      e.setUint16(t, n[0] << 8 | n[1]);
+      e.setUint16(t + 2, n[2] << 8 | n[3]);
+      t += 4;
+    }
+    return t;
+  },
+  read(e, t) {
+    let n = "";
+    const r = Math.min(t.length, 16);
+    for (let s = 0; s < r; s += 2) {
+      if (0 !== s) {
+        n += ":";
+      }
+      n += e.getUint16(t.offset + s).toString(16);
+    }
+    advance(t, r);
+    return n.replace(/(^|:)0(:0)*:0(:|$)/, "$1::$3").replace(/:{3,4}/, "::");
+  }
+};
+
+const withRDLength = e => ({
+  bytes: t => e.bytes(t) + 2,
+  write(t, n, r) {
+    const s = n;
+    n = e.write(t, n + 2, r);
+    t.setUint16(s, n - s - 2);
+    return n;
+  },
+  read(t, n) {
+    const {offset: r, length: s} = n;
+    const a = n.length = t.getUint16(n.offset);
+    n.offset += 2;
+    const o = e.read(t, n);
+    n.offset = r + 2 + a;
+    n.length = s;
+    return o;
+  }
+});
+
+const array = e => ({
+  bytes(t) {
+    let n = 0;
+    for (let r = 0; null != t && r < t.length; r++) {
+      n += e.bytes(t[r]);
+    }
+    return n;
+  },
+  write(t, n, r) {
+    for (let s = 0; null != r && s < r.length; s++) {
+      n = e.write(t, n, r[s]);
+    }
+    return n;
+  },
+  read(t, n) {
+    const {offset: r, length: s} = n;
+    const a = [];
+    while (n.offset - r < s) {
+      a.push(e.read(t, n));
+    }
+    return a;
+  }
+});
+
+const advance = (e, t) => {
+  e.offset += 0 | t;
+  e.length -= 0 | t;
+  e.length &= ~(e.length >> 31);
+};
+
+const sliceView = (e, t, n = t.length) => {
+  const r = new Uint8Array(e.buffer, e.byteOffset + t.offset, n);
+  advance(t, n);
+  return r;
+};
+
+const A = {
+  bytes: e => l.bytes(e.name) + 4,
+  write(e, t, n) {
+    let r = n.class || s.IN;
+    if (n.qu) {
+      r |= 32768;
+    }
+    t = l.write(e, t, n.name);
+    e.setUint16(t, n.type);
+    e.setUint16(t + 2, r);
+    return t + 4;
+  },
+  read(e, t) {
+    const n = l.read(e, t);
+    const r = e.getUint16(t.offset);
+    let a = e.getUint16(t.offset + 2) || s.ANY;
+    let o = !1;
+    if (a !== s.ANY && 32768 & a) {
+      a &= -32769;
+      o = !0;
+    }
+    advance(t, 4);
+    return {
+      name: n,
+      type: r,
+      class: a,
+      qu: o
+    };
+  }
+};
+
+let b = function(e) {
+  e[e.v4 = 1] = "v4";
+  e[e.v6 = 2] = "v6";
+  return e;
+}({});
+
+const N = withRDLength({
+  bytes: e => u.bytes(e.data),
+  write: (e, t, n) => u.write(e, t, n.data),
+  read: (e, t) => ({
+    code: o.OPTION_0,
+    data: u.read(e, t)
+  })
+});
+
+const S = "(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])";
+
+const w = new RegExp(`^(?:${S}\\.){3}${S}$`);
+
+const m = withRDLength({
+  bytes: e => Math.ceil((e.sourcePrefixLength || 0) / 8) + 4,
+  write(e, t, n) {
+    const r = n.sourcePrefixLength || 0;
+    const s = n.scopePrefixLength || 0;
+    const a = n.family || (w.test(n.ip) ? b.v4 : b.v6);
+    const o = Math.ceil(r / 8);
+    e.setUint16(t, a);
+    e.setUint8(t + 2, r);
+    e.setUint8(t + 3, s);
+    t += 4;
+    const i = ((e, t) => {
+      const n = new ArrayBuffer(e.bytes(t));
+      const r = e.write(new DataView(n), 0, t);
+      return new Uint8Array(n, 0, r);
+    })(a === b.v4 ? p : E, n.ip);
+    for (let n = 0; n < o; n++) {
+      e.setUint8(t++, i[n]);
+    }
+    return t;
+  },
+  read(e, t) {
+    const n = e.getUint16(t.offset);
+    const r = e.getUint8(t.offset + 2);
+    const s = e.getUint8(t.offset + 3);
+    advance(t, 4);
+    return {
+      code: o.CLIENT_SUBNET,
+      family: n,
+      sourcePrefixLength: r,
+      scopePrefixLength: s,
+      ip: n === b.v4 ? p.read(e, t) : E.read(e, t)
+    };
+  }
+});
+
+const U = withRDLength({
+  bytes: e => e.timeout ? 2 : 0,
+  write(e, t, n) {
+    if (n.timeout) {
+      e.setUint16(t, n.timeout);
+      t += 2;
+    }
+    return t;
+  },
+  read(e, t) {
+    if (t.length) {
+      const n = e.getUint16(t.offset);
+      advance(t, 2);
+      return {
+        code: o.TCP_KEEPALIVE,
+        timeout: n
+      };
+    } else {
+      return {
+        code: o.TCP_KEEPALIVE,
+        timeout: void 0
+      };
+    }
+  }
+});
+
+const T = withRDLength({
+  bytes: e => e.length || 0,
+  write: (e, t, n) => t + (n.length || 0),
+  read(e, t) {
+    const {length: n} = t;
+    advance(t, n);
+    return {
+      code: o.PADDING,
+      length: n
+    };
+  }
+});
+
+const I = withRDLength({
+  bytes: e => 2 * e.tags.length,
+  write(e, t, n) {
+    for (let r = 0; r < n.tags.length; r++) {
+      e.setUint16(t, n.tags[r]);
+      t += 2;
+    }
+    return t;
+  },
+  read(e, t) {
+    const {offset: n, length: r} = t;
+    const s = [];
+    while (t.offset - n < r) {
+      s.push(e.getUint16(t.offset));
+      advance(t, 2);
+    }
+    return {
+      code: o.KEY_TAG,
+      tags: s
+    };
+  }
+});
+
+const isUnknownOpt = e => !!e.data;
+
+const O = {
+  bytes(e) {
+    if (isUnknownOpt(e)) {
+      return N.bytes(e) + 2;
+    }
+    switch (e.code) {
+     case o.CLIENT_SUBNET:
+      return m.bytes(e) + 2;
+
+     case o.TCP_KEEPALIVE:
+      return U.bytes(e) + 2;
+
+     case o.PADDING:
+      return T.bytes(e) + 2;
+
+     case o.KEY_TAG:
+      return I.bytes(e) + 2;
+    }
+  },
+  write(e, t, n) {
+    e.setUint16(t, n.code);
+    t += 2;
+    if (isUnknownOpt(n)) {
+      return N.write(e, t, n);
+    }
+    switch (n.code) {
+     case o.CLIENT_SUBNET:
+      return m.write(e, t, n);
+
+     case o.TCP_KEEPALIVE:
+      return U.write(e, t, n);
+
+     case o.PADDING:
+      return T.write(e, t, n);
+
+     case o.KEY_TAG:
+      return I.write(e, t, n);
+    }
+  },
+  read(e, t) {
+    const n = e.getUint16(t.offset);
+    advance(t, 2);
+    switch (n) {
+     case o.CLIENT_SUBNET:
+      return m.read(e, t);
+
+     case o.TCP_KEEPALIVE:
+      return U.read(e, t);
+
+     case o.PADDING:
+      return T.read(e, t);
+
+     case o.KEY_TAG:
+      return I.read(e, t);
+
+     default:
+      const r = N.read(e, t);
+      r.code = n;
+      return r;
+    }
+  }
+};
+
+let R = function(e) {
+  e[e.Mandatory = 0] = "Mandatory";
+  e[e.Alpn = 1] = "Alpn";
+  e[e.NoDefaultAlpn = 2] = "NoDefaultAlpn";
+  e[e.Port = 3] = "Port";
+  e[e.Ipv4Hint = 4] = "Ipv4Hint";
+  e[e.EchConfig = 5] = "EchConfig";
+  e[e.Ipv6Hint = 6] = "Ipv6Hint";
+  e[e.DohPath = 7] = "DohPath";
+  e[e.Odoh = 32769] = "Odoh";
+  return e;
+}({});
+
+const P = withRDLength(array(g));
+
+const C = withRDLength(array(h));
+
+const D = withRDLength(g);
+
+const v = withRDLength(array(p));
+
+const L = withRDLength(array(E));
+
+const k = withRDLength(u);
+
+const M = {
+  bytes(e) {
+    let t = 0;
+    if (null != e.mandatory) {
+      t += P.bytes(e.mandatory) + 2;
+    }
+    if (null != e.alpn) {
+      t += C.bytes(e.alpn) + 2;
+    }
+    if (e["no-default-alpn"]) {
+      t += 4;
+    }
+    if (null != e.port) {
+      t += D.bytes(e.port) + 2;
+    }
+    if (e.ipv4hint) {
+      t += v.bytes(e.ipv4hint) + 2;
+    }
+    if (e.ipv6hint) {
+      t += L.bytes(e.ipv6hint) + 2;
+    }
+    if (e.echconfig) {
+      t += k.bytes(e.echconfig) + 2;
+    }
+    if (e.dohpath) {
+      t += k.bytes(e.dohpath) + 2;
+    }
+    if (e.odoh) {
+      t += k.bytes(e.odoh) + 2;
+    }
+    return t;
+  },
+  write(e, t, n) {
+    if (null != n.mandatory) {
+      e.setUint16(t, R.Mandatory);
+      t = P.write(e, t + 2, n.mandatory);
+    }
+    if (null != n.alpn) {
+      e.setUint16(t, R.Alpn);
+      t = C.write(e, t + 2, n.alpn);
+    }
+    if (n["no-default-alpn"]) {
+      e.setUint16(t, R.NoDefaultAlpn);
+      e.setUint16(t + 2, 0);
+      t += 4;
+    }
+    if (null != n.port) {
+      e.setUint16(t, R.Port);
+      t = D.write(e, t + 2, n.port);
+    }
+    if (n.ipv4hint) {
+      e.setUint16(t, R.Ipv4Hint);
+      t = v.write(e, t + 2, n.ipv4hint);
+    }
+    if (n.ipv6hint) {
+      e.setUint16(t, R.Ipv6Hint);
+      t = L.write(e, t + 2, n.ipv6hint);
+    }
+    if (n.echconfig) {
+      e.setUint16(t, R.EchConfig);
+      t = k.write(e, t + 2, n.echconfig);
+    }
+    if (n.dohpath) {
+      e.setUint16(t, R.DohPath);
+      t = k.write(e, t + 2, n.dohpath);
+    }
+    if (n.odoh) {
+      e.setUint16(t, R.Odoh);
+      t = k.write(e, t + 2, n.odoh);
+    }
+    return t;
+  },
+  read(e, t) {
+    const {length: n, offset: r} = t;
+    const s = {
+      mandatory: void 0,
+      alpn: void 0,
+      "no-default-alpn": !1,
+      port: void 0,
+      ipv4hint: void 0,
+      ipv6hint: void 0,
+      echconfig: void 0,
+      dohpath: void 0,
+      odoh: void 0
+    };
+    while (t.offset - r < n) {
+      const n = e.getUint16(t.offset);
+      advance(t, 2);
+      switch (n) {
+       case R.Mandatory:
+        s.mandatory = P.read(e, t);
+        break;
+
+       case R.Alpn:
+        s.alpn = C.read(e, t);
+        break;
+
+       case R.NoDefaultAlpn:
+        s["no-default-alpn"] = !0;
+        advance(t, 2);
+        break;
+
+       case R.Port:
+        s.port = D.read(e, t);
+        break;
+
+       case R.Ipv4Hint:
+        s.ipv4hint = v.read(e, t);
+        break;
+
+       case R.Ipv6Hint:
+        s.ipv6hint = L.read(e, t);
+        break;
+
+       case R.EchConfig:
+        s.echconfig = k.read(e, t);
+        break;
+
+       case R.DohPath:
+        s.dohpath = c.decode(k.read(e, t));
+        break;
+
+       case R.Odoh:
+        s.odoh = k.read(e, t);
+        break;
+
+       default:
+        k.read(e, t);
+      }
+    }
+    return s;
+  }
+};
+
+const _ = withRDLength(u);
+
+const H = withRDLength(l);
+
+const x = withRDLength(p);
+
+const V = withRDLength(E);
+
+const Y = withRDLength(array(h));
+
+const q = withRDLength({
+  bytes: e => l.bytes(e.target) + 6,
+  write(e, t, n) {
+    e.setUint16(t, n.priority || 0);
+    e.setUint16(t + 2, n.weight || 0);
+    e.setUint16(t + 4, n.port || 0);
+    return l.write(e, t + 6, n.target);
+  },
+  read(e, t) {
+    const n = {
+      priority: 0,
+      weight: 0,
+      port: 0,
+      target: ""
+    };
+    n.priority = e.getUint16(t.offset);
+    n.weight = e.getUint16(t.offset + 2);
+    n.port = e.getUint16(t.offset + 4);
+    advance(t, 6);
+    n.target = l.read(e, t);
+    return n;
+  }
+});
+
+const B = withRDLength({
+  bytes: e => h.bytes(e.cpu) + h.bytes(e.os),
+  write(e, t, n) {
+    t = h.write(e, t, n.cpu);
+    return h.write(e, t, n.os);
+  },
+  read: (e, t) => ({
+    cpu: h.read(e, t),
+    os: h.read(e, t)
+  })
+});
+
+const toCaaTag = e => {
+  switch (e) {
+   case "issue":
+   case "issuewild":
+   case "iodef":
+    return e;
+
+   default:
+    return "issue";
+  }
+};
+
+const G = withRDLength({
+  bytes: e => h.bytes(e.tag) + u.bytes(e.value) + 1,
+  write(e, t, n) {
+    let r = n.flags || 0;
+    if (n.issuerCritical) {
+      r |= 128;
+    }
+    e.setUint8(t, r);
+    t = h.write(e, t + 1, n.tag);
+    return u.write(e, t, n.value);
+  },
+  read(e, t) {
+    const n = e.getUint8(t.offset);
+    advance(t, 1);
+    return {
+      flags: n,
+      tag: toCaaTag(h.read(e, t)),
+      value: u.read(e, t),
+      issuerCritical: !!(128 & n)
+    };
+  }
+});
+
+const K = withRDLength({
+  bytes: e => l.bytes(e.mname) + l.bytes(e.rname) + 20,
+  write(e, t, n) {
+    t = l.write(e, t, n.mname);
+    t = l.write(e, t, n.rname);
+    e.setUint32(t, n.serial || 0);
+    e.setUint32(t + 4, n.refresh || 0);
+    e.setUint32(t + 8, n.retry || 0);
+    e.setUint32(t + 12, n.expire || 0);
+    e.setUint32(t + 16, n.minimum || 0);
+    return t + 20;
+  },
+  read(e, t) {
+    const n = {
+      mname: l.read(e, t),
+      rname: l.read(e, t),
+      serial: e.getUint32(t.offset),
+      refresh: e.getUint32(t.offset + 4),
+      retry: e.getUint32(t.offset + 8),
+      expire: e.getUint32(t.offset + 12),
+      minimum: e.getUint32(t.offset + 16)
+    };
+    t.offset += 20;
+    t.length -= 20;
+    return n;
+  }
+});
+
+const X = withRDLength({
+  bytes: e => l.bytes(e.exchange) + 2,
+  write(e, t, n) {
+    e.setUint16(t, n.preference || 0);
+    return l.write(e, t + 2, n.exchange);
+  },
+  read(e, t) {
+    const n = {
+      preference: e.getUint16(t.offset),
+      exchange: ""
+    };
+    advance(t, 2);
+    n.exchange = l.read(e, t);
+    return n;
+  }
+});
+
+const $ = withRDLength({
+  bytes: e => u.bytes(e.key) + 4,
+  write(e, t, n) {
+    e.setUint16(t, n.flags);
+    e.setUint8(t + 2, 3);
+    e.setUint8(t + 3, n.algorithm);
+    return u.write(e, t + 4, n.key);
+  },
+  read(e, t) {
+    const n = e.getUint16(t.offset);
+    const r = e.getUint8(t.offset + 3);
+    advance(t, 4);
+    return {
+      flags: n,
+      algorithm: r,
+      key: u.read(e, t)
+    };
+  }
+});
+
+const F = withRDLength({
+  bytes: e => 18 + l.bytes(e.signersName) + u.bytes(e.signature),
+  write(e, t, n) {
+    e.setUint16(t, n.typeCovered);
+    e.setUint8(t + 2, n.algorithm);
+    e.setUint8(t + 3, n.labels);
+    e.setUint32(t + 4, n.originalTTL);
+    e.setUint32(t + 8, n.expiration);
+    e.setUint32(t + 12, n.inception);
+    e.setUint16(t + 16, n.keyTag);
+    t = l.write(e, t + 18, n.signersName);
+    return u.write(e, t, n.signature);
+  },
+  read(e, t) {
+    const n = e.getUint16(t.offset);
+    const r = e.getUint8(t.offset + 2);
+    const s = e.getUint8(t.offset + 3);
+    const a = e.getUint32(t.offset + 4);
+    const o = e.getUint32(t.offset + 8);
+    const i = e.getUint32(t.offset + 12);
+    const c = e.getUint16(t.offset + 16);
+    advance(t, 18);
+    return {
+      typeCovered: n,
+      algorithm: r,
+      labels: s,
+      originalTTL: a,
+      expiration: o,
+      inception: i,
+      keyTag: c,
+      signersName: l.read(e, t),
+      signature: u.read(e, t)
+    };
+  }
+});
+
+const Q = withRDLength({
+  bytes: e => l.bytes(e.mbox) + l.bytes(e.txt),
+  write(e, t, n) {
+    t = l.write(e, t, n.mbox);
+    return l.write(e, t, n.txt);
+  },
+  read: (e, t) => ({
+    mbox: l.read(e, t),
+    txt: l.read(e, t)
+  })
+});
+
+const j = withRDLength({
+  bytes: e => l.bytes(e.nextDomain) + y.bytes(e.rrtypes),
+  write(e, t, n) {
+    t = l.write(e, t, n.nextDomain);
+    return y.write(e, t, n.rrtypes);
+  },
+  read: (e, t) => ({
+    nextDomain: l.read(e, t),
+    rrtypes: y.read(e, t)
+  })
+});
+
+const z = withRDLength({
+  bytes: e => d.bytes(e.salt) + d.bytes(e.nextDomain) + y.bytes(e.rrtypes) + 4,
+  write(e, t, n) {
+    e.setUint8(t, n.algorithm);
+    e.setUint8(t + 1, n.flags);
+    e.setUint16(t + 2, n.iterations);
+    t = d.write(e, t + 4, n.salt);
+    t = d.write(e, t, n.nextDomain);
+    return y.write(e, t, n.rrtypes);
+  },
+  read(e, t) {
+    const n = e.getUint8(t.offset);
+    const r = e.getUint8(t.offset + 1);
+    const s = e.getUint16(t.offset + 2);
+    advance(t, 4);
+    return {
+      algorithm: n,
+      flags: r,
+      iterations: s,
+      salt: d.read(e, t),
+      nextDomain: d.read(e, t),
+      rrtypes: y.read(e, t)
+    };
+  }
+});
+
+const W = withRDLength({
+  bytes: e => u.bytes(e.fingerprint) + 2,
+  write(e, t, n) {
+    e.setUint8(t, n.algorithm);
+    e.setUint8(t + 1, n.hash);
+    return u.write(e, t + 2, n.fingerprint);
+  },
+  read(e, t) {
+    const n = e.getUint8(t.offset);
+    const r = e.getUint8(t.offset + 1);
+    advance(t, 2);
+    return {
+      algorithm: n,
+      hash: r,
+      fingerprint: u.read(e, t)
+    };
+  }
+});
+
+const Z = withRDLength({
+  bytes: e => u.bytes(e.digest) + 4,
+  write(e, t, n) {
+    e.setUint16(t, n.keyTag);
+    e.setUint8(t + 2, n.algorithm);
+    e.setUint8(t + 3, n.digestType);
+    return u.write(e, t + 4, n.digest);
+  },
+  read(e, t) {
+    const n = e.getUint16(t.offset);
+    const r = e.getUint8(t.offset + 2);
+    const s = e.getUint8(t.offset + 3);
+    advance(t, 4);
+    return {
+      keyTag: n,
+      algorithm: r,
+      digestType: s,
+      digest: u.read(e, t)
+    };
+  }
+});
+
+const J = withRDLength({
+  bytes: e => h.bytes(e.flags) + h.bytes(e.services) + h.bytes(e.regexp) + l.bytes(e.replacement) + 4,
+  write(e, t, n) {
+    e.setUint16(t, n.order);
+    e.setUint16(t + 2, n.preference);
+    t = h.write(e, t + 4, n.flags);
+    t = h.write(e, t, n.services);
+    t = h.write(e, t, n.regexp);
+    return l.write(e, t, n.replacement);
+  },
+  read(e, t) {
+    const n = e.getUint16(t.offset);
+    const r = e.getUint16(t.offset + 2);
+    advance(t, 4);
+    return {
+      order: n,
+      preference: r,
+      flags: h.read(e, t),
+      services: h.read(e, t),
+      regexp: h.read(e, t),
+      replacement: l.read(e, t)
+    };
+  }
+});
+
+const ee = withRDLength({
+  bytes: e => u.bytes(e.certificate) + 3,
+  write(e, t, n) {
+    e.setUint8(t, n.usage);
+    e.setUint8(t + 1, n.selector);
+    e.setUint8(t + 2, n.matchingType);
+    return u.write(e, t + 3, n.certificate);
+  },
+  read(e, t) {
+    const n = e.getUint8(t.offset);
+    const r = e.getUint8(t.offset + 1);
+    const s = e.getUint8(t.offset + 2);
+    advance(t, 3);
+    return {
+      usage: n,
+      selector: r,
+      matchingType: s,
+      certificate: u.read(e, t)
+    };
+  }
+});
+
+const te = withRDLength({
+  bytes: e => l.bytes(e.name) + M.bytes(e.params) + 2,
+  write(e, t, n) {
+    e.setUint16(t, n.priority || 0);
+    t = l.write(e, t + 2, n.name);
+    return M.write(e, t, n.params);
+  },
+  read(e, t) {
+    const n = e.getUint16(t.offset);
+    advance(t, 2);
+    return {
+      name: l.read(e, t),
+      priority: n,
+      params: M.read(e, t)
+    };
+  }
+});
+
+const ne = withRDLength(array(O));
+
+const re = {
+  bytes(e) {
+    const t = 8 + l.bytes(e.type === r.OPT ? "." : e.name);
+    switch (e.type) {
+     case r.A:
+      return t + x.bytes(e.data);
+
+     case r.NS:
+      return t + H.bytes(e.data);
+
+     case r.SOA:
+      return t + K.bytes(e.data);
+
+     case r.HINFO:
+      return t + B.bytes(e.data);
+
+     case r.MX:
+      return t + X.bytes(e.data);
+
+     case r.TXT:
+      return t + Y.bytes(e.data);
+
+     case r.RP:
+      return t + Q.bytes(e.data);
+
+     case r.AAAA:
+      return t + V.bytes(e.data);
+
+     case r.SRV:
+      return t + q.bytes(e.data);
+
+     case r.NAPTR:
+      return t + J.bytes(e.data);
+
+     case r.OPT:
+      return t + ne.bytes(e.data);
+
+     case r.DS:
+      return t + Z.bytes(e.data);
+
+     case r.SSHFP:
+      return t + W.bytes(e.data);
+
+     case r.RRSIG:
+      return t + F.bytes(e.data);
+
+     case r.NSEC:
+      return t + j.bytes(e.data);
+
+     case r.DNSKEY:
+      return t + $.bytes(e.data);
+
+     case r.NSEC3:
+      return t + z.bytes(e.data);
+
+     case r.TLSA:
+      return t + ee.bytes(e.data);
+
+     case r.SVCB:
+     case r.HTTPS:
+      return t + te.bytes(e.data);
+
+     case r.CAA:
+      return t + G.bytes(e.data);
+
+     case r.PTR:
+     case r.CNAME:
+     case r.DNAME:
+      return t + H.bytes(e.data);
+
+     default:
+      return t + _.bytes(e.data);
+    }
+  },
+  write(e, t, n) {
+    if (n.type === r.OPT) {
+      t = l.write(e, t, ".");
+      e.setUint16(t, n.type);
+      e.setUint16(t + 2, n.udpPayloadSize || 4096);
+      e.setUint8(t + 4, n.extendedRcode || 0);
+      e.setUint8(t + 5, n.ednsVersion || 0);
+      e.setUint16(t + 6, n.flags || 0);
+      return ne.write(e, t += 8, n.data);
+    }
+    t = l.write(e, t, n.name);
+    e.setUint16(t, n.type);
+    e.setUint16(t + 2, (n.class || 0) | (n.flush ? 32768 : 0));
+    e.setUint32(t + 4, n.ttl || 0);
+    t += 8;
+    switch (n.type) {
+     case r.A:
+      return x.write(e, t, n.data);
+
+     case r.NS:
+      return H.write(e, t, n.data);
+
+     case r.SOA:
+      return K.write(e, t, n.data);
+
+     case r.HINFO:
+      return B.write(e, t, n.data);
+
+     case r.MX:
+      return X.write(e, t, n.data);
+
+     case r.TXT:
+      return Y.write(e, t, n.data);
+
+     case r.RP:
+      return Q.write(e, t, n.data);
+
+     case r.AAAA:
+      return V.write(e, t, n.data);
+
+     case r.SRV:
+      return q.write(e, t, n.data);
+
+     case r.NAPTR:
+      return J.write(e, t, n.data);
+
+     case r.DS:
+      return Z.write(e, t, n.data);
+
+     case r.SSHFP:
+      return W.write(e, t, n.data);
+
+     case r.RRSIG:
+      return F.write(e, t, n.data);
+
+     case r.NSEC:
+      return j.write(e, t, n.data);
+
+     case r.DNSKEY:
+      return $.write(e, t, n.data);
+
+     case r.NSEC3:
+      return z.write(e, t, n.data);
+
+     case r.TLSA:
+      return ee.write(e, t, n.data);
+
+     case r.SVCB:
+     case r.HTTPS:
+      return te.write(e, t, n.data);
+
+     case r.CAA:
+      return G.write(e, t, n.data);
+
+     case r.PTR:
+     case r.CNAME:
+     case r.DNAME:
+      return H.write(e, t, n.data);
+
+     default:
+      return _.write(e, t, n.data);
+    }
+  },
+  read(e, t) {
+    const n = l.read(e, t);
+    const s = e.getUint16(t.offset);
+    if (s === r.OPT) {
+      const n = e.getUint16(t.offset + 2) || 4096;
+      const r = e.getUint8(t.offset + 4);
+      const a = e.getUint8(t.offset + 5);
+      const o = e.getUint16(t.offset + 6);
+      advance(t, 8);
+      return {
+        type: s,
+        udpPayloadSize: n,
+        extendedRcode: r,
+        ednsVersion: a,
+        flags: o,
+        data: ne.read(e, t)
+      };
+    }
+    const a = e.getUint16(t.offset + 2);
+    const o = e.getUint32(t.offset + 4);
+    advance(t, 8);
+    const i = {
+      name: n,
+      type: s,
+      class: -32769 & a,
+      flush: !!(32768 & a),
+      ttl: o,
+      data: null
+    };
+    switch (i.type) {
+     case r.A:
+      i.data = x.read(e, t);
+      return i;
+
+     case r.NS:
+      i.data = H.read(e, t);
+      return i;
+
+     case r.SOA:
+      i.data = K.read(e, t);
+      return i;
+
+     case r.HINFO:
+      i.data = B.read(e, t);
+      return i;
+
+     case r.MX:
+      i.data = X.read(e, t);
+      return i;
+
+     case r.TXT:
+      i.data = Y.read(e, t);
+      return i;
+
+     case r.RP:
+      i.data = Q.read(e, t);
+      return i;
+
+     case r.AAAA:
+      i.data = V.read(e, t);
+      return i;
+
+     case r.SRV:
+      i.data = q.read(e, t);
+      return i;
+
+     case r.NAPTR:
+      i.data = J.read(e, t);
+      return i;
+
+     case r.DS:
+      i.data = Z.read(e, t);
+      return i;
+
+     case r.SSHFP:
+      i.data = W.read(e, t);
+      return i;
+
+     case r.RRSIG:
+      i.data = F.read(e, t);
+      return i;
+
+     case r.NSEC:
+      i.data = j.read(e, t);
+      return i;
+
+     case r.DNSKEY:
+      i.data = $.read(e, t);
+      return i;
+
+     case r.NSEC3:
+      i.data = z.read(e, t);
+      return i;
+
+     case r.TLSA:
+      i.data = ee.read(e, t);
+      return i;
+
+     case r.SVCB:
+     case r.HTTPS:
+      i.data = te.read(e, t);
+      return i;
+
+     case r.CAA:
+      i.data = G.read(e, t);
+      return i;
+
+     case r.PTR:
+     case r.CNAME:
+     case r.DNAME:
+      i.data = H.read(e, t);
+      return i;
+
+     default:
+      i.data = _.read(e, t);
+      return i;
+    }
+  }
+};
+
+const readList = (e, t, n, r) => {
+  if (!r) {
+    return;
+  }
+  const {offset: s, length: a} = n;
+  const o = [];
+  for (let i = 0; i < r && n.offset - s < a; i++) {
+    o.push(e.read(t, n));
+  }
+  return o;
+};
+
+const se = {
+  bytes(e) {
+    const {questions: t, answers: n, authorities: r, additionals: s} = e;
+    let a = 12;
+    let o = 0;
+    for (o = 0; t && o < t.length; o++) {
+      a += A.bytes(t[o]);
+    }
+    for (o = 0; n && o < n.length; o++) {
+      a += re.bytes(n[o]);
+    }
+    for (o = 0; r && o < r.length; o++) {
+      a += re.bytes(r[o]);
+    }
+    for (o = 0; s && o < s.length; o++) {
+      a += re.bytes(s[o]);
+    }
+    return a;
+  },
+  write(e, t, r) {
+    const {questions: s, answers: a, authorities: o, additionals: i} = r;
+    let c = 32767 & (r.flags || 0) | (r.type || n.QUERY) | (r.rtype || 0);
+    e.setUint16(t, r.id || 0);
+    e.setUint16(t + 2, c);
+    e.setUint16(t + 4, r.questions?.length || 0);
+    e.setUint16(t + 6, r.answers?.length || 0);
+    e.setUint16(t + 8, r.authorities?.length || 0);
+    e.setUint16(t + 10, r.additionals?.length || 0);
+    t += 12;
+    let f = 0;
+    for (f = 0; s && f < s.length; f++) {
+      t = A.write(e, t, s[f]);
+    }
+    for (f = 0; a && f < a.length; f++) {
+      t = re.write(e, t, a[f]);
+    }
+    for (f = 0; o && f < o.length; f++) {
+      t = re.write(e, t, o[f]);
+    }
+    for (f = 0; i && f < i.length; f++) {
+      t = re.write(e, t, i[f]);
+    }
+    return t;
+  },
+  read(e, t) {
+    const r = e.getUint16(t.offset);
+    const s = e.getUint16(t.offset + 2);
+    const a = e.getUint16(t.offset + 4);
+    const o = e.getUint16(t.offset + 6);
+    const i = e.getUint16(t.offset + 8);
+    const c = e.getUint16(t.offset + 10);
+    advance(t, 12);
+    return {
+      id: r,
+      flags: s,
+      rtype: 15 & s,
+      type: s & n.RESPONSE ? n.RESPONSE : n.QUERY,
+      questions: readList(A, e, t, a),
+      answers: readList(re, e, t, o),
+      authorities: readList(re, e, t, i),
+      additionals: readList(re, e, t, c)
+    };
+  }
+};
+
+function encode(e) {
+  const t = new ArrayBuffer(se.bytes(e));
+  const n = se.write(new DataView(t), 0, e);
+  return new Uint8Array(t, 0, n);
+}
+
+const ae = (() => {
+  let t = null;
+  let n = null;
+  return () => {
+    if (!t) {
+      t = e.networkInterfaces();
+    }
+    if (!n) {
+      n = Promise.resolve().then(() => t = n = null);
+    }
+    return t;
+  };
+})();
+
+const hasScopeid = e => null != e.scopeid && e.scopeid > 0;
+
+const hostname = () => e.hostname();
+
+const sanitizeLabel = e => e.trim().replace(/\.local\.?$/i, "").replace(/[^a-zA-Z0-9-]/g, "-").replace(/^-+|-+$/g, "").toLowerCase().slice(0, fe);
+
+const createServiceName = (e, t, n) => {
+  const r = (e => e.trim().replace(/\.+/, "_").slice(0, fe))(e);
+  if (n) {
+    const e = ` (${((e, t) => {
+      const n = `${hostname()}:${e}`;
+      let r = 5381;
+      if (0 !== t) {
+        r = (r << 5) + r + (255 & t);
+      }
+      for (let e = 0, t = n.length; e < t; e++) {
+        r = (r << 5) + r + n.charCodeAt(e);
+      }
+      return (65535 & r).toString(16).toUpperCase().padStart(4, "0");
+    })(t, n - 1)})`;
+    return r.slice(0, fe - e.length) + e;
+  } else {
+    return r;
+  }
+};
+
+const srvAnswer = (e, t) => ({
+  type: r.SRV,
+  class: s.IN,
+  name: e.fqdnOut,
+  ttl: t,
+  flush: !0,
+  data: {
+    priority: 0,
+    weight: 0,
+    port: e.port,
+    target: e.host
+  }
+});
+
+const txtAnswer = (e, t) => ({
+  type: r.TXT,
+  class: s.IN,
+  name: e.fqdnOut,
+  ttl: t,
+  flush: !0,
+  data: e.txt
+});
+
+const ptrAnswer = (e, t, n) => ({
+  type: r.PTR,
+  class: s.IN,
+  name: e,
+  ttl: n,
+  flush: !1,
+  data: t
+});
+
+const ptrAnswers = (e, t) => [ ptrAnswer(e.domain, e.fqdnOut, t), ptrAnswer(ue, e.domain, t), ...Object.keys(e.subtypes).map(n => ptrAnswer(n, e.fqdnOut, t)) ];
+
+const aAnswers = (e, t, n) => t.filter(e => e.family === ie.v4).map(t => ({
+  type: r.A,
+  class: s.IN,
+  name: e.host,
+  ttl: n,
+  flush: !0,
+  data: t.address
+}));
+
+const aaaaAnswers = (e, t, n) => t.filter(e => e.family === ie.v6).map(t => ({
+  type: r.AAAA,
+  class: s.IN,
+  name: e.host,
+  ttl: n,
+  flush: !0,
+  data: t.address
+}));
+
+const answers = (e, t, n) => [ ...ptrAnswers(e, n), srvAnswer(e, n), txtAnswer(e, n), ...aAnswers(e, t, n), ...aaaaAnswers(e, t, n) ];
+
+let oe = function(e) {
+  e[e.NONE = 0] = "NONE";
+  e[e.NAME = 1] = "NAME";
+  e[e.HOSTNAME_A = 2] = "HOSTNAME_A";
+  e[e.HOSTNAME_AAAA = 4] = "HOSTNAME_AAAA";
+  e[e.HOSTNAME = e.HOSTNAME_A | e.HOSTNAME_AAAA] = "HOSTNAME";
+  return e;
+}({});
+
+const checkAnswerConflicts = (e, t, n) => {
+  let s = oe.NONE;
+  const a = new Set(n.filter(e => e.family === ie.v4).map(e => e.address));
+  const o = new Set(n.filter(e => e.family === ie.v6).map(e => e.address));
+  for (const n of e) {
+    const e = n.name?.toLowerCase();
+    if (n.type === r.SRV && e === t.fqdnIn && (n.data.port !== t.port || n.data.target.toLowerCase() !== t.host)) {
+      s |= oe.NAME;
+    } else if (n.type === r.A && e === t.host && !a.has(n.data)) {
+      s |= oe.HOSTNAME_A;
+    } else if (n.type === r.AAAA && e === t.host && !o.has(n.data.toLowerCase())) {
+      s |= oe.HOSTNAME_AAAA;
+    }
+  }
+  return s;
+};
+
+const checkResponseConflicts = (e, t, r) => {
+  let s = oe.NONE;
+  if (e.type === n.RESPONSE) {
+    if (e.answers?.length) {
+      s |= checkAnswerConflicts(e.answers, t, r);
+    }
+    if (e.additionals?.length) {
+      s |= checkAnswerConflicts(e.additionals, t, r);
+    }
+  }
+  return s;
+};
+
+const checkQuestionConflicts = (e, t, s) => {
+  if (e.type !== n.QUERY || !e.questions?.length || !e.authorities?.length) {
+    return oe.NONE;
+  }
+  return e.questions.some(e => {
+    const n = e.name.toLowerCase();
+    return (e => e.type === r.ANY || e.type === r.A || e.type === r.AAAA || e.type === r.SRV || e.type === r.TXT || e.type === r.PTR)(e) && (n === t.host || n === t.fqdnIn);
+  }) ? checkAnswerConflicts(e.authorities, t, s) : oe.NONE;
+};
+
+const responseMessage = (e, t, s, o) => {
+  if (e.type !== n.QUERY || !e.questions?.length) {
+    return null;
+  }
+  const i = Object.create(null);
+  let c = !1;
+  let f = !1;
+  let l = !1;
+  let u = !1;
+  if (e.answers) {
+    for (const n of e.answers) {
+      const e = n.name?.toLowerCase();
+      switch (n.type) {
+       case r.SRV:
+        c ||= e === t.fqdnIn;
+        break;
+
+       case r.TXT:
+        f ||= e === t.fqdnIn;
+        break;
+
+       case r.A:
+        l ||= e === t.host;
+        break;
+
+       case r.AAAA:
+        u ||= e === t.host;
+        break;
+
+       case r.PTR:
+        switch (e) {
+         case t.domain:
+          if (n.data.toLowerCase() === t.fqdnIn) {
+            i[t.domain] = !0;
+          }
+          break;
+
+         case ue:
+          if (n.data.toLowerCase() === t.domain) {
+            i[ue] = !0;
+          }
+          break;
+
+         default:
+          if (e && t.subtypes[e] && n.data.toLowerCase() === t.fqdnIn) {
+            i[e] = !0;
+          }
+        }
+      }
+    }
+  }
+  const d = [];
+  const h = [];
+  for (const n of e.questions) {
+    if (!!n.qu !== o) {
+      continue;
+    }
+    const e = n.name.toLowerCase();
+    switch (n.type) {
+     case r.SRV:
+      if (!c && e === t.fqdnIn) {
+        d.push(srvAnswer(t, t.ttl));
+        c = !0;
+      }
+      break;
+
+     case r.TXT:
+      if (!f && e === t.fqdnIn) {
+        d.push(txtAnswer(t, t.ttl));
+        f = !0;
+      }
+      break;
+
+     case r.A:
+      if (!l && e === t.host) {
+        d.push(...aAnswers(t, s, t.ttl));
+        l = !0;
+      }
+      break;
+
+     case r.AAAA:
+      if (!u && e === t.host) {
+        d.push(...aaaaAnswers(t, s, t.ttl));
+        u = !0;
+      }
+      break;
+
+     case r.PTR:
+      switch (e) {
+       case t.domain:
+        if (!i[t.domain]) {
+          d.push(ptrAnswer(t.domain, t.fqdnOut, t.ttl));
+          i[t.domain] = !0;
+        }
+        break;
+
+       case ue:
+        if (!i[ue]) {
+          d.push(ptrAnswer(ue, t.domain, t.ttl));
+          i[ue] = !0;
+        }
+        break;
+
+       default:
+        if (t.subtypes[e]) {
+          d.push(ptrAnswer(e, t.fqdnOut, t.ttl));
+          i[e] = !0;
+        }
+      }
+      break;
+
+     case r.ANY:
+      switch (e) {
+       case t.fqdnIn:
+        if (!c) {
+          d.push(srvAnswer(t, t.ttl));
+          c = !0;
+        }
+        if (!f) {
+          d.push(txtAnswer(t, t.ttl));
+          f = !0;
+        }
+        break;
+
+       case t.host:
+        if (!l) {
+          d.push(...aAnswers(t, s, t.ttl));
+          l = !0;
+        }
+        if (!u) {
+          d.push(...aaaaAnswers(t, s, t.ttl));
+          u = !0;
+        }
+        break;
+
+       case t.domain:
+        if (!i[t.domain]) {
+          d.push(ptrAnswer(t.domain, t.fqdnOut, t.ttl));
+          i[t.domain] = !0;
+        }
+        break;
+
+       case ue:
+        if (!i[ue]) {
+          d.push(ptrAnswer(ue, t.domain, t.ttl));
+          i[ue] = !0;
+        }
+        break;
+
+       default:
+        if (t.subtypes[e]) {
+          d.push(ptrAnswer(e, t.fqdnOut, t.ttl));
+          i[e] = !0;
+        }
+      }
+    }
+  }
+  if (i[t.domain] && !c) {
+    h.push(srvAnswer(t, t.ttl));
+    c = !0;
+  }
+  if (i[t.domain] && !f) {
+    h.push(txtAnswer(t, t.ttl));
+    f = !0;
+  }
+  if (c && !l) {
+    h.push(...aAnswers(t, s, t.ttl));
+    l = !0;
+  }
+  if (c && !u) {
+    h.push(...aaaaAnswers(t, s, t.ttl));
+    u = !0;
+  }
+  if (d.length > 0) {
+    return encode({
+      type: n.RESPONSE,
+      flags: a.AUTHORITATIVE_ANSWER,
+      answers: d,
+      additionals: h
+    });
+  } else {
+    return null;
+  }
+};
+
+const createSocketSettings = (e, t) => {
+  const n = t === ie.v4 ? ce.v4 : ce.v6;
+  const r = ((e, t) => {
+    const n = ae()[e]?.filter(e => e.family === t).map(n => ({
+      ...n,
+      family: t,
+      iname: e
+    }));
+    return n?.length ? n : void 0;
+  })(e, t);
+  if (!r?.length) {
+    return null;
+  }
+  const s = new Set;
+  let a;
+  if (t === ie.v4) {
+    a = r[0].address;
+    for (const e of r) {
+      s.add(e.address);
+    }
+  } else {
+    const t = "win32" === process.platform ? r.find(hasScopeid)?.scopeid.toString() : e;
+    if (!t) {
+      return null;
+    }
+    s.add(a = `::%${t}`);
+  }
+  return {
+    family: t,
+    bindings: r,
+    memberships: s,
+    multicastAddress: n,
+    multicastInterface: a
+  };
+};
+
+const addMembership = (e, t, n) => {
+  try {
+    e.addMembership(t.multicastAddress, n);
+    return !0;
+  } catch (e) {
+    return !1;
+  }
+};
+
+const dropMembership = (e, t, n) => {
+  try {
+    e.dropMembership(t.multicastAddress, n);
+    return !0;
+  } catch {
+    return !1;
+  }
+};
+
+const createInterfaceSocket = (e, n, r) => {
+  const s = [];
+  let a = null;
+  let o = initSocket();
+  function initSocket() {
+    const s = createSocketSettings(e, n);
+    if (!s) {
+      return null;
+    }
+    const a = t.createSocket(n === ie.v4 ? {
+      type: "udp4",
+      reuseAddr: !0
+    } : {
+      type: "udp6",
+      reuseAddr: !0,
+      ipv6Only: !0
+    });
+    a.unref();
+    a.on("message", async (e, t) => {
+      try {
+        await r.onMessage(e, {
+          socket: i,
+          family: "IPv6" === t.family ? ie.v6 : ie.v4,
+          address: t.address,
+          port: t.port,
+          reply: e => send(e, t.address, t.port)
+        });
+      } catch {}
+    });
+    scheduleTimer(new Promise((e, t) => {
+      a.prependOnceListener("error", t);
+      a.prependOnceListener("close", closeSocket);
+      a.bind(le, () => {
+        try {
+          setupSocket(a, s);
+          e();
+        } catch (e) {
+          closeSocket();
+          t(e);
+        } finally {
+          a.removeListener("error", t);
+          a.on("error", closeSocket);
+        }
+      });
+    }));
+    return {
+      settings: s,
+      socket: a
+    };
+  }
+  function setupSocket(e, t) {
+    const n = t !== o?.settings ? o?.settings : null;
+    let r = !!n && n.multicastInterface !== t.multicastInterface;
+    try {
+      e.setMulticastTTL(255);
+      e.setMulticastLoopback(!0);
+      e.setMulticastInterface(t.multicastInterface);
+    } catch {
+      closeSocket();
+      return !1;
+    }
+    if (n) {
+      for (const s of n.memberships) {
+        if (!t.memberships.has(s)) {
+          dropMembership(e, n, s);
+          r = !0;
+        }
+      }
+    }
+    for (const s of t.memberships) {
+      if (!n?.memberships.has(s)) {
+        if (!addMembership(e, t, s)) {
+          t.memberships.delete(s);
+        } else if (n) {
+          r = !0;
+        }
+      }
+    }
+    if (!t.memberships.size) {
+      closeSocket();
+      return !1;
+    } else if (o) {
+      o.settings = t;
+    }
+    return r;
+  }
+  function closeSocket() {
+    if (o) {
+      const {socket: e} = o;
+      o = null;
+      try {
+        e.close();
+      } catch {}
+    }
+  }
+  function sendImmediate(e) {
+    try {
+      if (o) {
+        o.socket.send(e.message, 0, e.message.byteLength, e.port, e.address, e.onSent);
+      } else {
+        e.onSent(null);
+      }
+    } catch (t) {
+      e.onSent(t);
+    }
+  }
+  function flushQueue(e) {
+    if (null === e || a === e) {
+      a = null;
+    }
+    let t;
+    while (!a && null != (t = s.shift())) {
+      sendImmediate(t);
+    }
+  }
+  function scheduleTimer(e = function waitTick() {
+    return new Promise(e => setTimeout(e, 0).unref());
+  }()) {
+    if (!a) {
+      const t = a = e.then(() => flushQueue(t), () => flushQueue(null));
+    }
+  }
+  async function send(e, t, n) {
+    return new Promise((r, a) => {
+      scheduleTimer();
+      s.push({
+        message: e,
+        address: t,
+        port: n,
+        onSent(e) {
+          if (null != e) {
+            a(e);
+          } else {
+            r();
+          }
+        }
+      });
+    });
+  }
+  const i = {
+    get closed() {
+      return !o;
+    },
+    get bindings() {
+      return o?.settings.bindings ?? [];
+    },
+    async send(e) {
+      if (o) {
+        await send(e, o.settings.multicastAddress, le);
+      }
+    },
+    refresh() {
+      if (o) {
+        const t = createSocketSettings(e, n);
+        if (t) {
+          return setupSocket(o.socket, t);
+        } else {
+          closeSocket();
+          return !1;
+        }
+      } else {
+        o = initSocket();
+        return !!o;
+      }
+    },
+    close() {
+      closeSocket();
+      flushQueue(null);
+    }
+  };
+  return i;
+};
+
+let ie = function(e) {
+  e.v4 = "IPv4";
+  e.v6 = "IPv6";
+  return e;
+}({});
+
+let ce = function(e) {
+  e.v4 = "224.0.0.251";
+  e.v6 = "ff02::fb";
+  return e;
+}({});
+
+const fe = 63;
+
+const le = 5353;
+
+const ue = "_services._dns-sd._udp.local";
+
+const de = {
+  onError() {},
+  createSocket: (e, t) => {
+    const n = createInterfaceSocket(e, ie.v4, t);
+    const r = createInterfaceSocket(e, ie.v6, t);
+    return {
+      get closed() {
+        return n.closed && r.closed;
+      },
+      get bindings() {
+        return [ ...n.bindings, ...r.bindings ];
+      },
+      async send(e) {
+        await Promise.all([ n.send(e), r.send(e) ]);
+      },
+      refresh() {
+        const e = n.refresh();
+        const t = r.refresh();
+        return e || t;
+      },
+      close() {
+        n.close();
+        r.close();
+      }
+    };
+  },
+  createScheduler: function createScheduler() {
+    const e = new Set;
+    return {
+      schedule: async function schedule(t, n) {
+        return await async function schedule(r, s = getDelay(t, r)) {
+          return new Promise(async (a, o) => {
+            const i = Math.max(s, 20);
+            const c = runTimer(t, i, async () => {
+              e.delete(onCancel);
+              let i = !1;
+              try {
+                const e = await n({
+                  attempt: r,
+                  async retry(e) {
+                    i = !0;
+                    return schedule(r + 1, e);
+                  }
+                });
+                a(e);
+              } catch (e) {
+                if (!i && shouldRetry(t, r)) {
+                  schedule(r + 1, s).then(a, o);
+                } else {
+                  o(e);
+                }
+              }
+            });
+            function onCancel() {
+              o(new AbortError);
+              c();
+            }
+            e.add(onCancel);
+          });
+        }(0);
+      },
+      cancel() {
+        for (const t of e) {
+          t();
+        }
+        e.clear();
+      }
+    };
+  },
+  createServiceInput: e => ({
+    ...e,
+    nameSeed: 0,
+    hostnameSeed: 0
+  }),
+  createServiceRecord: e => {
+    const t = ((e, t) => {
+      let n = sanitizeLabel(e);
+      if (t) {
+        const e = /[-_](\d+)$/.exec(n);
+        if (e) {
+          const r = n.slice(0, -e[0].length);
+          const s = `-${(parseInt(e[1], 10) || t) + 1}`;
+          n = r.slice(0, fe - s.length) + s;
+        } else {
+          const e = `-${t + 1}`;
+          n = n.slice(0, fe - e.length) + e;
+        }
+      }
+      return n;
+    })(e.hostname, e.hostnameSeed);
+    const n = createServiceName(e.name, e.port, e.nameSeed);
+    const r = `_${sanitizeLabel(e.type)}._${sanitizeLabel(e.protocol)}.local`;
+    const s = `${n}.${r}`;
+    const a = [];
+    for (const t in e.txt) {
+      const n = e.txt[t];
+      if ("string" == typeof n || "number" == typeof n) {
+        a.push(`${t}=${n}`);
+      } else if ("boolean" == typeof n && n) {
+        a.push(t);
+      }
+    }
+    return {
+      domain: r,
+      fqdnOut: s,
+      fqdnIn: s.toLowerCase(),
+      host: `${t}.local`,
+      port: e.port >>> 0,
+      subtypes: (e.subtypes || []).reduce((e, t) => {
+        e[`${(e => e.trim().replace(/[^a-zA-Z0-9-_.]/g, "-").replace(/^-+|-+$/g, "").toLowerCase())(t)}._sub.${r}`] = !0;
+        return e;
+      }, Object.create(null)),
+      txt: a,
+      ttl: e.ttl || 250
+    };
+  },
+  networkInterfaceNames: () => {
+    const e = [];
+    const t = ae();
+    for (const n in t) {
+      const r = t[n];
+      if (r?.some(e => !e.internal)) {
+        e.push(n);
+      }
+    }
+    return e.length ? e : Object.keys(t);
+  },
+  hostname
+};
+
+let he = function(e) {
+  e[e.SEND = 0] = "SEND";
+  e[e.PROBE = 1] = "PROBE";
+  e[e.ANNOUNCE = 2] = "ANNOUNCE";
+  e[e.REOPEN = 3] = "REOPEN";
+  return e;
+}({});
+
+const ye = new Map;
+
+const randomDelay = (e, t) => e + Math.floor(Math.random() * (t - e + 1));
+
+const shouldRetry = (e, t) => {
+  switch (e) {
+   case he.SEND:
+   case he.PROBE:
+    return t < 4;
+
+   case he.ANNOUNCE:
+    return t < 3;
+
+   case he.REOPEN:
+    return !0;
+  }
+};
+
+const getDelay = (e, t) => {
+  switch (e) {
+   case he.SEND:
+    return randomDelay(20, 120);
+
+   case he.PROBE:
+    return t ? 250 : randomDelay(0, 250);
+
+   case he.ANNOUNCE:
+    return t ? 1e3 * 2 ** (Math.min(t, 3) - 1) : 0;
+
+   case he.REOPEN:
+    return 6e3;
+  }
+};
+
+const runTimer = (e, t, n) => {
+  const r = Date.now() + t;
+  let s = ye.get(e);
+  let a;
+  if (s) {
+    for (const t of s) {
+      if (e === he.REOPEN || Math.abs(t.time - r) <= 100) {
+        a = t;
+        break;
+      }
+    }
+  } else {
+    s = new Set;
+    ye.set(e, s);
+  }
+  if (!a) {
+    const e = setTimeout(() => {
+      s.delete(a);
+      for (const e of a.tasks) {
+        e();
+      }
+    }, t);
+    if ("unref" in e) {
+      e.unref();
+    }
+    s.add(a = {
+      time: r,
+      tasks: new Set,
+      timeout: e
+    });
+  }
+  a.tasks.add(n);
+  return () => {
+    a.tasks.delete(n);
+    if (!a.tasks.size) {
+      clearTimeout(a.timeout);
+      s.delete(a);
+    }
+  };
+};
+
+class AbortError extends Error {
+  static isAbortError(e) {
+    return e && "object" == typeof e && "AbortError" === e.name;
+  }
+  constructor() {
+    super("Operation cancelled");
+    this.name = "AbortError";
+  }
+}
+
+var pe = function(e) {
+  e[e.PROBING = 0] = "PROBING";
+  e[e.ADVERTISE = 2] = "ADVERTISE";
+  e[e.CLOSED = 3] = "CLOSED";
+  return e;
+}(pe || {});
+
+function createInterfaceAdvertiser(e, t, o) {
+  const i = o.createServiceInput(t);
+  const c = o.createScheduler();
+  let f = 0;
+  let l = 0;
+  let u = o.createServiceRecord(i);
+  let d = pe.PROBING;
+  let h = oe.NONE;
+  const y = o.createSocket(e, {
+    async onMessage(e, t) {
+      if (d === pe.CLOSED) {
+        return;
+      }
+      const r = function decode(e) {
+        const t = "buffer" in e ? new DataView(e.buffer, e.byteOffset, e.byteLength) : new DataView(e);
+        return se.read(t, {
+          offset: 0,
+          length: t.byteLength
+        });
+      }(e);
+      if (d === pe.PROBING) {
+        l++;
+        h |= ((e, t, r) => e.type === n.RESPONSE ? checkResponseConflicts(e, t, r) : checkQuestionConflicts(e, t, r))(r, u, y.bindings);
+        return;
+      } else if (d === pe.ADVERTISE) {
+        h = checkResponseConflicts(r, u, y.bindings);
+        if (resolveConflicts()) {
+          d = pe.PROBING;
+          return;
+        }
+        try {
+          await async function sendReply(e, t) {
+            const n = responseMessage(e, u, y.bindings, !1);
+            const r = responseMessage(e, u, y.bindings, !0);
+            await Promise.all([ n && c.schedule(he.SEND, () => t.reply(n)), r && c.schedule(he.SEND, () => y.send(r)) ]);
+          }(r, t);
+        } catch (e) {
+          if (!AbortError.isAbortError(e)) {
+            o.onError(e);
+          }
+        }
+      }
+    }
+  });
+  async function sendProbe() {
+    const e = ((e, t) => encode({
+      type: n.QUERY,
+      questions: [ {
+        name: e.fqdnOut,
+        type: r.ANY,
+        class: s.IN,
+        qu: !0
+      }, {
+        name: e.host,
+        type: r.ANY,
+        class: s.IN,
+        qu: !0
+      } ],
+      authorities: [ srvAnswer(e, e.ttl), ...aAnswers(e, t, e.ttl), ...aaaaAnswers(e, t, e.ttl) ]
+    }))(u, y.bindings);
+    await c.schedule(he.SEND, () => y.send(e));
+  }
+  async function sendAnnouncement() {
+    const e = ((e, t) => encode({
+      type: n.RESPONSE,
+      flags: a.AUTHORITATIVE_ANSWER,
+      answers: answers(e, t, e.ttl)
+    }))(u, y.bindings);
+    await c.schedule(he.SEND, () => y.send(e));
+  }
+  async function sendGoodbye() {
+    const e = ((e, t) => encode({
+      type: n.RESPONSE,
+      flags: a.AUTHORITATIVE_ANSWER,
+      answers: answers(e, t, 0)
+    }))(u, y.bindings);
+    await c.schedule(he.SEND, () => y.send(e));
+  }
+  function resolveConflicts() {
+    if (h !== oe.NONE) {
+      if (h & oe.NAME) {
+        i.nameSeed++;
+      }
+      if (h & oe.HOSTNAME) {
+        i.hostnameSeed++;
+      }
+      u = o.createServiceRecord(i);
+      h = oe.NONE;
+      return !0;
+    } else {
+      return !1;
+    }
+  }
+  function next() {
+    switch (d) {
+     case pe.PROBING:
+      return async function probe() {
+        l = 0;
+        h = oe.NONE;
+        await c.schedule(he.PROBE, async e => {
+          if (y.closed) {
+            d = pe.CLOSED;
+            return;
+          } else if (d !== pe.PROBING) {
+            return;
+          } else if (e.attempt >= 3) {
+            if (l) {
+              d = h === oe.NONE ? pe.ADVERTISE : pe.CLOSED;
+            } else {
+              d = pe.CLOSED;
+            }
+            return;
+          } else {
+            resolveConflicts();
+            await sendProbe();
+            return e.retry();
+          }
+        });
+        return next();
+      }();
+
+     case pe.ADVERTISE:
+      return async function announce() {
+        while (d === pe.ADVERTISE && !y.closed) {
+          if (!await c.schedule(he.ANNOUNCE, async e => {
+            if (d !== pe.ADVERTISE) {
+              return !1;
+            } else if (e.attempt > 2 && y.refresh()) {
+              return !0;
+            }
+            if (!y.closed) {
+              await sendAnnouncement();
+              if (e.attempt < 3) {
+                return e.retry();
+              }
+            }
+            return !1;
+          })) {
+            await c.schedule(he.REOPEN, async e => {
+              if (d !== pe.ADVERTISE) {
+                return;
+              } else if (!y.refresh() && !y.closed) {
+                return e.retry();
+              }
+            });
+          }
+        }
+        return next();
+      }();
+
+     case pe.CLOSED:
+      return async function reopen() {
+        c.cancel();
+        if (f++ > 15) {
+          return;
+        }
+        await c.schedule(he.REOPEN, async e => {
+          if (d === pe.CLOSED && y.refresh() && !y.closed) {
+            return e.retry();
+          } else if (!y.closed) {
+            d = pe.PROBING;
+            return;
+          }
+        });
+        return next();
+      }();
+    }
+  }
+  return {
+    promise: (async () => {
+      try {
+        d = pe.PROBING;
+        await next();
+        c.cancel();
+      } catch (e) {
+        if (!AbortError.isAbortError(e)) {
+          o.onError(e);
+        }
+      } finally {
+        y.close();
+      }
+    })(),
+    async close() {
+      try {
+        c.cancel();
+        if (d !== pe.CLOSED) {
+          d = pe.CLOSED;
+          await sendGoodbye();
+        }
+        c.cancel();
+      } catch (e) {
+        if (!AbortError.isAbortError(e)) {
+          o.onError(e);
+        }
+      } finally {
+        y.close();
+      }
+    }
+  };
+}
+
+exports.advertise = function advertise(e) {
+  return function advertiseInternal(e, t) {
+    const n = new Set(t.networkInterfaceNames());
+    const r = new Map;
+    const s = t.createScheduler();
+    for (const s of n) {
+      r.set(s, createInterfaceAdvertiser(s, e, t));
+    }
+    s.schedule(he.REOPEN, n => {
+      try {
+        const s = new Set(t.networkInterfaceNames());
+        for (const n of s) {
+          if (!r.has(n)) {
+            r.set(n, createInterfaceAdvertiser(n, e, t));
+          }
+        }
+        for (const [e, t] of r) {
+          if (!s.has(e)) {
+            r.delete(e);
+            t.close();
+          }
+        }
+        return n.retry();
+      } catch (e) {
+        if (!AbortError.isAbortError(e)) {
+          t.onError(e);
+        }
+      }
+    });
+    return async () => {
+      s.cancel();
+      await Promise.all([ ...r.values() ].map(e => e.close()));
+    };
+  }({
+    name: e.name,
+    type: e.type,
+    protocol: e.protocol,
+    hostname: e.hostname || de.hostname(),
+    port: e.port,
+    subtypes: e.subtypes || [],
+    txt: e.txt || {},
+    ttl: e.ttl || 250
+  }, de);
+};
+//# sourceMappingURL=dnssd-advertise.js.map