@nictool/dns-resource-record 1.3.1 → 1.5.0

package/rr/dname.js

@@ -36,9 +36,9 @@ export default class DNAME extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // DNAME via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 39) this.throwHelp('DNAME fromTinydns, invalid n')
 
     return new DNAME({
@@ -47,13 +47,13 @@ export default class DNAME extends RR {
       target: TINYDNS.unpackDomainName(rdata)[0],
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  DNAME  ...
-    const [owner, ttl, c, type, target] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, target] = bindline.split(/\s+/)
     return new DNAME({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/dnskey.js

@@ -93,12 +93,18 @@ export default class DNSKEY extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  DNSKEY Flags Protocol Algorithm PublicKey
-    const regex = /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+\s*(.*?)\s*$/
-    const match = opts.bindline.match(regex)
-    if (!match) this.throwHelp(`unable to parse DNSKEY: ${opts.bindline}`)
-    const [owner, ttl, c, type, flags, protocol, algorithm, publickey] = match.slice(1)
+    const regex =
+      /^(?<owner>\S+)\s+(?<ttl>\d+)\s+(?<cls>\w+)\s+(?<type>DNSKEY)\s+(?<flags>\d+)\s+(?<protocol>\d+)\s+(?<algorithm>\d+)\s+(?<publickey>\S.*)$/i
+
+    const match = bindline.trim().match(regex)
+
+    if (!match) {
+      this.throwHelp(`unable to parse DNSKEY: ${bindline}`)
+    }
+
+    const { owner, ttl, c, type, flags, protocol, algorithm, publickey } = match.groups
 
     return new DNSKEY({
       owner,
@@ -112,8 +118,8 @@ export default class DNSKEY extends RR {
     })
   }
 
-  fromTinydns(opts) {
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+  fromTinydns({ tinyline }) {
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.substring(1).split(':')
     if (n != 48) this.throwHelp('DNSKEY fromTinydns, invalid n')
 
     const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -127,7 +133,7 @@ export default class DNSKEY extends RR {
       algorithm: bytes.readUInt8(3),
       publickey: bytes.slice(4).toString(),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/ds.js

@@ -64,9 +64,9 @@ export default class DS extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  DS Key Tag Algorithm, Digest Type, Digest
-    const [owner, ttl, c, type, keytag, algorithm, digesttype] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, keytag, algorithm, digesttype] = bindline.split(/\s+/)
     return new DS({
       owner,
       ttl: parseInt(ttl, 10),
@@ -75,12 +75,12 @@ export default class DS extends RR {
       'key tag': parseInt(keytag, 10),
       algorithm: parseInt(algorithm, 10),
       'digest type': parseInt(digesttype, 10),
-      digest: opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+      digest: bindline.split(/\s+/).slice(7).join(' ').trim(),
     })
   }
 
-  fromTinydns(opts) {
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+  fromTinydns({ tinyline }) {
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 43) this.throwHelp('DS fromTinydns, invalid n')
 
     const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -94,7 +94,7 @@ export default class DS extends RR {
       'digest type': binRdata.readUInt8(3),
       digest: binRdata.slice(4).toString(),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/hinfo.js

@@ -39,26 +39,29 @@ export default class HINFO extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  HINFO   DEC-2060 TOPS20
-    const regex = /^([\S]+)\s+([0-9]{1,10})\s+(IN)\s+(HINFO)\s+("[^"]+"|[\S]+)\s+("[^"]+"|[\S]+)/i
-    const match = opts.bindline.trim().match(regex)
-    if (!match) this.throwHelp(`unable to parse HINFO: ${opts.bindline}`)
-    const [owner, ttl, c, type, cpu, os] = match.slice(1)
+    const regex =
+      /^(?<owner>\S+)\s+(?<ttl>\d{1,10})\s+(?<class>IN)\s+(?<type>HINFO)\s+(?:"(?<qCPU>[^"]*)"|(?<uCPU>\S+))\s+(?:"(?<qOS>[^"]*)"|(?<uOS>\S+))$/i
+
+    const match = bindline.trim().match(regex)
+    if (!match) this.throwHelp(`unable to parse HINFO: ${bindline}`)
+
+    const { owner, ttl, class: c, type, qCPU, uCPU, qOS, uOS } = match.groups
 
     return new HINFO({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type,
-      cpu,
-      os,
+      cpu: qCPU ?? uCPU,
+      os: qOS ?? uOS,
     })
   }
 
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // HINFO via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, , rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, , rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     const [cpu, os] = [...TINYDNS.unpackString(rdata)]
 
     return new this.constructor({
@@ -68,7 +71,7 @@ export default class HINFO extends RR {
       cpu,
       os,
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/hip.js

@@ -59,9 +59,50 @@ export default class HIP extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    // HIP via generic, :fqdn:55:rdata:ttl:timestamp:lo
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+    if (n != 55) this.throwHelp('HIP fromTinydns, invalid n')
+
+    const bytes = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const hitLen = bytes.readUInt8(0)
+    const pkAlgorithm = bytes.readUInt8(1)
+    const pkLen = bytes.readUInt16BE(2)
+
+    const hit = bytes
+      .slice(4, 4 + hitLen)
+      .toString('hex')
+      .toUpperCase()
+    const publicKey = bytes.slice(4 + hitLen, 4 + hitLen + pkLen).toString('base64')
+
+    const rvsNames = []
+    let pos = 4 + hitLen + pkLen
+    while (pos < bytes.length) {
+      const [name, newPos] = TINYDNS.unpackDomainName(
+        [...bytes.slice(pos)]
+          .map((b) => (b < 32 || b > 126 ? TINYDNS.UInt8toOctal(b) : String.fromCharCode(b)))
+          .join(''),
+      )
+      pos += newPos
+      if (name !== '.') rvsNames.push(name)
+    }
+
+    return new HIP({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'HIP',
+      'pk algorithm': pkAlgorithm,
+      hit,
+      'public key': publicKey,
+      'rendezvous servers': rvsNames.join(' '),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // owner  ttl  IN  HIP  pk-algorithm HIT public-key [rendezvous-server...]
-    const parts = opts.bindline.split(/\s+/)
+    const parts = bindline.split(/\s+/)
     const [owner, ttl, c, type, pkAlgorithm, hit, publicKey] = parts
     return new HIP({
       owner,

package/rr/https.js

@@ -46,9 +46,9 @@ export default class HTTPS extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  HTTPS Priority TargetName Params
-    const [owner, ttl, c, type, pri, fqdn] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, pri, fqdn] = bindline.split(/\s+/)
     return new HTTPS({
       owner,
       ttl: parseInt(ttl, 10),
@@ -56,7 +56,41 @@ export default class HTTPS extends RR {
       type,
       priority: parseInt(pri, 10),
       'target name': fqdn,
-      params: opts.bindline.split(/\s+/).slice(6).join(' ').trim(),
+      params: bindline.split(/\s+/).slice(6).join(' ').trim(),
+    })
+  }
+
+  fromTinydns({ tinyline }) {
+    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
+
+    if (rd.length < 6) {
+      this.throwHelp(`HTTPS: RDATA too short: ${rd}`)
+    }
+
+    const binary = Buffer.from(TINYDNS.octalToChar(rd), 'binary')
+    const priority = binary.readUInt16BE(0)
+
+    let pos = 2
+    const labels = []
+    while (true) {
+      const len = binary.readUInt8(pos)
+      pos += 1
+      if (len === 0) break
+      labels.push(binary.slice(pos, pos + len).toString())
+      pos += len
+    }
+    const targetName = `${labels.join('.')}.`
+    const params = binary.slice(pos).toString()
+
+    return new HTTPS({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'HTTPS',
+      priority,
+      'target name': targetName,
+      params,
+      timestamp: ts,
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/ipseckey.js

@@ -98,9 +98,9 @@ export default class IPSECKEY extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // FQDN TTL CLASS IPSECKEY Precedence GatewayType Algorithm Gateway PublicKey
-    const [owner, ttl, c, type, prec, gwt, algo, gateway, publickey] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, prec, gwt, algo, gateway, publickey] = bindline.split(/\s+/)
     return new IPSECKEY({
       owner,
       ttl: parseInt(ttl, 10),
@@ -114,32 +114,32 @@ export default class IPSECKEY extends RR {
     })
   }
 
-  fromTinydns(opts) {
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+  fromTinydns({ tinyline }) {
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 45) this.throwHelp('IPSECKEY fromTinydns, invalid n')
 
-    const precedence = TINYDNS.octalToUInt8(rdata.substring(0, 4))
-    const gwType = TINYDNS.octalToUInt8(rdata.substring(4, 8))
-    const algorithm = TINYDNS.octalToUInt8(rdata.substring(8, 12))
+    const precedence = TINYDNS.octalToUInt8(rdata.slice(0, 4))
+    const gwType = TINYDNS.octalToUInt8(rdata.slice(4, 8))
+    const algorithm = TINYDNS.octalToUInt8(rdata.slice(8, 12))
 
     let len, gateway, octalKey
 
     switch (gwType) {
       case 0: // no gateway
-        gateway = rdata.substring(12, 13) // should always be: '.'
-        octalKey = rdata.substring(13)
+        gateway = rdata.slice(12, 13) // should always be: '.'
+        octalKey = rdata.slice(13)
         break
       case 1: // 4-byte IPv4 address
-        gateway = TINYDNS.octalToIPv4(rdata.substring(12, 28))
-        octalKey = rdata.substring(28)
+        gateway = TINYDNS.octalToIPv4(rdata.slice(12, 28))
+        octalKey = rdata.slice(28)
         break
       case 2: // 16-byte IPv6
-        gateway = TINYDNS.octalToHex(rdata.substring(12, 76))
-        octalKey = rdata.substring(76)
+        gateway = TINYDNS.octalToHex(rdata.slice(12, 76))
+        octalKey = rdata.slice(76)
         break
       case 3: // wire encoded domain name
-        ;[gateway, len] = TINYDNS.unpackDomainName(rdata.substring(12))
-        octalKey = rdata.substring(12 + len)
+        ;[gateway, len] = TINYDNS.unpackDomainName(rdata.slice(12))
+        octalKey = rdata.slice(12 + len)
         break
     }
 
@@ -153,7 +153,7 @@ export default class IPSECKEY extends RR {
       gateway,
       publickey: TINYDNS.octalToBase64(octalKey),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 

package/rr/key.js

@@ -1,4 +1,5 @@
 import RR from '../rr.js'
+import * as TINYDNS from '../lib/tinydns.js'
 
 export default class KEY extends RR {
   constructor(opts) {
@@ -64,9 +65,9 @@ export default class KEY extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  KEY Flags Protocol Algorithm PublicKey
-    const [owner, ttl, c, type, flags, protocol, algorithm] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, flags, protocol, algorithm] = bindline.split(/\s+/)
     return new KEY({
       owner,
       ttl: parseInt(ttl, 10),
@@ -75,9 +76,39 @@ export default class KEY extends RR {
       flags: parseInt(flags, 10),
       protocol: parseInt(protocol, 10),
       algorithm: parseInt(algorithm, 10),
-      publickey: opts.bindline.split(/\s+/).slice(7).join(' ').trim(),
+      publickey: bindline.split(/\s+/).slice(7).join(' ').trim(),
+    })
+  }
+
+  fromTinydns({ tinyline }) {
+    // RDATA format: Flags (6 octal chars) + Protocol (3 octal chars) + Algorithm (3 octal chars) + Public Key (escaped data)
+    const [owner, _typeId, rd, ttl, ts, loc] = tinyline.slice(1).split(':')
+    if (rd.length < 12) {
+      this.throwHelp(`KEY: RDATA too short: ${rd}`)
+    }
+
+    return new KEY({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'KEY',
+      flags: TINYDNS.octalToUInt16(rd.slice(0, 6)),
+      protocol: TINYDNS.octalToUInt8(rd.slice(6, 9)),
+      algorithm: TINYDNS.octalToUInt8(rd.slice(9, 12)),
+      publickey: TINYDNS.unescapeOctal(rd.slice(12)),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
     })
   }
 
   /******  EXPORTERS   *******/
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+
+    return this.getTinydnsGeneric(
+      TINYDNS.UInt16toOctal(this.get('flags')) +
+        TINYDNS.UInt8toOctal(this.get('protocol')) +
+        TINYDNS.UInt8toOctal(this.get('algorithm')) +
+        TINYDNS.escapeOctal(dataRe, this.get('publickey')),
+    )
+  }
 }

package/rr/kx.js

@@ -51,9 +51,25 @@ export default class KX extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    // KX via generic, :fqdn:36:rdata:ttl:timestamp:lo
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+    if (n != 36) this.throwHelp('KX fromTinydns, invalid n')
+
+    return new KX({
+      owner: this.fullyQualify(fqdn),
+      ttl: parseInt(ttl, 10),
+      type: 'KX',
+      preference: TINYDNS.octalToUInt16(rdata.slice(0, 8)),
+      exchanger: TINYDNS.unpackDomainName(rdata.slice(8))[0],
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  KX  preference exchanger
-    const [owner, ttl, c, type, preference, exchanger] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, preference, exchanger] = bindline.split(/\s+/)
     return new KX({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/loc.js

@@ -85,22 +85,22 @@ export default class LOC extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // LOC via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 29) this.throwHelp('LOC fromTinydns, invalid n')
 
     // divide by 100 is to convert cm to meters
     const l = {
-      version: TINYDNS.octalToUInt8(rdata.substring(0, 4)),
-      size: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(4, 8))),
+      version: TINYDNS.octalToUInt8(rdata.slice(0, 4)),
+      size: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(4, 8))),
       precision: {
-        horizontal: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(8, 12))),
-        vertical: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(12, 16))),
+        horizontal: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(8, 12))),
+        vertical: this.fromExponent(TINYDNS.octalToUInt8(rdata.slice(12, 16))),
       },
-      latitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(16, 32)), 'lat'),
-      longitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.substring(32, 48)), 'lon'),
-      altitude: TINYDNS.octalToUInt32(rdata.substring(48, 64)) - REF.ALTITUDE,
+      latitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.slice(16, 32)), 'lat'),
+      longitude: this.arcSecToDMS(TINYDNS.octalToUInt32(rdata.slice(32, 48)), 'lon'),
+      altitude: TINYDNS.octalToUInt32(rdata.slice(48, 64)) - REF.ALTITUDE,
     }
 
     return new LOC({
@@ -109,24 +109,24 @@ export default class LOC extends RR {
       address: this.toHuman(l),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
-    const [owner, ttl, c, type] = opts.bindline.split(/\s+/)
+  fromBind({ bindline }) {
+    const [owner, ttl, c, type] = bindline.split(/\s+/)
 
     return new LOC({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
-      address: opts.bindline.split(/\s+/).slice(4).join(' ').trim(),
+      address: bindline.split(/\s+/).slice(4).join(' ').trim(),
     })
   }
 
   dmsToArcSec(obj) {
-    let retval = obj.degrees * CONV.deg + (obj.minutes || 0) * CONV.min + (obj.seconds || 0) * CONV.sec
+    let retval = obj.degrees * CONV.deg + (obj.minutes ?? 0) * CONV.min + (obj.seconds ?? 0) * CONV.sec
     switch (obj.hemisphere.toUpperCase()) {
       case 'W':
       case 'S':

package/rr/mx.js

@@ -53,10 +53,10 @@ export default class MX extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // @fqdn:ip:x:dist:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [owner, ip, x, preference, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [owner, ip, x, preference, ttl, ts, loc] = tinyline.slice(1).split(':')
 
     return new MX({
       type: 'MX',
@@ -65,13 +65,13 @@ export default class MX extends RR {
       preference: parseInt(preference, 10) || 0,
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  MX  preference exchange
-    const [owner, ttl, c, type, preference, exchange] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, preference, exchange] = bindline.split(/\s+/)
 
     return new MX({
       owner,

package/rr/naptr.js

@@ -62,9 +62,9 @@ export default class NAPTR extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // NAPTR via generic, :fqdn:n:rdata:ttl:timestamp:lo
-    const [fqdn, n, rdata, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, n, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
     if (n != 35) this.throwHelp('NAPTR fromTinydns, invalid n')
 
     const binRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
@@ -74,7 +74,7 @@ export default class NAPTR extends RR {
       owner: this.fullyQualify(fqdn),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
       order: binRdata.readUInt16BE(0, 2),
       preference: binRdata.readUInt16BE(2, 4),
     }
@@ -82,7 +82,7 @@ export default class NAPTR extends RR {
     let idx = 4
     const flagsLength = binRdata.readUInt8(idx)
     idx++
-    rec.flags = binRdata.slice(idx, flagsLength).toString()
+    rec.flags = binRdata.slice(idx, idx + flagsLength).toString()
     idx += flagsLength
 
     const serviceLen = binRdata.readUInt8(idx)
@@ -102,26 +102,30 @@ export default class NAPTR extends RR {
     return new NAPTR(rec)
   }
 
-  fromBind(opts) {
-    const str = opts.bindline
-    // test.example.com  3600  IN  NAPTR order, preference, "flags", "service", "regexp", replacement
-    const [owner, ttl, c, type, order, preference] = str.split(/\s+/)
-    const [flags, service, regexp] = str.match(/(?:").*?(?:"\s)/g)
-    const replacement = str.trim().split(/\s+/).pop()
+  fromBind({ bindline }) {
+    const regex =
+      /^(?<owner>\S+)\s+(?<ttl>\d+)\s+(?<class>\S+)\s+(?<type>NAPTR)\s+(?<order>\d+)\s+(?<preference>\d+)\s+["'](?<flags>[^"']*)["']\s+["'](?<service>[^"']*)["']\s+["'](?<regexp>[^"']*)["']\s+(?<replacement>\S+)$/
 
-    const bits = {
-      owner: owner,
+    const match = bindline.trim().match(regex)
+
+    if (!match) {
+      throw new Error(`Invalid NAPTR BIND line: ${bindline}`)
+    }
+
+    const { owner, ttl, type, order, preference, flags, service, regexp, replacement } = match.groups
+
+    return new NAPTR({
+      owner: this.fullyQualify(owner),
       ttl: parseInt(ttl, 10),
-      class: c,
-      type: type,
+      class: match.groups.class,
+      type,
       order: parseInt(order, 10),
       preference: parseInt(preference, 10),
-      flags: flags.trim().replace(/^['"]|['"]$/g, ''),
-      service: service.trim().replace(/^['"]|['"]$/g, ''),
-      regexp: regexp.trim().replace(/^['"]|['"]/g, ''),
-      replacement: replacement,
-    }
-    return new NAPTR(bits)
+      flags,
+      service,
+      regexp,
+      replacement,
+    })
   }
 
   /******  EXPORTERS   *******/

package/rr/ns.js

@@ -34,10 +34,10 @@ export default class NS extends RR {
   }
 
   /******  IMPORTERS   *******/
-  fromTinydns(opts) {
+  fromTinydns({ tinyline }) {
     // &fqdn:ip:x:ttl:timestamp:lo
     // eslint-disable-next-line no-unused-vars
-    const [fqdn, ip, dname, ttl, ts, loc] = opts.tinyline.substring(1).split(':')
+    const [fqdn, ip, dname, ttl, ts, loc] = tinyline.slice(1).split(':')
 
     return new NS({
       type: 'NS',
@@ -45,13 +45,13 @@ export default class NS extends RR {
       dname: this.fullyQualify(/\./.test(dname) ? dname : `${dname}.ns.${fqdn}`),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
-      location: loc !== '' && loc !== '\n' ? loc : '',
+      location: loc?.trim() ?? '',
     })
   }
 
-  fromBind(opts) {
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  NS dname
-    const [owner, ttl, c, type, dname] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, dname] = bindline.split(/\s+/)
 
     return new NS({
       owner,

package/rr/nsec.js

@@ -43,16 +43,32 @@ export default class NSEC extends RR {
 
   /******  IMPORTERS   *******/
 
-  fromBind(opts) {
+  fromTinydns({ tinyline }) {
+    const [owner, _typeId, rdata, ttl, ts, loc] = tinyline.slice(1).split(':')
+    const binaryRdata = Buffer.from(TINYDNS.octalToChar(rdata), 'binary')
+    const [nextDomain, _escapedLen, binaryLen] = TINYDNS.unpackDomainName(rdata)
+
+    return new NSEC({
+      owner: this.fullyQualify(owner),
+      ttl: parseInt(ttl, 10),
+      type: 'NSEC',
+      'next domain': nextDomain,
+      'type bit maps': binaryRdata.slice(binaryLen).toString(),
+      timestamp: ts,
+      location: loc?.trim() ?? '',
+    })
+  }
+
+  fromBind({ bindline }) {
     // test.example.com  3600  IN  NSEC NextDomain TypeBitMaps
-    const [owner, ttl, c, type, next] = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, next] = bindline.split(/\s+/)
     return new NSEC({
       owner,
       ttl: parseInt(ttl, 10),
       class: c,
       type: type,
       'next domain': next,
-      'type bit maps': opts.bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
+      'type bit maps': bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
     })
   }