msgpack5 4.0.0 → 4.2.0

package/lib/decoder.js

@@ -1,3 +1,5 @@
+'use strict'
+
 var bl = require('bl')
 var util = require('util')
 
@@ -242,7 +244,8 @@ module.exports = function buildDecode (decodingTypes) {
         length = buf.readUInt16BE(offset + 1)
         return decodeMap(buf, offset, length, 3)
       case 0xdf:
-        throw new Error('map too big to decode in JS')
+        length = buf.readUInt32BE(offset + 1)
+        return decodeMap(buf, offset, length, 5)
       case 0xd4:
         return decodeFixExt(buf, offset, 1)
       case 0xd5:
@@ -375,19 +378,21 @@ module.exports = function buildDecode (decodingTypes) {
     var type = buf.readInt8(offset + 1) // Signed
     return decodeExt(buf, offset, type, size, 2)
   }
+
   function decodeTimestamp (buf, size, headerSize) {
-    var seconds, nanoseconds
-    nanoseconds = 0
+    var seconds
+    var nanoseconds = 0
 
     switch (size) {
       case 4:
-          // timestamp 32 stores the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC in an 32-bit unsigned integer
-        seconds = buf.readUInt32BE()
+        // timestamp 32 stores the number of seconds that have elapsed since 1970-01-01 00:00:00 UTC in an 32-bit unsigned integer
+        seconds = buf.readUInt32BE(0)
         break
 
-      case 8: // Timestamp 64 stores the number of seconds and nanoseconds that have elapsed
-                // since 1970-01-01 00:00:00 UTC in 32-bit unsigned integers, split 30/34 bits
-        var upper = buf.readUInt32BE()
+      case 8:
+        // Timestamp 64 stores the number of seconds and nanoseconds that have elapsed
+        // since 1970-01-01 00:00:00 UTC in 32-bit unsigned integers, split 30/34 bits
+        var upper = buf.readUInt32BE(0)
         var lower = buf.readUInt32BE(4)
         nanoseconds = upper / 4
         seconds = ((upper & 0x03) * Math.pow(2, 32)) + lower // If we use bitwise operators, we get truncated to 32bits

package/lib/encoder.js

@@ -2,12 +2,11 @@
 
 var Buffer = require('safe-buffer').Buffer
 var bl = require('bl')
-var TOLERANCE = 0.1
 
 module.exports = function buildEncode (encodingTypes, forceFloat64, compatibilityMode, disableTimestampEncoding) {
   function encode (obj, avoidSlice) {
-    var buf,
-      len
+    var buf
+    var len
 
     if (obj === undefined) {
       throw new Error('undefined is not encodable in msgpack!')
@@ -158,8 +157,8 @@ module.exports = function buildEncode (encodingTypes, forceFloat64, compatibilit
     var nanos = (millis - (seconds * 1000)) * 1E6
 
     if (nanos || seconds > 0xFFFFFFFF) {
-        // Timestamp64
-      encoded = new Buffer(10)
+      // Timestamp64
+      encoded = Buffer.allocUnsafe(10)
       encoded[0] = 0xd7
       encoded[1] = -1
 
@@ -171,8 +170,8 @@ module.exports = function buildEncode (encodingTypes, forceFloat64, compatibilit
       encoded.writeInt32BE(upper, 2)
       encoded.writeInt32BE(lower, 6)
     } else {
-        // Timestamp32
-      encoded = new Buffer(6)
+      // Timestamp32
+      encoded = Buffer.allocUnsafe(6)
       encoded[0] = 0xd6
       encoded[1] = -1
       encoded.writeUInt32BE(Math.floor(millis / 1000), 2)
@@ -248,10 +247,14 @@ module.exports = function buildEncode (encodingTypes, forceFloat64, compatibilit
     if (length < 16) {
       header = Buffer.allocUnsafe(1)
       header[0] = 0x80 | length
-    } else {
+    } else if (length < 0xFFFF) {
       header = Buffer.allocUnsafe(3)
       header[0] = 0xde
       header.writeUInt16BE(length, 1)
+    } else {
+      header = Buffer.allocUnsafe(5)
+      header[0] = 0xdf
+      header.writeUInt32BE(length, 1)
     }
 
     acc.unshift(header)
@@ -297,22 +300,35 @@ function write64BitInt (buf, offset, num) {
 }
 
 function isFloat (n) {
-  return n !== Math.floor(n)
+  return n % 1 !== 0
 }
 
 function encodeFloat (obj, forceFloat64) {
-  var buf
+  var useDoublePrecision = true
+
+  // If `fround` is supported, we can check if a float
+  // is double or single precision by rounding the object
+  // to single precision and comparing the difference.
+  // If it's not supported, it's safer to use a 64 bit
+  // float so we don't lose precision without meaning to.
+  if (Math.fround) {
+    useDoublePrecision = Math.fround(obj) !== obj
+  }
 
-  buf = Buffer.allocUnsafe(5)
-  buf[0] = 0xca
-  buf.writeFloatBE(obj, 1)
+  if (forceFloat64) {
+    useDoublePrecision = true
+  }
+
+  var buf
 
-  // FIXME is there a way to check if a
-  // value fits in a float?
-  if (forceFloat64 || Math.abs(obj - buf.readFloatBE(1)) > TOLERANCE) {
+  if (useDoublePrecision) {
     buf = Buffer.allocUnsafe(9)
     buf[0] = 0xcb
     buf.writeDoubleBE(obj, 1)
+  } else {
+    buf = Buffer.allocUnsafe(5)
+    buf[0] = 0xca
+    buf.writeFloatBE(obj, 1)
   }
 
   return buf

package/lib/streams.js

@@ -25,6 +25,7 @@ function Encoder (opts) {
   }
 
   Base.call(this, opts)
+  this._wrap = ('wrap' in opts) && opts.wrap
 }
 
 inherits(Encoder, Base)
@@ -33,7 +34,7 @@ Encoder.prototype._transform = function (obj, enc, done) {
   var buf = null
 
   try {
-    buf = this._msgpack.encode(obj).slice(0)
+    buf = this._msgpack.encode(this._wrap ? obj.value : obj).slice(0)
   } catch (err) {
     this.emit('error', err)
     return done()
@@ -53,6 +54,7 @@ function Decoder (opts) {
   Base.call(this, opts)
 
   this._chunks = bl()
+  this._wrap = ('wrap' in opts) && opts.wrap
 }
 
 inherits(Decoder, Base)
@@ -64,6 +66,9 @@ Decoder.prototype._transform = function (buf, enc, done) {
 
   try {
     var result = this._msgpack.decode(this._chunks)
+    if (this._wrap) {
+      result = {value: result}
+    }
     this.push(result)
   } catch (err) {
     if (err instanceof this._msgpack.IncompleteBufferError) {

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "msgpack5",
-  "version": "4.0.0",
+  "version": "4.2.0",
   "description": "A msgpack v5 implementation for node.js and the browser, with extension points",
   "main": "index.js",
   "scripts": {
     "test": "standard && tape test/* | tap-mocha-reporter dot",
     "build": "npm run browserify && npm run dist",
-    "browserify": "node_modules/.bin/browserify index.js -o dist/msgpack5.js -s msgpack5",
-    "dist": "node_modules/.bin/uglifyjs dist/msgpack5.js -o dist/msgpack5.min.js",
-    "test-browser": "browserify test/* | testling -u"
+    "browserify": "browserify index.js -o dist/msgpack5.js -s msgpack5",
+    "dist": "uglifyjs dist/msgpack5.js -o dist/msgpack5.min.js"
   },
   "pre-commit": [
     "test"
@@ -31,38 +30,23 @@
   },
   "homepage": "https://github.com/mcollina/msgpack5",
   "devDependencies": {
-    "browserify": "^14.5.0",
-    "jshint": "^2.9.5",
+    "browserify": "^16.2.0",
     "memdb": "^1.3.1",
     "pre-commit": "^1.2.2",
-    "standard": "^10.0.3",
-    "tap-mocha-reporter": "^3.0.6",
-    "tape": "^4.8.0",
-    "testling": "^1.7.1",
-    "uglify-js": "^3.2.2"
+    "standard": "^11.0.1",
+    "tap-mocha-reporter": "^3.0.7",
+    "tape": "^4.9.0",
+    "uglify-js": "^3.3.25"
   },
   "standard": {
     "ignore": [
       "dist/"
     ]
   },
-  "testling": {
-    "files": "test/*.js",
-    "browsers": [
-      "ie/6..latest",
-      "chrome/22..latest",
-      "firefox/16..latest",
-      "safari/latest",
-      "opera/11.0..latest",
-      "iphone/6",
-      "ipad/6",
-      "android-browser/latest"
-    ]
-  },
   "dependencies": {
-    "bl": "^1.2.1",
+    "bl": "^2.0.0",
     "inherits": "^2.0.3",
-    "readable-stream": "^2.3.3",
-    "safe-buffer": "^5.1.1"
+    "readable-stream": "^2.3.6",
+    "safe-buffer": "^5.1.2"
   }
 }

package/test/1-byte-length-uint8arrays.js

@@ -34,7 +34,7 @@ test('encode/decode 2^8-1 Uint8Arrays', function (t) {
     })
 
     t.test('mirror test for an Uint8Array of length ' + array.byteLength + ' bytes', function (t) {
-      t.deepEqual(encoder.decode(encoder.encode(array)), new Buffer(array), 'must stay the same')
+      t.deepEqual(encoder.decode(encoder.encode(array)), Buffer.from(array), 'must stay the same')
       t.end()
     })
   })

package/test/2-bytes-length-uint8arrays.js

@@ -34,7 +34,7 @@ test('encode/decode 2^8-1 Uint8Arrays', function (t) {
     })
 
     t.test('mirror test for an Uint8Array of length ' + array.byteLength + ' bytes', function (t) {
-      t.deepEqual(encoder.decode(encoder.encode(array)), new Buffer(array), 'must stay the same')
+      t.deepEqual(encoder.decode(encoder.encode(array)), Buffer.from(array), 'must stay the same')
       t.end()
     })
   })

package/test/4-bytes-length-uint8arrays.js

@@ -33,7 +33,7 @@ test('encode/decode 2^8-1 Uint8Arrays', function (t) {
     })
 
     t.test('mirror test for an Uint8Array of length ' + array.byteLength + ' bytes', function (t) {
-      t.deepEqual(encoder.decode(encoder.encode(array)), new Buffer(array), 'must stay the same')
+      t.deepEqual(encoder.decode(encoder.encode(array)), Buffer.from(array), 'must stay the same')
       t.end()
     })
   })

package/test/floats.js

@@ -7,29 +7,67 @@ var bl = require('bl')
 
 test('encoding/decoding 32-bits float numbers', function (t) {
   var encoder = msgpack()
-  var allNum = []
+  var float32 = [
+    1.5,
+    0.15625,
+    -2.5
+  ]
 
-  allNum.push(-222.42)
-  allNum.push(748364.2)
-  allNum.push(2.2)
+  var float64 = [
+    2 ** 150,
+    1.337,
+    2.2
+  ]
 
-  allNum.forEach(function (num) {
+  float64.forEach(function (num) {
+    t.test('encoding ' + num, function (t) {
+      var buf = encoder.encode(num)
+      t.equal(buf.length, 9, 'must have 5 bytes')
+      t.equal(buf[0], 0xcb, 'must have the proper header')
+
+      var dec = buf.readDoubleBE(1)
+      t.equal(dec, num, 'must decode correctly')
+      t.end()
+    })
+
+    t.test('decoding ' + num, function (t) {
+      var buf = Buffer.allocUnsafe(9)
+      var dec
+      buf[0] = 0xcb
+      buf.writeDoubleBE(num, 1)
+
+      dec = encoder.decode(buf)
+      t.equal(dec, num, 'must decode correctly')
+      t.end()
+    })
+
+    t.test('mirror test ' + num, function (t) {
+      var dec = encoder.decode(encoder.encode(num))
+      t.equal(dec, num, 'must decode correctly')
+      t.end()
+    })
+  })
+
+  float32.forEach(function (num) {
     t.test('encoding ' + num, function (t) {
       var buf = encoder.encode(num)
-      var dec = buf.readFloatBE(1)
       t.equal(buf.length, 5, 'must have 5 bytes')
       t.equal(buf[0], 0xca, 'must have the proper header')
-      t.true(Math.abs(dec - num) < 0.1, 'must decode correctly')
+
+      var dec = buf.readFloatBE(1)
+      t.equal(dec, num, 'must decode correctly')
       t.end()
     })
 
     t.test('forceFloat64 encoding ' + num, function (t) {
       var enc = msgpack({ forceFloat64: true })
       var buf = enc.encode(num)
-      var dec = buf.readDoubleBE(1)
+
       t.equal(buf.length, 9, 'must have 9 bytes')
       t.equal(buf[0], 0xcb, 'must have the proper header')
-      t.true(Math.abs(dec - num) < 0.1, 'must decode correctly')
+
+      var dec = buf.readDoubleBE(1)
+      t.equal(dec, num, 'must decode correctly')
       t.end()
     })
 
@@ -38,14 +76,15 @@ test('encoding/decoding 32-bits float numbers', function (t) {
       var dec
       buf[0] = 0xca
       buf.writeFloatBE(num, 1)
+
       dec = encoder.decode(buf)
-      t.true(Math.abs(dec - num) < 0.1, 'must decode correctly')
+      t.equal(dec, num, 'must decode correctly')
       t.end()
     })
 
     t.test('mirror test ' + num, function (t) {
       var dec = encoder.decode(encoder.encode(num))
-      t.true(Math.abs(dec - num) < 0.1, 'must decode correctly')
+      t.equal(dec, num, 'must decode correctly')
       t.end()
     })
   })
@@ -65,3 +104,16 @@ test('decoding an incomplete 32-bits float numbers', function (t) {
   t.equals(buf.length, origLength, 'must not consume any byte')
   t.end()
 })
+
+test('decoding an incomplete 64-bits float numbers', function (t) {
+  var encoder = msgpack()
+  var buf = Buffer.allocUnsafe(8)
+  buf[0] = 0xcb
+  buf = bl().append(buf)
+  var origLength = buf.length
+  t.throws(function () {
+    encoder.decode(buf)
+  }, encoder.IncompleteBufferError, 'must throw IncompleteBufferError')
+  t.equals(buf.length, origLength, 'must not consume any byte')
+  t.end()
+})

package/test/object-with-many-keys.js

@@ -0,0 +1,71 @@
+'use strict'
+
+var test = require('tape').test
+var msgpack = require('../')
+
+test('encode/decode map with 10 keys', function (t) {
+  var map = {}
+
+  for (var i = 0; i < 10; i++) {
+    map[i] = i
+  }
+
+  var pack = msgpack()
+
+  var encoded = pack.encode(map)
+
+  // map16 byte
+  t.equal(encoded[0], 0x8A)
+
+  t.deepEqual(pack.decode(encoded), map)
+  t.end()
+})
+
+test('encode/decode map with 10000 keys', function (t) {
+  var map = {}
+
+  for (var i = 0; i < 10000; i++) {
+    map[i] = i
+  }
+
+  var pack = msgpack()
+
+  var encoded = pack.encode(map)
+
+  // map16 byte
+  t.equal(encoded[0], 0xde)
+
+  t.deepEqual(pack.decode(encoded), map)
+  t.end()
+})
+
+test('encode/decode map with 100000 keys', function (t) {
+  var map = {}
+
+  for (var i = 0; i < 100000; i++) {
+    map[i] = i
+  }
+
+  var pack = msgpack()
+
+  var encoded = pack.encode(map)
+
+  // map32 byte
+  t.equal(encoded[0], 0xdf)
+
+  t.deepEqual(pack.decode(encoded), map)
+  t.end()
+})
+
+test('encode/decode map with 1000000 keys', function (t) {
+  var map = {}
+
+  for (var i = 0; i < 1000000; i++) {
+    map[i] = i
+  }
+
+  var pack = msgpack()
+
+  t.deepEqual(pack.decode(pack.encode(map)), map)
+  t.end()
+})

package/test/streams.js

@@ -182,3 +182,80 @@ test('concatenated buffers work', function (t) {
 
   encoder.end()
 })
+
+test('nil processing works', function (t) {
+  t.plan(3)
+
+  var pack = msgpack()
+  var decoder = pack.decoder({wrap: true})
+  var decodedItemIndex = 0
+
+  decoder.on('data', function (chunk) {
+    decodedItemIndex++
+    t.deepEqual(chunk.value, decodedItemIndex === 1 ? null : false)
+  })
+
+  decoder.on('end', function () {
+    t.equal(decodedItemIndex, 2)
+  })
+
+  decoder.write(new Buffer([0xc0, 0xc2]))
+  decoder.end()
+})
+
+test('encoder wrap mode works', function (t) {
+  t.plan(1)
+
+  var pack = msgpack()
+  var encoder = pack.encoder({wrap: true})
+  var decoder = pack.decoder()
+  var data = { hello: 'world' }
+  var wrappedData = {value: data}
+
+  encoder.pipe(decoder)
+
+  decoder.on('data', function (chunk) {
+    t.deepEqual(chunk, data)
+  })
+
+  encoder.end(wrappedData)
+})
+
+test('encoder/decoder wrap mode must send an object through', function (t) {
+  t.plan(1)
+
+  var pack = msgpack()
+  var encoder = pack.encoder({wrap: true})
+  var decoder = pack.decoder({wrap: true})
+  var data = {value: { hello: 'world' }}
+
+  encoder.pipe(decoder)
+
+  decoder.on('data', function (chunk) {
+    t.deepEqual(chunk, data)
+  })
+
+  encoder.end(data)
+})
+
+test('encoder pack null', function (t) {
+  t.plan(2)
+  var pack = msgpack()
+  var encoder = pack.encoder({wrap: true})
+  var decoder = pack.decoder({wrap: true})
+
+  encoder.pipe(decoder)
+
+  var decodedItemIndex = 0
+  decoder.on('data', function (chunk) {
+    decodedItemIndex++
+    t.deepEqual(chunk.value, null)
+  })
+
+  decoder.on('end', function () {
+    t.equal(decodedItemIndex, 1)
+  })
+
+  encoder.write({value: null})
+  encoder.end()
+})

package/test/timestamps.js

@@ -7,7 +7,7 @@ var msgpack = require('../')
 test('timestamp disabling', function (t) {
   var encoder = msgpack({disableTimestampEncoding: true})
   var timestamps = [
-        [new Date('2018-01-02T03:04:05.000000000Z'), [0x80]]
+    [new Date('2018-01-02T03:04:05.000000000Z'), [0x80]]
   ]
 
   timestamps.forEach(function (testcase) {
@@ -27,11 +27,11 @@ test('timestamp disabling', function (t) {
 test('encoding/decoding timestamp 64', function (t) {
   var encoder = msgpack()
   var timestamps = [
-  [new Date('2018-01-02T03:04:05.000000000Z'), [0xd6, 0xff, 0x5a, 0x4a, 0xf6, 0xa5]],
-  [new Date('2038-01-19T03:14:08.000000000Z'), [0xd6, 0xff, 0x80, 0x00, 0x00, 0x00]],
-  [new Date('2038-01-19T03:14:07.999000000Z'), [0xd7, 0xff, 0xee, 0x2E, 0x1F, 0x00, 0x7f, 0xff, 0xff, 0xff]],
-  [new Date('2106-02-07T06:28:16.000000000Z'), [0xd7, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00]],
-  [new Date('2018-01-02T03:04:05.678000000Z'), [0xd7, 0xff, 0xa1, 0xa5, 0xd6, 0x00, 0x5a, 0x4a, 0xf6, 0xa5]]
+    [new Date('2018-01-02T03:04:05.000000000Z'), [0xd6, 0xff, 0x5a, 0x4a, 0xf6, 0xa5]],
+    [new Date('2038-01-19T03:14:08.000000000Z'), [0xd6, 0xff, 0x80, 0x00, 0x00, 0x00]],
+    [new Date('2038-01-19T03:14:07.999000000Z'), [0xd7, 0xff, 0xee, 0x2E, 0x1F, 0x00, 0x7f, 0xff, 0xff, 0xff]],
+    [new Date('2106-02-07T06:28:16.000000000Z'), [0xd7, 0xff, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00]],
+    [new Date('2018-01-02T03:04:05.678000000Z'), [0xd7, 0xff, 0xa1, 0xa5, 0xd6, 0x00, 0x5a, 0x4a, 0xf6, 0xa5]]
   ]
 
   timestamps.forEach(function (testcase) {