@nictool/dns-resource-record 1.2.3 → 1.3.0

package/rr/dnskey.js

@@ -12,34 +12,63 @@ export default class DNSKEY extends RR {
     // a 2 octet Flags Field
     this.is16bitInt('DNSKEY', 'flags', val)
 
-    // the possible values are: 0, 256, and 257; RFC 4034
-    if (![0, 256, 257].includes(val)) this.throwHelp(`DNSKEY: flags invalid`)
+    if (!this.getFlagsOptions().has(val)) {
+      this.throwHelp(`DNSKEY: flags must be in the set: ${this.getFlagsOptions()}`)
+    }
 
     this.set('flags', val)
   }
 
+  // possible values are: 0, 256, and 257; RFC 4034
+  getFlagsOptions() {
+    return new Map([[0], [256], [257]])
+  }
+
   setProtocol(val) {
     // 1 octet
     this.is8bitInt('DNSKEY', 'protocol', val)
 
     // The Protocol Field MUST be represented as an unsigned decimal integer with a value of 3.
-    if (![3].includes(val)) this.throwHelp(`DNSKEY: protocol invalid`)
+    if (!this.getProtocolOptions().has(val)) this.throwHelp(`DNSKEY: protocol invalid`)
 
     this.set('protocol', val)
   }
 
+  getProtocolOptions() {
+    return new Map([[3]])
+  }
+
   setAlgorithm(val) {
     // 1 octet
     this.is8bitInt('DNSKEY', 'algorithm', val)
 
     // https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml
-    // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
-    if (![...Array(16).keys(), 253, 254].includes(val))
-      console.error(`DNSKEY: algorithm (${val}) not recognized`)
+    if (!this.getAlgorithmOptions().has(val)) console.error(`DNSKEY: algorithm (${val}) not recognized`)
 
     this.set('algorithm', val)
   }
 
+  getAlgorithmOptions() {
+    return new Map([
+      [1, 'RSA/MD5 (DEPRECATED)'],
+      [2, 'DH'],
+      [3, 'DSA/SHA-1'],
+      [4, 'EC'],
+      [5, 'RSA/SHA-1'],
+      [6, 'DSA-NSEC3-SHA1'],
+      [7, 'RSASHA1-NSEC3-SHA1'],
+      [8, 'RSA/SHA-256'],
+      [9, ''],
+      [10, 'RSA/SHA-512'],
+      [13, 'ECDSA Curve P-256 with SHA-256'],
+      [14, 'ECDSA Curve P-384 with SHA-384'],
+      [15, 'Ed25519'],
+      [16, 'Ed448'],
+      [253],
+      [254],
+    ])
+  }
+
   setPublickey(val) {
     if (!val) this.throwHelp(`DNSKEY: publickey is required`)
 
@@ -66,12 +95,10 @@ export default class DNSKEY extends RR {
 
   fromBind(opts) {
     // test.example.com  3600  IN  DNSKEY Flags Protocol Algorithm PublicKey
-    const match = opts.bindline.match(
-      /^([^\s]+)\s+([0-9]+)\s+(\w+)\s+(\w+)\s+([0-9]+)\s+([0-9]+)\s+([0-9]+)\s+\s*(.*?)\s*$/,
-    )
+    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 [owner, ttl, c, type, flags, protocol, algorithm, publickey] = match.slice(1)
 
     return new DNSKEY({
       owner,

package/rr/ds.js

@@ -17,13 +17,23 @@ export default class DS extends RR {
   }
 
   setAlgorithm(val) {
-    // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
-    if (![1, 2, 3, 4, 5, 253, 254].includes(val))
-      this.throwHelp(`DS: algorithm invalid`)
+    if (!this.getAlgorithmOptions().has(val)) this.throwHelp(`DS: algorithm invalid`)
 
     this.set('algorithm', val)
   }
 
+  getAlgorithmOptions() {
+    return new Map([
+      [1, 'RSA/MD5'],
+      [2, 'DH'],
+      [3, 'DSA/SHA-1'],
+      [4, 'EC'],
+      [5, 'RSA/SHA-1'],
+      [253, ''],
+      [254, ''],
+    ])
+  }
+
   setDigestType(val) {
     if (![1, 2].includes(val)) this.throwHelp(`DS: digest type invalid`)
 
@@ -56,8 +66,7 @@ export default class DS extends RR {
 
   fromBind(opts) {
     // 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] = opts.bindline.split(/\s+/)
     return new DS({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/hinfo.js

@@ -41,11 +41,8 @@ export default class HINFO extends RR {
   /******  IMPORTERS   *******/
   fromBind(opts) {
     // test.example.com  3600  IN  HINFO   DEC-2060 TOPS20
-    const match = opts.bindline
-      .trim()
-      .match(
-        /^([\S]+)\s+([0-9]{1,10})\s+(IN)\s+(HINFO)\s+("[^"]+"|[\S]+)\s+("[^"]+"|[\S]+)/i,
-      )
+    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)
 
@@ -78,10 +75,7 @@ export default class HINFO extends RR {
   /******  EXPORTERS   *******/
   toTinydns() {
     return this.getTinydnsGeneric(
-      [
-        TINYDNS.packString(this.get('cpu')),
-        TINYDNS.packString(this.get('os')),
-      ].join(''),
+      [TINYDNS.packString(this.get('cpu')), TINYDNS.packString(this.get('os'))].join(''),
     )
   }
 }

package/rr/hip.js

@@ -0,0 +1,102 @@
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class HIP extends RR {
+  constructor(opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPkAlgorithm(val) {
+    if (val === undefined) this.throwHelp('HIP: pk algorithm is required')
+    this.is8bitInt('HIP', 'pk algorithm', val)
+    this.set('pk algorithm', val)
+  }
+
+  setHit(val) {
+    if (!val) this.throwHelp('HIP: hit is required')
+    this.set('hit', val)
+  }
+
+  setPublicKey(val) {
+    if (!val) this.throwHelp('HIP: public key is required')
+    this.set('public key', val)
+  }
+
+  setRendezvousServers(val) {
+    this.set('rendezvous servers', val ?? '')
+  }
+
+  getDescription() {
+    return 'Host Identity Protocol'
+  }
+
+  getRdataFields(arg) {
+    return ['pk algorithm', 'hit', 'public key', 'rendezvous servers']
+  }
+
+  getRFCs() {
+    return [8005]
+  }
+
+  getTypeId() {
+    return 55
+  }
+
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'HIP',
+      'pk algorithm': 2,
+      hit: '200100107B1A74DF365639CC39F1D578',
+      'public key':
+        'AwEAAbdxyhNuSutc5EMzxTs9LBPCIkOFH8cIvM4p9+LrV4e19WzK00+CI6zBCQTdtWsuxKbWIy87UOoJTwIXAqcOTiW7iHnQt5hwVAAAAA==',
+      'rendezvous servers': '',
+    }
+  }
+
+  /******  IMPORTERS   *******/
+  fromBind(opts) {
+    // owner  ttl  IN  HIP  pk-algorithm HIT public-key [rendezvous-server...]
+    const parts = opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, pkAlgorithm, hit, publicKey] = parts
+    return new HIP({
+      owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type,
+      'pk algorithm': parseInt(pkAlgorithm, 10),
+      hit,
+      'public key': publicKey,
+      'rendezvous servers': parts.slice(7).join(' ').trim(),
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toBind(zone_opts) {
+    const rs = this.get('rendezvous servers')
+    const rsPart = rs ? `\t${rs}` : ''
+    return `${this.getPrefix(zone_opts)}\t${this.get('pk algorithm')}\t${this.get('hit')}\t${this.get('public key')}${rsPart}\n`
+  }
+
+  toTinydns() {
+    const hitBytes = Buffer.from(this.get('hit'), 'hex')
+    const pkBytes = Buffer.from(this.get('public key'), 'base64')
+    const rs = this.get('rendezvous servers')
+
+    let rdata = ''
+    rdata += TINYDNS.UInt8toOctal(hitBytes.length)
+    rdata += TINYDNS.UInt8toOctal(this.get('pk algorithm'))
+    rdata += TINYDNS.UInt16toOctal(pkBytes.length)
+    for (const b of hitBytes) rdata += TINYDNS.UInt8toOctal(b)
+    for (const b of pkBytes) rdata += TINYDNS.UInt8toOctal(b)
+    if (rs) {
+      for (const name of rs.split(/\s+/)) rdata += TINYDNS.packDomainName(name)
+    }
+
+    return this.getTinydnsGeneric(rdata)
+  }
+}

package/rr/https.js

@@ -1,5 +1,7 @@
 import RR from '../rr.js'
 
+import * as TINYDNS from '../lib/tinydns.js'
+
 export default class HTTPS extends RR {
   constructor(opts) {
     super(opts)
@@ -59,4 +61,14 @@ export default class HTTPS extends RR {
   }
 
   /******  EXPORTERS   *******/
+
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+
+    return this.getTinydnsGeneric(
+      TINYDNS.UInt16toOctal(this.get('priority')) +
+        TINYDNS.packDomainName(this.get('target name')) +
+        TINYDNS.escapeOctal(dataRe, this.get('params')),
+    )
+  }
 }

package/rr/ipseckey.js

@@ -16,23 +16,37 @@ export default class IPSECKEY extends RR {
   }
 
   setGatewayType(val) {
-    // 0 (none), 1 (4-byte IPv4), 2 (16-byte IPv6), 3 (wire encoded domain name)
-    if (![0, 1, 2, 3].includes(val))
-      this.throwHelp(`IPSECKEY: Gateway Type is invalid`)
+    if (!this.getGatewayTypeOptions().has(val)) this.throwHelp(`IPSECKEY: Gateway Type is invalid`)
 
     this.set('gateway type', val)
   }
 
+  getGatewayTypeOptions() {
+    return new Map([
+      [0, 'none'],
+      [1, '4-byte IPv4'],
+      [2, '16-byte IPv6'],
+      [3, 'wire encoded domain name'],
+    ])
+  }
+
   setAlgorithm(val) {
-    // unsigned int, 1 octet, values: 1=DSA, 2=RSA
-    if (![1, 2].includes(val)) this.throwHelp(`IPSECKEY: Algorithm invalid`)
+    if (!this.getAlgorithmOptions().has(val)) this.throwHelp(`IPSECKEY: Algorithm invalid`)
 
     this.set('algorithm', val)
   }
 
+  getAlgorithmOptions() {
+    return new Map([
+      [1, 'DSA'],
+      [2, 'RSA'],
+    ])
+  }
+
   setGateway(val) {
-    const gwErr = new Error(`IPSECKEY: gateway invalid (${val})`)
-    switch (this.get('gateway type')) {
+    const type = this.get('gateway type')
+    const gwErr = new Error(`IPSECKEY: gateway invalid (${val}) for type ${type}`)
+    switch (type) {
       case 0:
         if (val !== '.') throw gwErr
         break
@@ -86,8 +100,7 @@ export default class IPSECKEY extends RR {
   /******  IMPORTERS   *******/
   fromBind(opts) {
     // 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] = opts.bindline.split(/\s+/)
     return new IPSECKEY({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/key.js

@@ -22,13 +22,24 @@ export default class KEY extends RR {
 
   setAlgorithm(val) {
     // 1 octet
-    // 1=RSA/MD5, 2=DH, 3=DSA/SHA-1, 4=EC, 5=RSA/SHA-1
-    if (![1, 2, 3, 4, 5, 253, 254].includes(val))
-      this.throwHelp(`KEY: algorithm invalid`)
+
+    if (!this.getAlgorithmOptions().has(val)) this.throwHelp(`KEY: algorithm invalid`)
 
     this.set('algorithm', val)
   }
 
+  getAlgorithmOptions() {
+    return new Map([
+      [1, 'RSA/MD5'],
+      [2, 'DH'],
+      [3, 'DSA/SHA-1'],
+      [4, 'EC'],
+      [5, 'RSA/SHA-1'],
+      [253, ''],
+      [254, ''],
+    ])
+  }
+
   setPublickey(val) {
     if (!val) this.throwHelp(`KEY: publickey is required`)
 
@@ -55,8 +66,7 @@ export default class KEY extends RR {
 
   fromBind(opts) {
     // 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] = opts.bindline.split(/\s+/)
     return new KEY({
       owner,
       ttl: parseInt(ttl, 10),

package/rr/kx.js

@@ -0,0 +1,77 @@
+import RR from '../rr.js'
+
+import * as TINYDNS from '../lib/tinydns.js'
+
+export default class KX extends RR {
+  constructor(opts) {
+    super(opts)
+  }
+
+  /****** Resource record specific setters   *******/
+  setPreference(val) {
+    if (val === undefined) this.throwHelp('KX: preference is required')
+    this.is16bitInt('KX', 'preference', val)
+    this.set('preference', val)
+  }
+
+  setExchanger(val) {
+    if (!val) this.throwHelp('KX: exchanger is required')
+
+    this.isFullyQualified('KX', 'exchanger', val)
+    this.isValidHostname('KX', 'exchanger', val)
+
+    this.set('exchanger', val.toLowerCase())
+  }
+
+  getDescription() {
+    return 'Key Exchanger'
+  }
+
+  getRdataFields(arg) {
+    return ['preference', 'exchanger']
+  }
+
+  getRFCs() {
+    return [2230]
+  }
+
+  getTypeId() {
+    return 36
+  }
+
+  getCanonical() {
+    return {
+      owner: 'example.com.',
+      ttl: 3600,
+      class: 'IN',
+      type: 'KX',
+      preference: 10,
+      exchanger: 'kx.example.com.',
+    }
+  }
+
+  /******  IMPORTERS   *******/
+  fromBind(opts) {
+    // test.example.com  3600  IN  KX  preference exchanger
+    const [owner, ttl, c, type, preference, exchanger] = opts.bindline.split(/\s+/)
+    return new KX({
+      owner,
+      ttl: parseInt(ttl, 10),
+      class: c,
+      type,
+      preference: parseInt(preference, 10),
+      exchanger,
+    })
+  }
+
+  /******  EXPORTERS   *******/
+  toBind(zone_opts) {
+    return `${this.getPrefix(zone_opts)}\t${this.get('preference')}\t${this.getFQDN('exchanger', zone_opts)}\n`
+  }
+
+  toTinydns() {
+    return this.getTinydnsGeneric(
+      TINYDNS.UInt16toOctal(this.get('preference')) + TINYDNS.packDomainName(this.get('exchanger')),
+    )
+  }
+}

package/rr/loc.js

@@ -53,8 +53,7 @@ export default class LOC extends RR {
     const dms = '(\\d+)\\s+(?:(\\d+)\\s+)?(?:([\\d.]+)\\s+)?'
 
     // alt["m"] [siz["m"] [hp["m"] [vp["m"]]]]
-    const alt =
-      '(-?[\\d.]+)m?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?'
+    const alt = '(-?[\\d.]+)m?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?(?:\\s+([\\d.]+)m?)?'
 
     // put them all together
     const locRe = new RegExp(`^${dms}(N|S)\\s+${dms}(E|W)\\s+${alt}`, 'i')
@@ -96,21 +95,11 @@ export default class LOC extends RR {
       version: TINYDNS.octalToUInt8(rdata.substring(0, 4)),
       size: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(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.substring(8, 12))),
+        vertical: this.fromExponent(TINYDNS.octalToUInt8(rdata.substring(12, 16))),
       },
-      latitude: this.arcSecToDMS(
-        TINYDNS.octalToUInt32(rdata.substring(16, 32)),
-        'lat',
-      ),
-      longitude: this.arcSecToDMS(
-        TINYDNS.octalToUInt32(rdata.substring(32, 48)),
-        'lon',
-      ),
+      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,
     }
 
@@ -137,10 +126,7 @@ export default class LOC extends RR {
   }
 
   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

@@ -16,8 +16,7 @@ export default class MX extends RR {
   setExchange(val) {
     if (!val) this.throwHelp('MX: exchange is required')
 
-    if (this.isIPv4(val) || this.isIPv6(val))
-      this.throwHelp(`MX: exchange must be a FQDN`)
+    if (this.isIPv4(val) || this.isIPv6(val)) this.throwHelp(`MX: exchange must be a FQDN`)
 
     this.isFullyQualified('MX', 'exchange', val)
     this.isValidHostname('MX', 'exchange', val)
@@ -57,9 +56,7 @@ export default class MX extends RR {
   fromTinydns(opts) {
     // @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] = opts.tinyline.substring(1).split(':')
 
     return new MX({
       type: 'MX',
@@ -74,8 +71,7 @@ export default class MX extends RR {
 
   fromBind(opts) {
     // 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] = opts.bindline.split(/\s+/)
 
     return new MX({
       owner,

package/rr/naptr.js

@@ -40,12 +40,15 @@ export default class NAPTR extends RR {
   }
 
   setFlags(val) {
-    if (!['', 'S', 'A', 'U', 'P'].includes(val.toUpperCase()))
-      this.throwHelp(`NAPTR flags are invalid`)
+    if (!this.getFlagsOptions().has(val.toUpperCase())) this.throwHelp(`NAPTR flags are invalid`)
 
     this.set('flags', val.toUpperCase())
   }
 
+  getFlagsOptions() {
+    return new Map([[''], ['S'], ['A'], ['U'], ['P']])
+  }
+
   setService(val) {
     this.set('service', val)
   }

package/rr/ns.js

@@ -37,16 +37,12 @@ export default class NS extends RR {
   fromTinydns(opts) {
     // &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] = opts.tinyline.substring(1).split(':')
 
     return new NS({
       type: 'NS',
       owner: this.fullyQualify(fqdn),
-      dname: this.fullyQualify(
-        /\./.test(dname) ? dname : `${dname}.ns.${fqdn}`,
-      ),
+      dname: this.fullyQualify(/\./.test(dname) ? dname : `${dname}.ns.${fqdn}`),
       ttl: parseInt(ttl, 10),
       timestamp: ts,
       location: loc !== '' && loc !== '\n' ? loc : '',

package/rr/nsec.js

@@ -1,5 +1,7 @@
 import RR from '../rr.js'
 
+import * as TINYDNS from '../lib/tinydns.js'
+
 export default class NSEC extends RR {
   constructor(opts) {
     super(opts)
@@ -50,16 +52,20 @@ export default class NSEC extends RR {
       class: c,
       type: type,
       'next domain': next,
-      'type bit maps': opts.bindline
-        .split(/\s+/)
-        .slice(5)
-        .filter(removeParens)
-        .join(' ')
-        .trim(),
+      'type bit maps': opts.bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
     })
   }
 
   /******  EXPORTERS   *******/
+
+  toTinydns() {
+    const dataRe = new RegExp(/[\r\n\t:\\/]/, 'g')
+
+    return this.getTinydnsGeneric(
+      TINYDNS.packDomainName(this.get('next domain')) +
+        TINYDNS.escapeOctal(dataRe, this.get('type bit maps')),
+    )
+  }
 }
 
 const removeParens = (a) => !['(', ')'].includes(a)

package/rr/nsec3.js

@@ -65,14 +65,7 @@ export default class NSEC3 extends RR {
   }
 
   getRdataFields(arg) {
-    return [
-      'hash algorithm',
-      'flags',
-      'iterations',
-      'salt',
-      'next hashed owner name',
-      'type bit maps',
-    ]
+    return ['hash algorithm', 'flags', 'iterations', 'salt', 'next hashed owner name', 'type bit maps']
   }
 
   getRFCs() {
@@ -87,8 +80,7 @@ export default class NSEC3 extends RR {
 
   fromBind(opts) {
     // test.example.com. 3600 IN NSEC3 1 1 12 aabbccdd (2vptu5timamqttgl4luu9kg21e0aor3s A RRSIG)
-    const [owner, ttl, c, type, ha, flags, iterations, salt] =
-      opts.bindline.split(/\s+/)
+    const [owner, ttl, c, type, ha, flags, iterations, salt] = opts.bindline.split(/\s+/)
     const rdata = opts.bindline.split(/\(|\)/)[1]
 
     return new NSEC3({

package/rr/nxt.js

@@ -50,12 +50,7 @@ export default class NXT extends RR {
       class: c,
       type: type,
       'next domain': next,
-      'type bit map': opts.bindline
-        .split(/\s+/)
-        .slice(5)
-        .filter(removeParens)
-        .join(' ')
-        .trim(),
+      'type bit map': opts.bindline.split(/\s+/).slice(5).filter(removeParens).join(' ').trim(),
     })
   }
 

package/rr/openpgpkey.js

@@ -29,10 +29,9 @@ export default class OPENPGPKEY extends RR {
   /******  IMPORTERS   *******/
   fromBind(obj) {
     // test.example.com  3600  IN  OPENPGPKEY  <base64 public key>
+    const regex = /^([\S]+)\s+(\d{1,10})\s+(IN)\s+(OPENPGPKEY)\s+([\W\w]*)$/
     // eslint-disable-next-line no-unused-vars
-    const [ignore, owner, ttl, c, type, publickey] = obj.bindline
-      .trim()
-      .match(/^([\S]+)\s+(\d{1,10})\s+(IN)\s+(OPENPGPKEY)\s+([\W\w]*)$/)
+    const [ignore, owner, ttl, c, type, publickey] = obj.bindline.trim().match(regex)
 
     return new OPENPGPKEY({
       owner,