compact-encoding 2.14.0 → 2.15.1

package/README.md

@@ -94,7 +94,10 @@ to build others on top. Feel free to PR more that are missing.
 * `cenc.int48` - Encodes a fixed size int48 using `cenc.uint48` with ZigZag encoding.
 * `cenc.int56` - Encodes a fixed size int56 using `cenc.uint56` with ZigZag encoding.
 * `cenc.int64` - Encodes a fixed size int64 using `cenc.uint64` with ZigZag encoding.
-* `cenc.lexint` - Encodes an int using [lexicographic-integer](https://github.com/substack/lexicographic-integer) encoding so that encoded values are lexicographically sorted in ascending numerical order.
+* `cenc.biguint64` - Encodes a fixed size biguint64.
+* `cenc.bigint64` - Encodes a fixed size bigint64 using `cenc.biguint64` with ZigZag encoding.
+* `cenc.biguint` - Encodes a biguint with its word count uint prefixed.
+* `cenc.bigint` - Encodes a bigint using `cenc.biguint` with ZigZag encoding.
 * `cenc.float32` - Encodes a fixed size float32.
 * `cenc.float64` - Encodes a fixed size float64.
 * `cenc.buffer` - Encodes a buffer with its length uint prefixed. When decoding an empty buffer, `null` is returned.
@@ -113,6 +116,10 @@ to build others on top. Feel free to PR more that are missing.
 * `cenc.raw.int16array` - Encodes a int16array without a length prefixed.
 * `cenc.int32array` - Encodes a int32array with its element length uint prefixed.
 * `cenc.raw.int32array` - Encodes a int32array without a length prefixed.
+* `cenc.biguint64array` - Encodes a biguint64array with its element length uint prefixed.
+* `cenc.raw.biguint64array` - Encodes a biguint64array without a length prefixed.
+* `cenc.bigint64array` - Encodes a bigint64array with its element length uint prefixed.
+* `cenc.raw.bigint64array` - Encodes a bigint64array without a length prefixed.
 * `cenc.float32array` - Encodes a float32array with its element length uint prefixed.
 * `cenc.raw.float32array` - Encodes a float32array without a length prefixed.
 * `cenc.float64array` - Encodes a float64array with its element length uint prefixed.
@@ -144,6 +151,7 @@ to build others on top. Feel free to PR more that are missing.
 * `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.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
 
 ## License
 

package/index.js

@@ -39,6 +39,7 @@ const uint8 = exports.uint8 = {
     state.end += 1
   },
   encode (state, n) {
+    validateUint(n)
     state.buffer[state.start++] = n
   },
   decode (state) {
@@ -52,6 +53,7 @@ const uint16 = exports.uint16 = {
     state.end += 2
   },
   encode (state, n) {
+    validateUint(n)
     state.buffer[state.start++] = n
     state.buffer[state.start++] = n >>> 8
   },
@@ -69,6 +71,7 @@ const uint24 = exports.uint24 = {
     state.end += 3
   },
   encode (state, n) {
+    validateUint(n)
     state.buffer[state.start++] = n
     state.buffer[state.start++] = n >>> 8
     state.buffer[state.start++] = n >>> 16
@@ -88,6 +91,7 @@ const uint32 = exports.uint32 = {
     state.end += 4
   },
   encode (state, n) {
+    validateUint(n)
     state.buffer[state.start++] = n
     state.buffer[state.start++] = n >>> 8
     state.buffer[state.start++] = n >>> 16
@@ -109,6 +113,7 @@ const uint40 = exports.uint40 = {
     state.end += 5
   },
   encode (state, n) {
+    validateUint(n)
     const r = Math.floor(n / 0x100)
     uint8.encode(state, n)
     uint32.encode(state, r)
@@ -124,6 +129,7 @@ const uint48 = exports.uint48 = {
     state.end += 6
   },
   encode (state, n) {
+    validateUint(n)
     const r = Math.floor(n / 0x10000)
     uint16.encode(state, n)
     uint32.encode(state, r)
@@ -139,6 +145,7 @@ const uint56 = exports.uint56 = {
     state.end += 7
   },
   encode (state, n) {
+    validateUint(n)
     const r = Math.floor(n / 0x1000000)
     uint24.encode(state, n)
     uint32.encode(state, r)
@@ -154,6 +161,7 @@ const uint64 = exports.uint64 = {
     state.end += 8
   },
   encode (state, n) {
+    validateUint(n)
     const r = Math.floor(n / 0x100000000)
     uint32.encode(state, n)
     uint32.encode(state, r)
@@ -164,15 +172,65 @@ const uint64 = exports.uint64 = {
   }
 }
 
-exports.int = zigZag(uint)
-exports.int8 = zigZag(uint8)
-exports.int16 = zigZag(uint16)
-exports.int24 = zigZag(uint24)
-exports.int32 = zigZag(uint32)
-exports.int40 = zigZag(uint40)
-exports.int48 = zigZag(uint48)
-exports.int56 = zigZag(uint56)
-exports.int64 = zigZag(uint64)
+exports.int = zigZagInt(uint)
+exports.int8 = zigZagInt(uint8)
+exports.int16 = zigZagInt(uint16)
+exports.int24 = zigZagInt(uint24)
+exports.int32 = zigZagInt(uint32)
+exports.int40 = zigZagInt(uint40)
+exports.int48 = zigZagInt(uint48)
+exports.int56 = zigZagInt(uint56)
+exports.int64 = zigZagInt(uint64)
+
+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)
+    view.setBigUint64(0, n, true) // little endian
+    state.start += 8
+  },
+  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 n = view.getBigUint64(0, true) // little endian
+    state.start += 8
+    return n
+  }
+}
+
+exports.bigint64 = zigZagBigInt(biguint64)
+
+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) {
+    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)
+    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) {
+    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)
+    let n = 0n
+    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')
 
@@ -306,6 +364,9 @@ exports.int8array = typedarray(Int8Array)
 exports.int16array = typedarray(Int16Array, b4a.swap16)
 exports.int32array = typedarray(Int32Array, b4a.swap32)
 
+exports.biguint64array = typedarray(BigUint64Array, b4a.swap64)
+exports.bigint64array = typedarray(BigInt64Array, b4a.swap64)
+
 exports.float32array = typedarray(Float32Array, b4a.swap32)
 exports.float64array = typedarray(Float64Array, b4a.swap64)
 
@@ -367,6 +428,7 @@ exports.bool = {
 const fixed = exports.fixed = function fixed (n) {
   return {
     preencode (state, s) {
+      if (s.byteLength !== n) throw new Error('Incorrect buffer size')
       state.end += n
     },
     encode (state, s) {
@@ -639,25 +701,52 @@ exports.decode = function decode (enc, buffer) {
   return enc.decode(exports.state(0, buffer.byteLength, buffer))
 }
 
-function zigZag (enc) {
+function zigZagInt (enc) {
   return {
     preencode (state, n) {
-      enc.preencode(state, zigZagEncode(n))
+      enc.preencode(state, zigZagEncodeInt(n))
     },
     encode (state, n) {
-      enc.encode(state, zigZagEncode(n))
+      enc.encode(state, zigZagEncodeInt(n))
     },
     decode (state) {
-      return zigZagDecode(enc.decode(state))
+      return zigZagDecodeInt(enc.decode(state))
     }
   }
 }
 
-function zigZagDecode (n) {
+function zigZagDecodeInt (n) {
   return n === 0 ? n : (n & 1) === 0 ? n / 2 : -(n + 1) / 2
 }
 
-function zigZagEncode (n) {
+function zigZagEncodeInt (n) {
   // 0, -1, 1, -2, 2, ...
   return n < 0 ? (2 * -n) - 1 : n === 0 ? 0 : 2 * n
 }
+
+function zigZagBigInt (enc) {
+  return {
+    preencode (state, n) {
+      enc.preencode(state, zigZagEncodeBigInt(n))
+    },
+    encode (state, n) {
+      enc.encode(state, zigZagEncodeBigInt(n))
+    },
+    decode (state) {
+      return zigZagDecodeBigInt(enc.decode(state))
+    }
+  }
+}
+
+function zigZagDecodeBigInt (n) {
+  return n === 0n ? n : (n & 1n) === 0n ? n / 2n : -(n + 1n) / 2n
+}
+
+function zigZagEncodeBigInt (n) {
+  // 0, -1, 1, -2, 2, ...
+  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')
+}

package/package.json

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

package/raw.js

@@ -104,6 +104,9 @@ exports.int8array = typedarray(Int8Array)
 exports.int16array = typedarray(Int16Array, b4a.swap16)
 exports.int32array = typedarray(Int32Array, b4a.swap32)
 
+exports.biguint64array = typedarray(BigUint64Array, b4a.swap64)
+exports.bigint64array = typedarray(BigInt64Array, b4a.swap64)
+
 exports.float32array = typedarray(Float32Array, b4a.swap32)
 exports.float64array = typedarray(Float64Array, b4a.swap64)
 

package/test.js

@@ -146,6 +146,82 @@ test('float64', function (t) {
   t.is(state.start, state.end)
 })
 
+test('biguint64', function (t) {
+  const state = enc.state()
+
+  const n = 0x0102030405060708n
+
+  enc.biguint64.preencode(state, n)
+  t.alike(state, enc.state(0, 8))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.biguint64.encode(state, n)
+  t.alike(state, enc.state(8, 8, b4a.from([0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1])))
+
+  state.start = 0
+  t.is(enc.biguint64.decode(state), n)
+  t.is(state.start, state.end)
+
+  t.exception(() => enc.biguint64.decode(state))
+})
+
+test('bigint64', function (t) {
+  const state = enc.state()
+
+  const n = -0x0102030405060708n
+
+  enc.bigint64.preencode(state, n)
+  t.alike(state, enc.state(0, 8))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.bigint64.encode(state, n)
+  t.alike(state, enc.state(8, 8, b4a.from([0xf, 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2])))
+
+  state.start = 0
+  t.is(enc.bigint64.decode(state), n)
+  t.is(state.start, state.end)
+
+  t.exception(() => enc.bigint64.decode(state))
+})
+
+test('biguint', function (t) {
+  const state = enc.state()
+
+  const n = 0x0102030405060708090a0b0cn
+
+  enc.biguint.preencode(state, n)
+  t.alike(state, enc.state(0, 17))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.biguint.encode(state, n)
+  t.alike(state, enc.state(17, 17, b4a.from([2, 0xc, 0xb, 0xa, 0x9, 0x8, 0x7, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0])))
+
+  state.start = 0
+  t.is(enc.biguint.decode(state), n)
+  t.is(state.start, state.end)
+
+  t.exception(() => enc.biguint.decode(state))
+})
+
+test('bigint', function (t) {
+  const state = enc.state()
+
+  const n = -0x0102030405060708090a0b0cn
+
+  enc.bigint.preencode(state, n)
+  t.alike(state, enc.state(0, 17))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.bigint.encode(state, n)
+  t.alike(state, enc.state(17, 17, b4a.from([2, 0x17, 0x16, 0x14, 0x12, 0x10, 0xe, 0xc, 0xa, 0x8, 0x6, 0x4, 0x2, 0x0, 0x0, 0x0, 0x0])))
+
+  state.start = 0
+  t.is(enc.bigint.decode(state), n)
+  t.is(state.start, state.end)
+
+  t.exception(() => enc.bigint.decode(state))
+})
+
 test('buffer', function (t) {
   const state = enc.state()
 
@@ -308,6 +384,44 @@ test('int32array', function (t) {
   t.exception(() => enc.int32array.decode(state))
 })
 
+test('biguint64array', function (t) {
+  const state = enc.state()
+
+  const arr = new BigUint64Array([0x01020304n, 0x05060708n, 0x090a0b0cn])
+
+  enc.biguint64array.preencode(state, arr)
+  t.alike(state, enc.state(0, 25))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.biguint64array.encode(state, arr)
+  t.alike(state, enc.state(25, 25, b4a.from([3, 0x4, 0x3, 0x2, 0x1, 0x0, 0x0, 0x0, 0x0, 0x8, 0x7, 0x6, 0x5, 0x0, 0x0, 0x0, 0x0, 0xc, 0xb, 0xa, 0x9, 0x0, 0x0, 0x0, 0x0])))
+
+  state.start = 0
+  t.alike(enc.biguint64array.decode(state), arr)
+  t.is(state.start, state.end)
+
+  t.exception(() => enc.biguint64array.decode(state))
+})
+
+test('bigint64array', function (t) {
+  const state = enc.state()
+
+  const arr = new BigInt64Array([-0x01020304n, 0x05060708n, -0x090a0b0cn])
+
+  enc.bigint64array.preencode(state, arr)
+  t.alike(state, enc.state(0, 25))
+
+  state.buffer = b4a.alloc(state.end)
+  enc.bigint64array.encode(state, arr)
+  t.alike(state, enc.state(25, 25, b4a.from([3, 0xfc, 0xfc, 0xfd, 0xfe, 0xff, 0xff, 0xff, 0xff, 0x8, 0x7, 0x6, 0x5, 0x0, 0x0, 0x0, 0x0, 0xf4, 0xf4, 0xf5, 0xf6, 0xff, 0xff, 0xff, 0xff])))
+
+  state.start = 0
+  t.alike(enc.bigint64array.decode(state), arr)
+  t.is(state.start, state.end)
+
+  t.exception(() => enc.bigint64array.decode(state))
+})
+
 test('float32array', function (t) {
   const state = enc.state()
 
@@ -451,6 +565,19 @@ test('fixed n', function (t) {
   t.exception(() => fixed.decode(state))
 })
 
+test('error for incorrect buffer sizes when encoding fixed-length buffers', function (t) {
+  const smallbuf = b4a.from('aa', 'hex')
+  const bigBuf = b4a.from('aa'.repeat(500), 'hex')
+
+  t.exception(() => enc.encode(enc.fixed32, smallbuf), /Incorrect buffer size/)
+  t.exception(() => enc.encode(enc.fixed64, smallbuf), /Incorrect buffer size/)
+  t.exception(() => enc.encode(enc.fixed(100), smallbuf), /Incorrect buffer size/)
+
+  t.exception(() => enc.encode(enc.fixed32, bigBuf), /Incorrect buffer size/)
+  t.exception(() => enc.encode(enc.fixed64, bigBuf), /Incorrect buffer size/)
+  t.exception(() => enc.encode(enc.fixed(100), bigBuf), /Incorrect buffer size/)
+})
+
 test('array', function (t) {
   const state = enc.state()
   const arr = enc.array(enc.bool)