compact-encoding 2.16.1 → 2.18.0

package/index.js

@@ -3,16 +3,16 @@ const b4a = require('b4a')
 const { BE } = require('./endian')
 
 exports.state = function (start = 0, end = 0, buffer = null) {
-  return { start, end, buffer, cache: null }
+  return { start, end, buffer }
 }
 
-const raw = exports.raw = require('./raw')
+const raw = (exports.raw = require('./raw'))
 
-const uint = exports.uint = {
-  preencode (state, n) {
+const uint = (exports.uint = {
+  preencode(state, n) {
     state.end += n <= 0xfc ? 1 : n <= 0xffff ? 3 : n <= 0xffffffff ? 5 : 9
   },
-  encode (state, n) {
+  encode(state, n) {
     if (n <= 0xfc) uint8.encode(state, n)
     else if (n <= 0xffff) {
       state.buffer[state.start++] = 0xfd
@@ -25,58 +25,55 @@ const uint = exports.uint = {
       uint64.encode(state, n)
     }
   },
-  decode (state) {
+  decode(state) {
     const a = uint8.decode(state)
     if (a <= 0xfc) return a
     if (a === 0xfd) return uint16.decode(state)
     if (a === 0xfe) return uint32.decode(state)
     return uint64.decode(state)
   }
-}
+})
 
-const uint8 = exports.uint8 = {
-  preencode (state, n) {
+const uint8 = (exports.uint8 = {
+  preencode(state, n) {
     state.end += 1
   },
-  encode (state, n) {
+  encode(state, n) {
     validateUint(n)
     state.buffer[state.start++] = n
   },
-  decode (state) {
+  decode(state) {
     if (state.start >= state.end) throw new Error('Out of bounds')
     return state.buffer[state.start++]
   }
-}
+})
 
-const uint16 = exports.uint16 = {
-  preencode (state, n) {
+const uint16 = (exports.uint16 = {
+  preencode(state, n) {
     state.end += 2
   },
-  encode (state, n) {
+  encode(state, n) {
     validateUint(n)
     state.buffer[state.start++] = n
     state.buffer[state.start++] = n >>> 8
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 2) throw new Error('Out of bounds')
-    return (
-      state.buffer[state.start++] +
-      state.buffer[state.start++] * 0x100
-    )
+    return state.buffer[state.start++] + state.buffer[state.start++] * 0x100
   }
-}
+})
 
-const uint24 = exports.uint24 = {
-  preencode (state, n) {
+const uint24 = (exports.uint24 = {
+  preencode(state, n) {
     state.end += 3
   },
-  encode (state, n) {
+  encode(state, n) {
     validateUint(n)
     state.buffer[state.start++] = n
     state.buffer[state.start++] = n >>> 8
     state.buffer[state.start++] = n >>> 16
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 3) throw new Error('Out of bounds')
     return (
       state.buffer[state.start++] +
@@ -84,20 +81,20 @@ const uint24 = exports.uint24 = {
       state.buffer[state.start++] * 0x10000
     )
   }
-}
+})
 
-const uint32 = exports.uint32 = {
-  preencode (state, n) {
+const uint32 = (exports.uint32 = {
+  preencode(state, n) {
     state.end += 4
   },
-  encode (state, n) {
+  encode(state, n) {
     validateUint(n)
     state.buffer[state.start++] = n
     state.buffer[state.start++] = n >>> 8
     state.buffer[state.start++] = n >>> 16
     state.buffer[state.start++] = n >>> 24
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 4) throw new Error('Out of bounds')
     return (
       state.buffer[state.start++] +
@@ -106,73 +103,73 @@ const uint32 = exports.uint32 = {
       state.buffer[state.start++] * 0x1000000
     )
   }
-}
+})
 
-const uint40 = exports.uint40 = {
-  preencode (state, n) {
+const uint40 = (exports.uint40 = {
+  preencode(state, n) {
     state.end += 5
   },
-  encode (state, n) {
+  encode(state, n) {
     validateUint(n)
     const r = Math.floor(n / 0x100)
     uint8.encode(state, n)
     uint32.encode(state, r)
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 5) throw new Error('Out of bounds')
     return uint8.decode(state) + 0x100 * uint32.decode(state)
   }
-}
+})
 
-const uint48 = exports.uint48 = {
-  preencode (state, n) {
+const uint48 = (exports.uint48 = {
+  preencode(state, n) {
     state.end += 6
   },
-  encode (state, n) {
+  encode(state, n) {
     validateUint(n)
     const r = Math.floor(n / 0x10000)
     uint16.encode(state, n)
     uint32.encode(state, r)
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 6) throw new Error('Out of bounds')
     return uint16.decode(state) + 0x10000 * uint32.decode(state)
   }
-}
+})
 
-const uint56 = exports.uint56 = {
-  preencode (state, n) {
+const uint56 = (exports.uint56 = {
+  preencode(state, n) {
     state.end += 7
   },
-  encode (state, n) {
+  encode(state, n) {
     validateUint(n)
     const r = Math.floor(n / 0x1000000)
     uint24.encode(state, n)
     uint32.encode(state, r)
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 7) throw new Error('Out of bounds')
     return uint24.decode(state) + 0x1000000 * uint32.decode(state)
   }
-}
+})
 
-const uint64 = exports.uint64 = {
-  preencode (state, n) {
+const uint64 = (exports.uint64 = {
+  preencode(state, n) {
     state.end += 8
   },
-  encode (state, n) {
+  encode(state, n) {
     validateUint(n)
     const r = Math.floor(n / 0x100000000)
     uint32.encode(state, n)
     uint32.encode(state, r)
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
     return uint32.decode(state) + 0x100000000 * uint32.decode(state)
   }
-}
+})
 
-const int = exports.int = zigZagInt(uint)
+const int = (exports.int = zigZagInt(uint))
 exports.int8 = zigZagInt(uint8)
 exports.int16 = zigZagInt(uint16)
 exports.int24 = zigZagInt(uint24)
@@ -182,70 +179,95 @@ exports.int48 = zigZagInt(uint48)
 exports.int56 = zigZagInt(uint56)
 exports.int64 = zigZagInt(uint64)
 
-const biguint64 = exports.biguint64 = {
-  preencode (state, n) {
+const biguint64 = (exports.biguint64 = {
+  preencode(state, n) {
     state.end += 8
   },
-  encode (state, n) {
-    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8)
+  encode(state, n) {
+    const view = new DataView(
+      state.buffer.buffer,
+      state.start + state.buffer.byteOffset,
+      8
+    )
     view.setBigUint64(0, n, true) // little endian
     state.start += 8
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
-    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8)
+    const view = new DataView(
+      state.buffer.buffer,
+      state.start + state.buffer.byteOffset,
+      8
+    )
     const n = view.getBigUint64(0, true) // little endian
     state.start += 8
     return n
   }
-}
+})
 
 exports.bigint64 = zigZagBigInt(biguint64)
 
-const biguint = exports.biguint = {
-  preencode (state, n) {
+const biguint = (exports.biguint = {
+  preencode(state, n) {
     let len = 0
     for (let m = n; m; m = m >> 64n) len++
     uint.preencode(state, len)
     state.end += 8 * len
   },
-  encode (state, n) {
+  encode(state, n) {
     let len = 0
     for (let m = n; m; m = m >> 64n) len++
     uint.encode(state, len)
-    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len)
+    const view = new DataView(
+      state.buffer.buffer,
+      state.start + state.buffer.byteOffset,
+      8 * len
+    )
     for (let m = n, i = 0; m; m = m >> 64n, i += 8) {
       view.setBigUint64(i, BigInt.asUintN(64, m), true) // little endian
     }
     state.start += 8 * len
   },
-  decode (state) {
+  decode(state) {
     const len = uint.decode(state)
     if (state.end - state.start < 8 * len) throw new Error('Out of bounds')
-    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8 * len)
+    const view = new DataView(
+      state.buffer.buffer,
+      state.start + state.buffer.byteOffset,
+      8 * len
+    )
     let n = 0n
-    for (let i = len - 1; i >= 0; i--) n = (n << 64n) + view.getBigUint64(i * 8, true) // little endian
+    for (let i = len - 1; i >= 0; i--)
+      n = (n << 64n) + view.getBigUint64(i * 8, true) // little endian
     state.start += 8 * len
     return n
   }
-}
+})
 
 exports.bigint = zigZagBigInt(biguint)
 
 exports.lexint = require('./lexint')
 
 exports.float32 = {
-  preencode (state, n) {
+  preencode(state, n) {
     state.end += 4
   },
-  encode (state, n) {
-    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 4)
+  encode(state, n) {
+    const view = new DataView(
+      state.buffer.buffer,
+      state.start + state.buffer.byteOffset,
+      4
+    )
     view.setFloat32(0, n, true) // little endian
     state.start += 4
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 4) throw new Error('Out of bounds')
-    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 4)
+    const view = new DataView(
+      state.buffer.buffer,
+      state.start + state.buffer.byteOffset,
+      4
+    )
     const float = view.getFloat32(0, true) // little endian
     state.start += 4
     return float
@@ -253,58 +275,66 @@ exports.float32 = {
 }
 
 exports.float64 = {
-  preencode (state, n) {
+  preencode(state, n) {
     state.end += 8
   },
-  encode (state, n) {
-    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8)
+  encode(state, n) {
+    const view = new DataView(
+      state.buffer.buffer,
+      state.start + state.buffer.byteOffset,
+      8
+    )
     view.setFloat64(0, n, true) // little endian
     state.start += 8
   },
-  decode (state) {
+  decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
-    const view = new DataView(state.buffer.buffer, state.start + state.buffer.byteOffset, 8)
+    const view = new DataView(
+      state.buffer.buffer,
+      state.start + state.buffer.byteOffset,
+      8
+    )
     const float = view.getFloat64(0, true) // little endian
     state.start += 8
     return float
   }
 }
 
-const buffer = exports.buffer = {
-  preencode (state, b) {
+const buffer = (exports.buffer = {
+  preencode(state, b) {
     if (b) uint8array.preencode(state, b)
     else state.end++
   },
-  encode (state, b) {
+  encode(state, b) {
     if (b) uint8array.encode(state, b)
     else state.buffer[state.start++] = 0
   },
-  decode (state) {
+  decode(state) {
     const len = uint.decode(state)
     if (len === 0) return null
     if (state.end - state.start < len) throw new Error('Out of bounds')
     return state.buffer.subarray(state.start, (state.start += len))
   }
-}
+})
 
 exports.binary = {
   ...buffer,
-  preencode (state, b) {
+  preencode(state, b) {
     if (typeof b === 'string') utf8.preencode(state, b)
     else buffer.preencode(state, b)
   },
-  encode (state, b) {
+  encode(state, b) {
     if (typeof b === 'string') utf8.encode(state, b)
     else buffer.encode(state, b)
   }
 }
 
 exports.arraybuffer = {
-  preencode (state, b) {
+  preencode(state, b) {
     uint.preencode(state, b.byteLength)
     state.end += b.byteLength
   },
-  encode (state, b) {
+  encode(state, b) {
     uint.encode(state, b.byteLength)
 
     const view = new Uint8Array(b)
@@ -312,27 +342,27 @@ exports.arraybuffer = {
     state.buffer.set(view, state.start)
     state.start += b.byteLength
   },
-  decode (state) {
+  decode(state) {
     const len = uint.decode(state)
 
     const b = new ArrayBuffer(len)
     const view = new Uint8Array(b)
 
-    view.set(state.buffer.subarray(state.start, state.start += len))
+    view.set(state.buffer.subarray(state.start, (state.start += len)))
 
     return b
   }
 }
 
-function typedarray (TypedArray, swap) {
+function typedarray(TypedArray, swap) {
   const n = TypedArray.BYTES_PER_ELEMENT
 
   return {
-    preencode (state, b) {
+    preencode(state, b) {
       uint.preencode(state, b.length)
       state.end += b.byteLength
     },
-    encode (state, b) {
+    encode(state, b) {
       uint.encode(state, b.length)
 
       const view = new Uint8Array(b.buffer, b.byteOffset, b.byteLength)
@@ -342,12 +372,12 @@ function typedarray (TypedArray, swap) {
       state.buffer.set(view, state.start)
       state.start += b.byteLength
     },
-    decode (state) {
+    decode(state) {
       const len = uint.decode(state)
 
-      let b = state.buffer.subarray(state.start, state.start += len * n)
+      let b = state.buffer.subarray(state.start, (state.start += len * n))
       if (b.byteLength !== len * n) throw new Error('Out of bounds')
-      if ((b.byteOffset % n) !== 0) b = new Uint8Array(b)
+      if (b.byteOffset % n !== 0) b = new Uint8Array(b)
 
       if (BE && swap) swap(b)
 
@@ -356,7 +386,7 @@ function typedarray (TypedArray, swap) {
   }
 }
 
-const uint8array = exports.uint8array = typedarray(Uint8Array)
+const uint8array = (exports.uint8array = typedarray(Uint8Array))
 exports.uint16array = typedarray(Uint16Array, b4a.swap16)
 exports.uint32array = typedarray(Uint32Array, b4a.swap32)
 
@@ -370,92 +400,102 @@ exports.bigint64array = typedarray(BigInt64Array, b4a.swap64)
 exports.float32array = typedarray(Float32Array, b4a.swap32)
 exports.float64array = typedarray(Float64Array, b4a.swap64)
 
-function string (encoding) {
+function string(encoding) {
   return {
-    preencode (state, s) {
+    preencode(state, s) {
       const len = b4a.byteLength(s, encoding)
       uint.preencode(state, len)
       state.end += len
     },
-    encode (state, s) {
+    encode(state, s) {
       const len = b4a.byteLength(s, encoding)
       uint.encode(state, len)
       b4a.write(state.buffer, s, state.start, encoding)
       state.start += len
     },
-    decode (state) {
+    decode(state) {
       const len = uint.decode(state)
       if (state.end - state.start < len) throw new Error('Out of bounds')
-      return b4a.toString(state.buffer, encoding, state.start, (state.start += len))
+      return b4a.toString(
+        state.buffer,
+        encoding,
+        state.start,
+        (state.start += len)
+      )
     },
-    fixed (n) {
+    fixed(n) {
       return {
-        preencode (state) {
+        preencode(state) {
           state.end += n
         },
-        encode (state, s) {
+        encode(state, s) {
           b4a.write(state.buffer, s, state.start, n, encoding)
           state.start += n
         },
-        decode (state) {
+        decode(state) {
           if (state.end - state.start < n) throw new Error('Out of bounds')
-          return b4a.toString(state.buffer, encoding, state.start, (state.start += n))
+          return b4a.toString(
+            state.buffer,
+            encoding,
+            state.start,
+            (state.start += n)
+          )
         }
       }
     }
   }
 }
 
-const utf8 = exports.string = exports.utf8 = string('utf-8')
+const utf8 = (exports.string = exports.utf8 = string('utf-8'))
 exports.ascii = string('ascii')
 exports.hex = string('hex')
 exports.base64 = string('base64')
 exports.ucs2 = exports.utf16le = string('utf16le')
 
 exports.bool = {
-  preencode (state, b) {
+  preencode(state, b) {
     state.end++
   },
-  encode (state, b) {
+  encode(state, b) {
     state.buffer[state.start++] = b ? 1 : 0
   },
-  decode (state) {
+  decode(state) {
     if (state.start >= state.end) throw Error('Out of bounds')
     return state.buffer[state.start++] === 1
   }
 }
 
-const fixed = exports.fixed = function fixed (n) {
+const fixed = (exports.fixed = function fixed(n) {
   return {
-    preencode (state, s) {
+    preencode(state, s) {
       if (s.byteLength !== n) throw new Error('Incorrect buffer size')
       state.end += n
     },
-    encode (state, s) {
+    encode(state, s) {
       state.buffer.set(s, state.start)
       state.start += n
     },
-    decode (state) {
+    decode(state) {
       if (state.end - state.start < n) throw new Error('Out of bounds')
       return state.buffer.subarray(state.start, (state.start += n))
     }
   }
-}
+})
 
 exports.fixed32 = fixed(32)
 exports.fixed64 = fixed(64)
 
-exports.array = function array (enc) {
+exports.array = function array(enc) {
   return {
-    preencode (state, list) {
+    preencode(state, list) {
       uint.preencode(state, list.length)
       for (let i = 0; i < list.length; i++) enc.preencode(state, list[i])
     },
-    encode (state, list) {
+    encode(state, list) {
       uint.encode(state, list.length)
       for (let i = 0; i < list.length; i++) enc.encode(state, list[i])
     },
-    decode (state) {
+    decode(state) {
       const len = uint.decode(state)
       if (len > 0x100000) throw new Error('Array is too big')
       const arr = new Array(len)
@@ -465,22 +505,22 @@ exports.array = function array (enc) {
   }
 }
 
-exports.frame = function frame (enc) {
+exports.frame = function frame(enc) {
   const dummy = exports.state()
 
   return {
-    preencode (state, m) {
+    preencode(state, m) {
       const end = state.end
       enc.preencode(state, m)
       uint.preencode(state, state.end - end)
     },
-    encode (state, m) {
+    encode(state, m) {
       dummy.end = 0
       enc.preencode(dummy, m)
       uint.encode(state, dummy.end)
       enc.encode(state, m)
     },
-    decode (state) {
+    decode(state) {
       const end = state.end
       const len = uint.decode(state)
       state.end = state.start + len
@@ -493,50 +533,50 @@ exports.frame = function frame (enc) {
 }
 
 exports.date = {
-  preencode (state, d) {
+  preencode(state, d) {
     int.preencode(state, d.getTime())
   },
-  encode (state, d) {
+  encode(state, d) {
     int.encode(state, d.getTime())
   },
-  decode (state, d) {
+  decode(state, d) {
     return new Date(int.decode(state))
   }
 }
 
 exports.json = {
-  preencode (state, v) {
+  preencode(state, v) {
     utf8.preencode(state, JSON.stringify(v))
   },
-  encode (state, v) {
+  encode(state, v) {
     utf8.encode(state, JSON.stringify(v))
   },
-  decode (state) {
+  decode(state) {
     return JSON.parse(utf8.decode(state))
   }
 }
 
 exports.ndjson = {
-  preencode (state, v) {
+  preencode(state, v) {
     utf8.preencode(state, JSON.stringify(v) + '\n')
   },
-  encode (state, v) {
+  encode(state, v) {
     utf8.encode(state, JSON.stringify(v) + '\n')
   },
-  decode (state) {
+  decode(state) {
     return JSON.parse(utf8.decode(state))
   }
 }
 
 // simple helper for when you want to just express nothing
 exports.none = {
-  preencode (state, n) {
+  preencode(state, n) {
     // do nothing
   },
-  encode (state, n) {
+  encode(state, n) {
     // do nothing
   },
-  decode (state) {
+  decode(state) {
     return null
   }
 }
@@ -544,19 +584,19 @@ exports.none = {
 // "any" encoders here for helping just structure any object without schematising it
 
 const anyArray = {
-  preencode (state, arr) {
+  preencode(state, arr) {
     uint.preencode(state, arr.length)
     for (let i = 0; i < arr.length; i++) {
       any.preencode(state, arr[i])
     }
   },
-  encode (state, arr) {
+  encode(state, arr) {
     uint.encode(state, arr.length)
     for (let i = 0; i < arr.length; i++) {
       any.encode(state, arr[i])
     }
   },
-  decode (state) {
+  decode(state) {
     const arr = []
     let len = uint.decode(state)
     while (len-- > 0) {
@@ -567,7 +607,7 @@ const anyArray = {
 }
 
 const anyObject = {
-  preencode (state, o) {
+  preencode(state, o) {
     const keys = Object.keys(o)
     uint.preencode(state, keys.length)
     for (const key of keys) {
@@ -575,7 +615,7 @@ const anyObject = {
       any.preencode(state, o[key])
     }
   },
-  encode (state, o) {
+  encode(state, o) {
     const keys = Object.keys(o)
     uint.encode(state, keys.length)
     for (const key of keys) {
@@ -583,7 +623,7 @@ const anyObject = {
       any.encode(state, o[key])
     }
   },
-  decode (state) {
+  decode(state) {
     let len = uint.decode(state)
     const o = {}
     while (len-- > 0) {
@@ -607,25 +647,218 @@ const anyTypes = [
   exports.date
 ]
 
-const any = exports.any = {
-  preencode (state, o) {
+const any = (exports.any = {
+  preencode(state, o) {
     const t = getType(o)
     uint.preencode(state, t)
     anyTypes[t].preencode(state, o)
   },
-  encode (state, o) {
+  encode(state, o) {
     const t = getType(o)
     uint.encode(state, t)
     anyTypes[t].encode(state, o)
   },
-  decode (state) {
+  decode(state) {
     const t = uint.decode(state)
     if (t >= anyTypes.length) throw new Error('Unknown type: ' + t)
     return anyTypes[t].decode(state)
   }
+})
+
+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) {
+function getType(o) {
   if (o === null || o === undefined) return 0
   if (typeof o === 'boolean') return 1
   if (typeof o === 'string') return 2
@@ -641,61 +874,69 @@ function getType (o) {
   throw new Error('Unsupported type for ' + o)
 }
 
-exports.from = function from (enc) {
+exports.from = function from(enc) {
   if (typeof enc === 'string') return fromNamed(enc)
   if (enc.preencode) return enc
   if (enc.encodingLength) return fromAbstractEncoder(enc)
   return fromCodec(enc)
 }
 
-function fromNamed (enc) {
+function fromNamed(enc) {
   switch (enc) {
-    case 'ascii': return raw.ascii
+    case 'ascii':
+      return raw.ascii
     case 'utf-8':
-    case 'utf8': return raw.utf8
-    case 'hex': return raw.hex
-    case 'base64': return raw.base64
+    case 'utf8':
+      return raw.utf8
+    case 'hex':
+      return raw.hex
+    case 'base64':
+      return raw.base64
     case 'utf16-le':
     case 'utf16le':
     case 'ucs-2':
-    case 'ucs2': return raw.ucs2
-    case 'ndjson': return raw.ndjson
-    case 'json': return raw.json
+    case 'ucs2':
+      return raw.ucs2
+    case 'ndjson':
+      return raw.ndjson
+    case 'json':
+      return raw.json
     case 'binary':
-    default: return raw.binary
+    default:
+      return raw.binary
   }
 }
 
-function fromCodec (enc) {
+function fromCodec(enc) {
   let tmpM = null
   let tmpBuf = null
 
   return {
-    preencode (state, m) {
+    preencode(state, m) {
       tmpM = m
       tmpBuf = enc.encode(m)
       state.end += tmpBuf.byteLength
     },
-    encode (state, m) {
+    encode(state, m) {
       raw.encode(state, m === tmpM ? tmpBuf : enc.encode(m))
       tmpM = tmpBuf = null
     },
-    decode (state) {
+    decode(state) {
       return enc.decode(raw.decode(state))
     }
   }
 }
 
-function fromAbstractEncoder (enc) {
+function fromAbstractEncoder(enc) {
   return {
-    preencode (state, m) {
+    preencode(state, m) {
       state.end += enc.encodingLength(m)
     },
-    encode (state, m) {
+    encode(state, m) {
       enc.encode(m, state.buffer, state.start)
       state.start += enc.encode.bytes
     },
-    decode (state) {
+    decode(state) {
       const m = enc.decode(state.buffer, state.start, state.end)
       state.start += enc.decode.bytes
       return m
@@ -703,7 +944,7 @@ function fromAbstractEncoder (enc) {
   }
 }
 
-exports.encode = function encode (enc, m) {
+exports.encode = function encode(enc, m) {
   const state = exports.state()
   enc.preencode(state, m)
   state.buffer = b4a.allocUnsafe(state.end)
@@ -711,56 +952,57 @@ exports.encode = function encode (enc, m) {
   return state.buffer
 }
 
-exports.decode = function decode (enc, buffer) {
+exports.decode = function decode(enc, buffer) {
   return enc.decode(exports.state(0, buffer.byteLength, buffer))
 }
 
-function zigZagInt (enc) {
+function zigZagInt(enc) {
   return {
-    preencode (state, n) {
+    preencode(state, n) {
       enc.preencode(state, zigZagEncodeInt(n))
     },
-    encode (state, n) {
+    encode(state, n) {
       enc.encode(state, zigZagEncodeInt(n))
     },
-    decode (state) {
+    decode(state) {
       return zigZagDecodeInt(enc.decode(state))
     }
   }
 }
 
-function zigZagDecodeInt (n) {
+function zigZagDecodeInt(n) {
   return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2
 }
 
-function zigZagEncodeInt (n) {
+function zigZagEncodeInt(n) {
   // 0, -1, 1, -2, 2, ...
-  return n < 0 ? (2 * -n) - 1 : n === 0 ? 0 : 2 * n
+  return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n
 }
 
-function zigZagBigInt (enc) {
+function zigZagBigInt(enc) {
   return {
-    preencode (state, n) {
+    preencode(state, n) {
       enc.preencode(state, zigZagEncodeBigInt(n))
     },
-    encode (state, n) {
+    encode(state, n) {
       enc.encode(state, zigZagEncodeBigInt(n))
     },
-    decode (state) {
+    decode(state) {
       return zigZagDecodeBigInt(enc.decode(state))
     }
   }
 }
 
-function zigZagDecodeBigInt (n) {
+function zigZagDecodeBigInt(n) {
   return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n
 }
 
-function zigZagEncodeBigInt (n) {
+function zigZagEncodeBigInt(n) {
   // 0, -1, 1, -2, 2, ...
-  return n < 0n ? (2n * -n) - 1n : n === 0n ? 0n : 2n * n
+  return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n
 }
 
-function validateUint (n) {
-  if ((n >= 0) === false /* Handles NaN as well */) throw new Error('uint must be positive')
+function validateUint(n) {
+  if (n >= 0 === false /* Handles NaN as well */)
+    throw new Error('uint must be positive')
 }