msgpackr 1.6.2 → 1.6.3

package/SECURITY.md

@@ -1,11 +1,11 @@
-# Security Policy
-
-## Supported Versions
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 1.4.x   | :white_check_mark: |
-
-## Reporting a Vulnerability
-
-Please report security vulnerabilities to kriszyp@gmail.com.
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported          |
+| ------- | ------------------ |
+| 1.4.x   | :white_check_mark: |
+
+## Reporting a Vulnerability
+
+Please report security vulnerabilities to kriszyp@gmail.com.

package/benchmark.md

@@ -1,67 +1,67 @@
-Here are more comprehensive benchmarks. This is comparison with the next fastest JS projects using the benchmark tool from `msgpack-lite` (and data is from some clinical research data we use that has a good mix of different value types and structures). It also includes comparison to V8 native JSON functionality, and JavaScript Avro (`avsc`, a very optimized Avro implementation):
-
-operation                                                  |   op   |   ms  |  op/s
----------------------------------------------------------- | ------: | ----: | -----:
-buf = Buffer(JSON.stringify(obj));                         |   82000 |  5004 |  16386
-obj = JSON.parse(buf);                                     |   88600 |  5000 |  17720
-require("msgpackr").pack(obj);                             |  161500 |  5002 |  32287
-require("msgpackr").unpack(buf);                           |   94600 |  5004 |  18904
-msgpackr w/ shared structures: packr.pack(obj);            |  178400 |  5002 |  35665
-msgpackr w/ shared structures: packr.unpack(buf);          |  376700 |  5000 |  75340
-buf = require("msgpack-lite").encode(obj);                 |   30100 |  5012 |   6005
-obj = require("msgpack-lite").decode(buf);                 |   16200 |  5001 |   3239
-buf = require("notepack").encode(obj);                     |   62600 |  5005 |  12507
-obj = require("notepack").decode(buf);                     |   32400 |  5007 |   6470
-require("what-the-pack")... encoder.encode(obj);           |   63500 |  5002 |  12694
-require("what-the-pack")... encoder.decode(buf);           |   32000 |  5001 |   6398
-require("avsc")...make schema/type...type.toBuffer(obj);   |   84600 |  5003 |  16909
-require("avsc")...make schema/type...type.toBuffer(obj);   |   99300 |  5001 |  19856
-
-(`avsc` is schema-based and more comparable in style to msgpackr with shared structures).
-
-Here is a benchmark of streaming data (again borrowed from `msgpack-lite`'s benchmarking), where msgpackr is able to take advantage of the structured record extension and really pull away from other tools:
-
-operation (1000000 x 2)                          |   op    |  ms   |  op/s
------------------------------------------------- | ------: | ----: | -----:
-new PackrStream().write(obj);                    | 1000000 |   372 | 2688172
-new UnpackrStream().write(buf);                  | 1000000 |   247 | 4048582
-stream.write(msgpack.encode(obj));               | 1000000 |  2898 | 345065
-stream.write(msgpack.decode(buf));               | 1000000 |  1969 | 507872
-stream.write(notepack.encode(obj));              | 1000000 |   901 | 1109877
-stream.write(notepack.decode(buf));              | 1000000 |  1012 | 988142
-msgpack.Encoder().on("data",ondata).encode(obj); | 1000000 |  1763 | 567214
-msgpack.createDecodeStream().write(buf);         | 1000000 |  2222 | 450045
-msgpack.createEncodeStream().write(obj);         | 1000000 |  1577 | 634115
-msgpack.Decoder().on("data",ondata).decode(buf); | 1000000 |  2246 | 445235
-
-
-
-These are the benchmarks from notepack package. The larger test data for these benchmarks is very heavily weighted with large binary/buffer data and objects with extreme numbers of keys (much more than I typically see with real-world data, but YMMV):
-
-node ./benchmarks/encode
-
-library          |   tiny            |  small          | medium         | large
----------------- | ----------------: | --------------: | ---------------| -------:
-notepack         | 2,171,621 ops/sec | 546,905 ops/sec | 29,578 ops/sec | 265 ops/sec   
-msgpack-js       | 967,682 ops/sec   | 184,455 ops/sec | 20,556 ops/sec | 259 ops/sec   
-msgpackr         | 2,392,826 ops/sec | 556,915 ops/sec | 70,573 ops/sec | 313 ops/sec   
-msgpack-lite     | 553,143 ops/sec   | 132,318 ops/sec | 11,816 ops/sec | 186 ops/sec   
-@msgpack/msgpack | 2,157,655 ops/sec | 573,236 ops/sec | 25,864 ops/sec | 90.26 ops/sec 
-
-
-node ./benchmarks/decode
-
-library          |   tiny            |  small          | medium          | large
----------------- | ----------------: | --------------: | --------------- | -------:
-notepack         | 2,220,904 ops/sec | 560,630 ops/sec | 28,177 ops/sec  | 275 ops/sec   
-msgpack-js       | 965,719 ops/sec   | 222,047 ops/sec | 21,431 ops/sec  | 257 ops/sec   
-msgpackr         | 2,320,046 ops/sec | 589,167 ops/sec | 70,299 ops/sec  | 329 ops/sec   
-msgpackr records | 3,750,547 ops/sec | 912,419 ops/sec | 136,853 ops/sec | 733 ops/sec   
-msgpack-lite     | 569,222 ops/sec   | 129,008 ops/sec | 12,424 ops/sec  | 180 ops/sec   
-@msgpack/msgpack | 2,089,697 ops/sec | 557,507 ops/sec | 20,256 ops/sec  | 85.03 ops/sec 
-
-This was run by adding the msgpackr to the benchmarks for notepack.
-
-All benchmarks were performed on Node 14.8.0 (Windows i7-4770 3.4Ghz). They can be run with:
-npm install --no-save msgpack msgpack-js @msgpack/msgpack msgpack-lite notepack avsc
-node tests/benchmark
+Here are more comprehensive benchmarks. This is comparison with the next fastest JS projects using the benchmark tool from `msgpack-lite` (and data is from some clinical research data we use that has a good mix of different value types and structures). It also includes comparison to V8 native JSON functionality, and JavaScript Avro (`avsc`, a very optimized Avro implementation):
+
+operation                                                  |   op   |   ms  |  op/s
+---------------------------------------------------------- | ------: | ----: | -----:
+buf = Buffer(JSON.stringify(obj));                         |   82000 |  5004 |  16386
+obj = JSON.parse(buf);                                     |   88600 |  5000 |  17720
+require("msgpackr").pack(obj);                             |  161500 |  5002 |  32287
+require("msgpackr").unpack(buf);                           |   94600 |  5004 |  18904
+msgpackr w/ shared structures: packr.pack(obj);            |  178400 |  5002 |  35665
+msgpackr w/ shared structures: packr.unpack(buf);          |  376700 |  5000 |  75340
+buf = require("msgpack-lite").encode(obj);                 |   30100 |  5012 |   6005
+obj = require("msgpack-lite").decode(buf);                 |   16200 |  5001 |   3239
+buf = require("notepack").encode(obj);                     |   62600 |  5005 |  12507
+obj = require("notepack").decode(buf);                     |   32400 |  5007 |   6470
+require("what-the-pack")... encoder.encode(obj);           |   63500 |  5002 |  12694
+require("what-the-pack")... encoder.decode(buf);           |   32000 |  5001 |   6398
+require("avsc")...make schema/type...type.toBuffer(obj);   |   84600 |  5003 |  16909
+require("avsc")...make schema/type...type.toBuffer(obj);   |   99300 |  5001 |  19856
+
+(`avsc` is schema-based and more comparable in style to msgpackr with shared structures).
+
+Here is a benchmark of streaming data (again borrowed from `msgpack-lite`'s benchmarking), where msgpackr is able to take advantage of the structured record extension and really pull away from other tools:
+
+operation (1000000 x 2)                          |   op    |  ms   |  op/s
+------------------------------------------------ | ------: | ----: | -----:
+new PackrStream().write(obj);                    | 1000000 |   372 | 2688172
+new UnpackrStream().write(buf);                  | 1000000 |   247 | 4048582
+stream.write(msgpack.encode(obj));               | 1000000 |  2898 | 345065
+stream.write(msgpack.decode(buf));               | 1000000 |  1969 | 507872
+stream.write(notepack.encode(obj));              | 1000000 |   901 | 1109877
+stream.write(notepack.decode(buf));              | 1000000 |  1012 | 988142
+msgpack.Encoder().on("data",ondata).encode(obj); | 1000000 |  1763 | 567214
+msgpack.createDecodeStream().write(buf);         | 1000000 |  2222 | 450045
+msgpack.createEncodeStream().write(obj);         | 1000000 |  1577 | 634115
+msgpack.Decoder().on("data",ondata).decode(buf); | 1000000 |  2246 | 445235
+
+
+
+These are the benchmarks from notepack package. The larger test data for these benchmarks is very heavily weighted with large binary/buffer data and objects with extreme numbers of keys (much more than I typically see with real-world data, but YMMV):
+
+node ./benchmarks/encode
+
+library          |   tiny            |  small          | medium         | large
+---------------- | ----------------: | --------------: | ---------------| -------:
+notepack         | 2,171,621 ops/sec | 546,905 ops/sec | 29,578 ops/sec | 265 ops/sec   
+msgpack-js       | 967,682 ops/sec   | 184,455 ops/sec | 20,556 ops/sec | 259 ops/sec   
+msgpackr         | 2,392,826 ops/sec | 556,915 ops/sec | 70,573 ops/sec | 313 ops/sec   
+msgpack-lite     | 553,143 ops/sec   | 132,318 ops/sec | 11,816 ops/sec | 186 ops/sec   
+@msgpack/msgpack | 2,157,655 ops/sec | 573,236 ops/sec | 25,864 ops/sec | 90.26 ops/sec 
+
+
+node ./benchmarks/decode
+
+library          |   tiny            |  small          | medium          | large
+---------------- | ----------------: | --------------: | --------------- | -------:
+notepack         | 2,220,904 ops/sec | 560,630 ops/sec | 28,177 ops/sec  | 275 ops/sec   
+msgpack-js       | 965,719 ops/sec   | 222,047 ops/sec | 21,431 ops/sec  | 257 ops/sec   
+msgpackr         | 2,320,046 ops/sec | 589,167 ops/sec | 70,299 ops/sec  | 329 ops/sec   
+msgpackr records | 3,750,547 ops/sec | 912,419 ops/sec | 136,853 ops/sec | 733 ops/sec   
+msgpack-lite     | 569,222 ops/sec   | 129,008 ops/sec | 12,424 ops/sec  | 180 ops/sec   
+@msgpack/msgpack | 2,089,697 ops/sec | 557,507 ops/sec | 20,256 ops/sec  | 85.03 ops/sec 
+
+This was run by adding the msgpackr to the benchmarks for notepack.
+
+All benchmarks were performed on Node 14.8.0 (Windows i7-4770 3.4Ghz). They can be run with:
+npm install --no-save msgpack msgpack-js @msgpack/msgpack msgpack-lite notepack avsc
+node tests/benchmark

package/dist/index.js

@@ -227,7 +227,10 @@
 				if (currentUnpackr.mapsAsObjects) {
 					let object = {};
 					for (let i = 0; i < token; i++) {
-						object[readKey()] = read();
+						let key = readKey();
+						if (key === '__proto__')
+							key = '__proto_';
+						object[key] = read();
 					}
 					return object
 				} else {
@@ -453,7 +456,8 @@
 		function readObject() {
 			// This initial function is quick to instantiate, but runs slower. After several iterations pay the cost to build the faster function
 			if (readObject.count++ > inlineObjectReadThreshold) {
-				let readObject = structure.read = (new Function('r', 'return function(){return {' + structure.map(key => validName.test(key) ? key + ':r()' : ('[' + JSON.stringify(key) + ']:r()')).join(',') + '}}'))(read);
+				let readObject = structure.read = (new Function('r', 'return function(){return {' + structure.map(key => key === '__proto__' ? '__proto_:r()' :
+					validName.test(key) ? key + ':r()' : ('[' + JSON.stringify(key) + ']:r()')).join(',') + '}}'))(read);
 				if (structure.highByte === 0)
 					structure.read = createSecondByteReader(firstId, structure.read);
 				return readObject() // second byte is already read, if there is one so immediately read object
@@ -461,6 +465,8 @@
 			let object = {};
 			for (let i = 0, l = structure.length; i < l; i++) {
 				let key = structure[i];
+				if (key === '__proto__')
+					key = '__proto_';
 				object[key] = read();
 			}
 			return object
@@ -568,7 +574,10 @@
 		if (currentUnpackr.mapsAsObjects) {
 			let object = {};
 			for (let i = 0; i < length; i++) {
-				object[readKey()] = read();
+				let key = readKey();
+				if (key === '__proto__')
+					key = '__proto_';
+				object[key] = read();
 			}
 			return object
 		} else {
@@ -1937,92 +1946,92 @@
 	const REUSE_BUFFER_MODE = 512;
 	const RESET_BUFFER_MODE = 1024;
 
-	/**
-	 * Given an Iterable first argument, returns an Iterable where each value is packed as a Buffer
-	 * If the argument is only Async Iterable, the return value will be an Async Iterable.
-	 * @param {Iterable|Iterator|AsyncIterable|AsyncIterator} objectIterator - iterable source, like a Readable object stream, an array, Set, or custom object
-	 * @param {options} [options] - msgpackr pack options
-	 * @returns {IterableIterator|Promise.<AsyncIterableIterator>}
-	 */
-	function packIter (objectIterator, options = {}) {
-	  if (!objectIterator || typeof objectIterator !== 'object') {
-	    throw new Error('first argument must be an Iterable, Async Iterable, or a Promise for an Async Iterable')
-	  } else if (typeof objectIterator[Symbol.iterator] === 'function') {
-	    return packIterSync(objectIterator, options)
-	  } else if (typeof objectIterator.then === 'function' || typeof objectIterator[Symbol.asyncIterator] === 'function') {
-	    return packIterAsync(objectIterator, options)
-	  } else {
-	    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise')
-	  }
-	}
-
-	function * packIterSync (objectIterator, options) {
-	  const packr = new Packr(options);
-	  for (const value of objectIterator) {
-	    yield packr.pack(value);
-	  }
-	}
-
-	async function * packIterAsync (objectIterator, options) {
-	  const packr = new Packr(options);
-	  for await (const value of objectIterator) {
-	    yield packr.pack(value);
-	  }
-	}
-
-	/**
-	 * Given an Iterable/Iterator input which yields buffers, returns an IterableIterator which yields sync decoded objects
-	 * Or, given an Async Iterable/Iterator which yields promises resolving in buffers, returns an AsyncIterableIterator.
-	 * @param {Iterable|Iterator|AsyncIterable|AsyncIterableIterator} bufferIterator
-	 * @param {object} [options] - unpackr options
-	 * @returns {IterableIterator|Promise.<AsyncIterableIterator}
-	 */
-	function unpackIter (bufferIterator, options = {}) {
-	  if (!bufferIterator || typeof bufferIterator !== 'object') {
-	    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a promise')
-	  }
-
-	  const unpackr = new Unpackr(options);
-	  let incomplete;
-	  const parser = (chunk) => {
-	    let yields;
-	    // if there's incomplete data from previous chunk, concatinate and try again
-	    if (incomplete) {
-	      chunk = Buffer.concat([incomplete, chunk]);
-	      incomplete = undefined;
-	    }
-
-	    try {
-	      yields = unpackr.unpackMultiple(chunk);
-	    } catch (err) {
-	      if (err.incomplete) {
-	        incomplete = chunk.slice(err.lastPosition);
-	        yields = err.values;
-	      } else {
-	        throw err
-	      }
-	    }
-	    return yields
-	  };
-
-	  if (typeof bufferIterator[Symbol.iterator] === 'function') {
-	    return (function * iter () {
-	      for (const value of bufferIterator) {
-	        yield * parser(value);
-	      }
-	    })()
-	  } else if (typeof bufferIterator[Symbol.asyncIterator] === 'function') {
-	    return (async function * iter () {
-	      for await (const value of bufferIterator) {
-	        yield * parser(value);
-	      }
-	    })()
-	  }
-	}
-	const decodeIter = unpackIter;
+	/**
+	 * Given an Iterable first argument, returns an Iterable where each value is packed as a Buffer
+	 * If the argument is only Async Iterable, the return value will be an Async Iterable.
+	 * @param {Iterable|Iterator|AsyncIterable|AsyncIterator} objectIterator - iterable source, like a Readable object stream, an array, Set, or custom object
+	 * @param {options} [options] - msgpackr pack options
+	 * @returns {IterableIterator|Promise.<AsyncIterableIterator>}
+	 */
+	function packIter (objectIterator, options = {}) {
+	  if (!objectIterator || typeof objectIterator !== 'object') {
+	    throw new Error('first argument must be an Iterable, Async Iterable, or a Promise for an Async Iterable')
+	  } else if (typeof objectIterator[Symbol.iterator] === 'function') {
+	    return packIterSync(objectIterator, options)
+	  } else if (typeof objectIterator.then === 'function' || typeof objectIterator[Symbol.asyncIterator] === 'function') {
+	    return packIterAsync(objectIterator, options)
+	  } else {
+	    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise')
+	  }
+	}
+
+	function * packIterSync (objectIterator, options) {
+	  const packr = new Packr(options);
+	  for (const value of objectIterator) {
+	    yield packr.pack(value);
+	  }
+	}
+
+	async function * packIterAsync (objectIterator, options) {
+	  const packr = new Packr(options);
+	  for await (const value of objectIterator) {
+	    yield packr.pack(value);
+	  }
+	}
+
+	/**
+	 * Given an Iterable/Iterator input which yields buffers, returns an IterableIterator which yields sync decoded objects
+	 * Or, given an Async Iterable/Iterator which yields promises resolving in buffers, returns an AsyncIterableIterator.
+	 * @param {Iterable|Iterator|AsyncIterable|AsyncIterableIterator} bufferIterator
+	 * @param {object} [options] - unpackr options
+	 * @returns {IterableIterator|Promise.<AsyncIterableIterator}
+	 */
+	function unpackIter (bufferIterator, options = {}) {
+	  if (!bufferIterator || typeof bufferIterator !== 'object') {
+	    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a promise')
+	  }
+
+	  const unpackr = new Unpackr(options);
+	  let incomplete;
+	  const parser = (chunk) => {
+	    let yields;
+	    // if there's incomplete data from previous chunk, concatinate and try again
+	    if (incomplete) {
+	      chunk = Buffer.concat([incomplete, chunk]);
+	      incomplete = undefined;
+	    }
+
+	    try {
+	      yields = unpackr.unpackMultiple(chunk);
+	    } catch (err) {
+	      if (err.incomplete) {
+	        incomplete = chunk.slice(err.lastPosition);
+	        yields = err.values;
+	      } else {
+	        throw err
+	      }
+	    }
+	    return yields
+	  };
+
+	  if (typeof bufferIterator[Symbol.iterator] === 'function') {
+	    return (function * iter () {
+	      for (const value of bufferIterator) {
+	        yield * parser(value);
+	      }
+	    })()
+	  } else if (typeof bufferIterator[Symbol.asyncIterator] === 'function') {
+	    return (async function * iter () {
+	      for await (const value of bufferIterator) {
+	        yield * parser(value);
+	      }
+	    })()
+	  }
+	}
+	const decodeIter = unpackIter;
 	const encodeIter = packIter;
 
-	const useRecords = false;
+	const useRecords = false;
 	const mapsAsObjects = true;
 
 	exports.ALWAYS = ALWAYS;