compact-encoding 2.16.1 → 2.17.0

package/README.md

@@ -76,7 +76,7 @@ The following encodings are bundled as they are primitives that can be used
 to build others on top. Feel free to PR more that are missing.
 
 * `cenc.raw` - Pass through encodes a buffer, i.e. a basic copy.
-* `cenc.uint` - Encodes a uint using [compact-uint](https://github.com/mafintosh/compact-uint).
+* `cenc.uint` - Encodes a uint using the smallest fixed size encoding with a prefix to signal which one. Useful for uints that can be a wide range of values.
 * `cenc.uint8` - Encodes a fixed size uint8.
 * `cenc.uint16` - Encodes a fixed size uint16. Useful for things like ports.
 * `cenc.uint24` - Encodes a fixed size uint24. Useful for message framing.
@@ -151,6 +151,13 @@ to build others on top. Feel free to PR more that are missing.
 * `cenc.ndjson` - Encodes a JSON value as newline delimited utf-8.
 * `cenc.raw.ndjson` - Encodes a JSON value as newline delimited utf-8 without a length prefixed.
 * `cenc.any` - Encodes any JSON representable value into a self described buffer. Like JSON + buffer, but using compact types. Useful for schemaless codecs.
+* `cenc.port` - Encodes a port number for network addresses.
+* `cenc.ipv4` - Encodes an IPv4 network address.
+* `cenc.ipv4Address` Encodes an IPv4 network address and a port number.
+* `cenc.ipv6` - Encodes an IPv6 network address.
+* `cenc.ipv6Address` Encodes an IPv6 network address and a port number.
+* `cenc.ip` - Encodes a dual IPv4/6 network address.
+* `cenc.ipAddress` Encodes a dual IPv4/6 network address and a port number.
 * `cenc.from(enc)` - Makes a compact encoder from a [codec](https://github.com/mafintosh/codecs) or [abstract-encoding](https://github.com/mafintosh/abstract-encoding).
 * `cenc.none` - Helper for when you want to just express nothing
 

package/index.js

@@ -625,6 +625,159 @@ const any = exports.any = {
   }
 }
 
+const port = exports.port = uint16
+
+const address = (host, family) => {
+  return {
+    preencode (state, m) {
+      host.preencode(state, m.host)
+      port.preencode(state, m.port)
+    },
+    encode (state, m) {
+      host.encode(state, m.host)
+      port.encode(state, m.port)
+    },
+    decode (state) {
+      return {
+        host: host.decode(state),
+        family,
+        port: port.decode(state)
+      }
+    }
+  }
+}
+
+const ipv4 = exports.ipv4 = {
+  preencode (state) {
+    state.end += 4
+  },
+  encode (state, string) {
+    const start = state.start
+    const end = start + 4
+
+    let i = 0
+
+    while (i < string.length) {
+      let n = 0
+      let c
+
+      while (i < string.length && (c = string.charCodeAt(i++)) !== /* . */ 0x2e) {
+        n = n * 10 + (c - /* 0 */ 0x30)
+      }
+
+      state.buffer[state.start++] = n
+    }
+
+    state.start = end
+  },
+  decode (state) {
+    if (state.end - state.start < 4) throw new Error('Out of bounds')
+    return (
+      state.buffer[state.start++] + '.' +
+      state.buffer[state.start++] + '.' +
+      state.buffer[state.start++] + '.' +
+      state.buffer[state.start++]
+    )
+  }
+}
+
+exports.ipv4Address = address(ipv4, 4)
+
+const ipv6 = exports.ipv6 = {
+  preencode (state) {
+    state.end += 16
+  },
+  encode (state, string) {
+    const start = state.start
+    const end = start + 16
+
+    let i = 0
+    let split = null
+
+    while (i < string.length) {
+      let n = 0
+      let c
+
+      while (i < string.length && (c = string.charCodeAt(i++)) !== /* : */ 0x3a) {
+        if (c >= 0x30 && c <= 0x39) n = n * 0x10 + (c - /* 0 */ 0x30)
+        else if (c >= 0x41 && c <= 0x46) n = n * 0x10 + (c - /* A */ 0x41 + 10)
+        else if (c >= 0x61 && c <= 0x66) n = n * 0x10 + (c - /* a */ 0x61 + 10)
+      }
+
+      state.buffer[state.start++] = n >>> 8
+      state.buffer[state.start++] = n
+
+      if (i < string.length && string.charCodeAt(i) === /* : */ 0x3a) {
+        i++
+        split = state.start
+      }
+    }
+
+    if (split !== null) {
+      const offset = end - state.start
+      state.buffer
+        .copyWithin(split + offset, split)
+        .fill(0, split, split + offset)
+    }
+
+    state.start = end
+  },
+  decode (state) {
+    if (state.end - state.start < 16) throw new Error('Out of bounds')
+    return (
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ':' +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ':' +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ':' +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ':' +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ':' +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ':' +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16) + ':' +
+      (state.buffer[state.start++] * 256 + state.buffer[state.start++]).toString(16)
+    )
+  }
+}
+
+exports.ipv6Address = address(ipv6, 6)
+
+const ip = exports.ip = {
+  preencode (state, string) {
+    const family = string.includes(':') ? 6 : 4
+    uint8.preencode(state, family)
+    if (family === 4) ipv4.preencode(state)
+    else ipv6.preencode(state)
+  },
+  encode (state, string) {
+    const family = string.includes(':') ? 6 : 4
+    uint8.encode(state, family)
+    if (family === 4) ipv4.encode(state, string)
+    else ipv6.encode(state, string)
+  },
+  decode (state) {
+    const family = uint8.decode(state)
+    if (family === 4) return ipv4.decode(state)
+    else return ipv6.decode(state)
+  }
+}
+
+exports.ipAddress = {
+  preencode (state, m) {
+    ip.preencode(state, m.host)
+    port.preencode(state, m.port)
+  },
+  encode (state, m) {
+    ip.encode(state, m.host)
+    port.encode(state, m.port)
+  },
+  decode (state) {
+    const family = uint8.decode(state)
+    return {
+      host: family === 4 ? ipv4.decode(state) : ipv6.decode(state),
+      family,
+      port: port.decode(state)
+    }
+  }
+}
+
 function getType (o) {
   if (o === null || o === undefined) return 0
   if (typeof o === 'boolean') return 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "compact-encoding",
-  "version": "2.16.1",
+  "version": "2.17.0",
   "description": "A series of compact encoding schemes for building small and fast parsers and serializers",
   "main": "index.js",
   "dependencies": {

package/test.js

@@ -841,3 +841,127 @@ test('framed', function (t) {
   t.alike(enc.encode(e, 4200), b4a.from([0x03, 0xfd, 0x68, 0x10]))
   t.alike(enc.decode(e, b4a.from([0x03, 0xfd, 0x68, 0x10])), 4200)
 })
+
+test('port', function (t) {
+  const p = 0x1234
+  const buf = Buffer.from([0x34, 0x12])
+
+  t.alike(enc.encode(enc.port, p), buf)
+  t.alike(enc.decode(enc.port, buf), p)
+})
+
+test('ipv4', function (t) {
+  const ip = '1.2.3.4'
+  const buf = Buffer.from([1, 2, 3, 4])
+
+  t.alike(enc.encode(enc.ipv4, ip), buf)
+  t.alike(enc.decode(enc.ipv4, buf), ip)
+})
+
+test('ipv4 + port', function (t) {
+  const host = '1.2.3.4'
+  const port = 1234
+
+  t.alike(enc.decode(enc.ipv4Address, enc.encode(enc.ipv4Address, { host, port })), {
+    host,
+    family: 4,
+    port
+  })
+})
+
+test('ipv6', function (t) {
+  const ip = '1:2:3:4:5:6:7:8'
+  const buf = Buffer.from([0, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8])
+
+  t.alike(enc.encode(enc.ipv6, ip), buf)
+  t.alike(enc.decode(enc.ipv6, buf), ip)
+
+  t.test('abbreviated', function (t) {
+    const buf = Buffer.from([0, 1, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 8])
+
+    t.alike(enc.encode(enc.ipv6, '1:2::7:8'), buf)
+    t.alike(enc.decode(enc.ipv6, buf), '1:2:0:0:0:0:7:8')
+  })
+
+  t.test('prefix abbreviated', function (t) {
+    const buf = Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 6, 0, 7, 0, 8])
+
+    t.alike(enc.encode(enc.ipv6, '::5:6:7:8'), buf)
+    t.alike(enc.decode(enc.ipv6, buf), '0:0:0:0:5:6:7:8')
+  })
+
+  t.test('suffix abbreviated', function (t) {
+    const buf = Buffer.from([0, 1, 0, 2, 0, 3, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0])
+
+    t.alike(enc.encode(enc.ipv6, '1:2:3:4::'), buf)
+    t.alike(enc.decode(enc.ipv6, buf), '1:2:3:4:0:0:0:0')
+  })
+
+  t.test('any', function (t) {
+    const buf = Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])
+
+    t.alike(enc.encode(enc.ipv6, '::'), buf)
+    t.alike(enc.decode(enc.ipv6, buf), '0:0:0:0:0:0:0:0')
+  })
+
+  t.test('lowercase hex', function (t) {
+    const buf = Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xab, 0xcd])
+
+    t.alike(enc.encode(enc.ipv6, '::abcd'), buf)
+    t.alike(enc.decode(enc.ipv6, buf), '0:0:0:0:0:0:0:abcd')
+  })
+
+  t.test('uppercase hex', function (t) {
+    const buf = Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xab, 0xcd])
+
+    t.alike(enc.encode(enc.ipv6, '::ABCD'), buf)
+    t.alike(enc.decode(enc.ipv6, buf), '0:0:0:0:0:0:0:abcd')
+  })
+})
+
+test('ipv6 + port', function (t) {
+  const host = '1:2:3:4:5:6:7:8'
+  const port = 1234
+
+  t.alike(enc.decode(enc.ipv6Address, enc.encode(enc.ipv6Address, { host, port })), {
+    host,
+    family: 6,
+    port
+  })
+})
+
+test('dual ip', function (t) {
+  {
+    const host = '1.2.3.4'
+
+    t.alike(enc.decode(enc.ip, enc.encode(enc.ip, host)), host, 'ipv4')
+  }
+  {
+    const host = '1:2:3:4:5:6:7:8'
+
+    t.alike(enc.decode(enc.ip, enc.encode(enc.ip, host)), host, 'ipv6')
+  }
+})
+
+test('dual ip + port', function (t) {
+  const port = 1234
+
+  {
+    const host = '1.2.3.4'
+
+    t.alike(enc.decode(enc.ipAddress, enc.encode(enc.ipAddress, { host, port })), {
+      host,
+      family: 4,
+      port
+    }, 'ipv4')
+  }
+  {
+    const host = '1:2:3:4:5:6:7:8'
+
+    t.alike(enc.decode(enc.ipAddress, enc.encode(enc.ipAddress, { host, port })), {
+      host,
+      family: 6,
+      port
+    }, 'ipv6')
+  }
+})