compact-encoding 3.2.0 → 3.3.1

package/index.js

@@ -2,6 +2,11 @@ const b4a = require('b4a')
 
 const { BE } = require('./endian')
 
+// Zig-zag doubles the magnitude of a value before it is written as a uint, so
+// an int only reaches half as far as a uint of the same width does.
+const MAX_SAFE_INT = 2 ** 52 - 1
+const MIN_SAFE_INT = -(2 ** 52)
+
 exports.state = function (start = 0, end = 0, buffer = null) {
   return { start, end, buffer }
 }
@@ -171,7 +176,9 @@ const uint56 = (exports.uint56 = {
   },
   decode(state) {
     if (state.end - state.start < 7) throw new Error('Out of bounds')
-    return uint24.decode(state) + 0x1000000 * uint32.decode(state)
+    return validateSafeUint(
+      uint24.decode(state) + 0x1000000 * uint32.decode(state)
+    )
   }
 })
 
@@ -187,7 +194,9 @@ const uint64 = (exports.uint64 = {
   },
   decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
-    return uint32.decode(state) + 0x100000000 * uint32.decode(state)
+    return validateSafeUint(
+      uint32.decode(state) + 0x100000000 * uint32.decode(state)
+    )
   }
 })
 
@@ -203,7 +212,9 @@ exports.uint64be = {
   },
   decode(state) {
     if (state.end - state.start < 8) throw new Error('Out of bounds')
-    return 0x100000000 * uint32be.decode(state) + uint32be.decode(state)
+    return validateSafeUint(
+      0x100000000 * uint32be.decode(state) + uint32be.decode(state)
+    )
   }
 }
 
@@ -1058,6 +1069,7 @@ function zigZagDecodeInt(n) {
 }
 
 function zigZagEncodeInt(n) {
+  validateInt(n)
   // 0, -1, 1, -2, 2, ...
   return n < 0 ? 2 * -n - 1 : n === 0 ? 0 : 2 * n
 }
@@ -1085,14 +1097,36 @@ function zigZagEncodeBigInt(n) {
   return n < 0n ? 2n * -n - 1n : n === 0n ? 0n : 2n * n
 }
 
+function validateSafeUint(n) {
+  if (n <= Number.MAX_SAFE_INTEGER) return n // Handles NaN as well
+
+  throw outsideUintRange()
+}
+
 function validateUint(n) {
-  if (n >= 0 === false /* Handles NaN as well */)
-    throw new Error('uint must be positive')
-  // Beyond this, Number arithmetic loses precision and silently corrupts the
-  // encoding. The zig-zag int codecs route through here too, so this also
-  // guards int values whose doubled magnitude exceeds the safe range.
-  if (n > Number.MAX_SAFE_INTEGER)
-    throw new Error(
-      'integer is greater than the maximum safe integer, use biguint/bigint'
-    )
+  if (n >= 0 && n <= Number.MAX_SAFE_INTEGER) return n // Handles NaN as well
+
+  throw outsideUintRange()
+}
+
+function validateInt(n) {
+  if (n >= MIN_SAFE_INT && n <= MAX_SAFE_INT) return n // Handles NaN as well
+
+  throw outsideIntRange()
+}
+
+// The validations above sit on the hottest paths in the library and are small
+// enough to be inlined, which building a message inline would put a stop to.
+// Kept out here, the message costs nothing until it is actually thrown.
+
+function outsideUintRange() {
+  return new Error(
+    `uint must be between 0 and ${Number.MAX_SAFE_INTEGER}, use biguint`
+  )
+}
+
+function outsideIntRange() {
+  return new Error(
+    `int must be between ${MIN_SAFE_INT} and ${MAX_SAFE_INT}, use bigint`
+  )
 }

package/package.json

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