msgpackr 1.6.2 → 1.6.3

package/dist/node.cjs

@@ -233,7 +233,10 @@ function read() {
 			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 {
@@ -459,7 +462,8 @@ function createStructureReader(structure, firstId) {
 	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
@@ -467,6 +471,8 @@ function createStructureReader(structure, firstId) {
 		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
@@ -613,7 +619,10 @@ function readMap(length) {
 	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 {
@@ -1986,142 +1995,142 @@ const { NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS;
 const REUSE_BUFFER_MODE = 512;
 const RESET_BUFFER_MODE = 1024;
 
-class PackrStream extends stream.Transform {
-	constructor(options) {
-		if (!options)
-			options = {};
-		options.writableObjectMode = true;
-		super(options);
-		options.sequential = true;
-		this.packr = options.packr || new Packr(options);
-	}
-	_transform(value, encoding, callback) {
-		this.push(this.packr.pack(value));
-		callback();
-	}
-}
-
-class UnpackrStream extends stream.Transform {
-	constructor(options) {
-		if (!options)
-			options = {};
-		options.objectMode = true;
-		super(options);
-		options.structures = [];
-		this.unpackr = options.unpackr || new Unpackr(options);
-	}
-	_transform(chunk, encoding, callback) {
-		if (this.incompleteBuffer) {
-			chunk = Buffer.concat([this.incompleteBuffer, chunk]);
-			this.incompleteBuffer = null;
-		}
-		let values;
-		try {
-			values = this.unpackr.unpackMultiple(chunk);
-		} catch(error) {
-			if (error.incomplete) {
-				this.incompleteBuffer = chunk.slice(error.lastPosition);
-				values = error.values;
-			}
-			else
-				throw error
-		} finally {
-			for (let value of values || []) {
-				if (value === null)
-					value = this.getNullValue();
-				this.push(value);
-			}
-		}
-		if (callback) callback();
-	}
-	getNullValue() {
-		return Symbol.for(null)
-	}
+class PackrStream extends stream.Transform {
+	constructor(options) {
+		if (!options)
+			options = {};
+		options.writableObjectMode = true;
+		super(options);
+		options.sequential = true;
+		this.packr = options.packr || new Packr(options);
+	}
+	_transform(value, encoding, callback) {
+		this.push(this.packr.pack(value));
+		callback();
+	}
 }
 
-/**
- * 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;
+class UnpackrStream extends stream.Transform {
+	constructor(options) {
+		if (!options)
+			options = {};
+		options.objectMode = true;
+		super(options);
+		options.structures = [];
+		this.unpackr = options.unpackr || new Unpackr(options);
+	}
+	_transform(chunk, encoding, callback) {
+		if (this.incompleteBuffer) {
+			chunk = Buffer.concat([this.incompleteBuffer, chunk]);
+			this.incompleteBuffer = null;
+		}
+		let values;
+		try {
+			values = this.unpackr.unpackMultiple(chunk);
+		} catch(error) {
+			if (error.incomplete) {
+				this.incompleteBuffer = chunk.slice(error.lastPosition);
+				values = error.values;
+			}
+			else
+				throw error
+		} finally {
+			for (let value of values || []) {
+				if (value === null)
+					value = this.getNullValue();
+				this.push(value);
+			}
+		}
+		if (callback) callback();
+	}
+	getNullValue() {
+		return Symbol.for(null)
+	}
+}
+
+/**
+ * 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;