cbor-x 0.8.0 → 0.9.0

package/dist/index.js

@@ -1,7 +1,7 @@
 (function (global, factory) {
 	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
 	typeof define === 'function' && define.amd ? define(['exports'], factory) :
-	(global = global || self, factory(global.msgpackr = {}));
+	(global = global || self, factory(global.CBOR = {}));
 }(this, (function (exports) { 'use strict';
 
 	let decoder;
@@ -21,10 +21,12 @@
 	let referenceMap;
 	let currentExtensions = [];
 	let dataView;
+	let restoreMapsAsObject;
 	let defaultOptions = {
 		useRecords: false,
 		mapsAsObjects: true
 	};
+	let sequentialMode = false;
 
 	class Decoder {
 		constructor(options) {
@@ -36,12 +38,12 @@
 			}
 			Object.assign(this, options);
 		}
-		decode(source, end, continueReading) {
+		decode(source, end) {
 			if (src) {
 				// re-entrant execution, save the state and restore it after we do this decode
 				return saveState(() => {
 					clearSource();
-					return this ? this.decode(source, end, continueReading) : Decoder.prototype.decode.call(defaultOptions, source, end, continueReading)
+					return this ? this.decode(source, end) : Decoder.prototype.decode.call(defaultOptions, source, end)
 				})
 			}
 			srcEnd = end > -1 ? end : source.length;
@@ -57,17 +59,7 @@
 				currentDecoder = this;
 				if (this.structures) {
 					currentStructures = this.structures;
-					try {
-						return read()
-					} finally {
-						if (position >= srcEnd || !continueReading) {
-							// finished reading this source, cleanup references
-							currentStructures = null;
-							src = null;
-							if (referenceMap)
-								referenceMap = null;
-						}
-					}
+					return checkedRead()
 				} else if (!currentStructures || currentStructures.length > 0) {
 					currentStructures = [];
 				}
@@ -76,26 +68,19 @@
 				if (!currentStructures || currentStructures.length > 0)
 					currentStructures = [];
 			}
-			try {
-				return read()
-			} finally {
-				if (position >= srcEnd || !continueReading) {
-					src = null;
-					if (referenceMap)
-						referenceMap = null;
-				}
-			}
+			return checkedRead()
 		}
 		decodeMultiple(source, forEach) {
+			let values, lastPosition = 0;
 			try {
-				let decoder = this;
 				let size = source.length;
-				let value = this ? this.decode(source, size, true) : defaultDecoder.decode(source, size, true);
-				let values;
+				sequentialMode = true;
+				let value = this ? this.decode(source, size) : defaultDecoder.decode(source, size);
 				if (forEach) {
 					forEach(value);
 					while(position < size) {
-						if (forEach(read()) === false) {
+						lastPosition = position;
+						if (forEach(checkedRead()) === false) {
 							return
 						}
 					}
@@ -103,15 +88,48 @@
 				else {
 					values = [ value ];
 					while(position < size) {
-						values.push(read());
+						lastPosition = position;
+						values.push(checkedRead());
 					}
 					return values
 				}
+			} catch(error) {
+				error.lastPosition = lastPosition;
+				error.values = values;
+				throw error
 			} finally {
+				sequentialMode = false;
 				clearSource();
 			}
 		}
 	}
+	function checkedRead() {
+		try {
+			let result = read();
+			if (position == srcEnd) {
+				// finished reading this source, cleanup references
+				currentStructures = null;
+				src = null;
+				if (referenceMap)
+					referenceMap = null;
+			} else if (position > srcEnd) {
+				// over read
+				let error = new Error('Unexpected end of CBOR data');
+				error.incomplete = true;
+				throw error
+			} else if (!sequentialMode) {
+				throw new Error('Data read, but end of buffer not reached')
+			}
+			// else more to read, but we are reading sequentially, so don't clear source yet
+			return result
+		} catch(error) {
+			clearSource();
+			if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer')) {
+				error.incomplete = true;
+			}
+			throw error
+		}
+	}
 
 	function read() {
 		let token = src[position++];
@@ -176,6 +194,10 @@
 									object[key] = read();
 								return object
 							} else {
+								if (restoreMapsAsObject) {
+									currentDecoder.mapsAsObjects = true;
+									restoreMapsAsObject = false;
+								}
 								let map = new Map();
 								while ((key = read()) != STOP_CODE)
 									map.set(key, read());
@@ -222,6 +244,10 @@
 					}
 					return object
 				} else {
+					if (restoreMapsAsObject) {
+						currentDecoder.mapsAsObjects = true;
+						restoreMapsAsObject = false;
+					}
 					let map = new Map();
 					for (let i = 0; i < token; i++) {
 						map.set(read(), read());
@@ -693,6 +719,16 @@
 	};
 
 	currentExtensions[258] = (array) => new Set(array); // https://github.com/input-output-hk/cbor-sets-spec/blob/master/CBOR_SETS.md
+	(currentExtensions[259] = (read) => {
+		// https://github.com/shanewholloway/js-cbor-codec/blob/master/docs/CBOR-259-spec
+		// for decoding as a standard Map
+		if (currentDecoder.mapsAsObjects) {
+			currentDecoder.mapsAsObjects = false;
+			restoreMapsAsObject = true;
+		}
+		return read()
+	}).handlesRead = true;
+
 
 	const typedArrays = ['Uint8', 'Uint8Clamped', 'Uint16', 'Uint32', 'BigUint64','Int8', 'Int16', 'Int32', 'BigInt64', 'Float32', 'Float64'].map(type => type + 'Array');
 	const typedArrayTags = [64, 68, 69, 70, 71, 72, 77, 78, 79, 81, 82];
@@ -719,6 +755,7 @@
 		let savedSrc = new Uint8Array(src.slice(0, srcEnd)); // we copy the data in case it changes while external data is processed
 		let savedStructures = currentStructures;
 		let savedDecoder = currentDecoder;
+		let savedSequentialMode = sequentialMode;
 		let value = callback();
 		srcEnd = savedSrcEnd;
 		position = savedPosition;
@@ -727,6 +764,7 @@
 		srcString = savedSrcString;
 		referenceMap = savedReferenceMap;
 		src = savedSrc;
+		sequentialMode = savedSequentialMode;
 		currentStructures = savedStructures;
 		currentDecoder = savedDecoder;
 		dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
@@ -742,7 +780,7 @@
 		currentExtensions[extension.tag] = extension.decode;
 	}
 
-	let mult10 = new Array(147); // this is a table matching binary exponents to the multiplier to determine significant digit rounding
+	const mult10 = new Array(147); // this is a table matching binary exponents to the multiplier to determine significant digit rounding
 	for (let i = 0; i < 256; i++) {
 		mult10[i] = +('1e' + Math.floor(45.15 - i * 0.30103));
 	}
@@ -754,7 +792,14 @@
 		ALWAYS: 1,
 		DECIMAL_ROUND: 3,
 		DECIMAL_FIT: 4
-	};
+	};
+	let f32Array = new Float32Array(1);
+	let u8Array = new Uint8Array(f32Array.buffer, 0, 4);
+	function roundFloat32(float32Number) {
+		f32Array[0] = float32Number;
+		let multiplier = mult10[((u8Array[3] & 0x7f) << 1) | (u8Array[2] >> 7)];
+		return ((multiplier * float32Number + (float32Number > 0 ? 0.5 : -0.5)) >> 0) / multiplier
+	}
 
 	let textEncoder;
 	try {
@@ -799,11 +844,8 @@
 			let recordIdsToRemove = [];
 			let transitionsCount = 0;
 			let serializationsSinceTransitionRebuild = 0;
-			if (this.structures && this.structures.length > maxSharedStructures) {
-				throw new Error('Too many shared structures')
-			}
 
-			this.encode = function(value) {
+			this.encode = function(value, encodeOptions) {
 				if (!target) {
 					target = new ByteArrayAllocate(8192);
 					targetView = new DataView(target.buffer, 0, 8192);
@@ -816,7 +858,8 @@
 					targetView = new DataView(target.buffer, 0, target.length);
 					safeEnd = target.length - 10;
 					position$1 = 0;
-				}
+				} else if (encodeOptions === REUSE_BUFFER_MODE)
+					position$1 = (position$1 + 7) & 0x7ffffff8; // Word align to make any future copying of this buffer faster
 				start = position$1;
 				referenceMap = encoder.structuredClone ? new Map() : null;
 				sharedStructures = encoder.structures;
@@ -824,7 +867,7 @@
 					if (sharedStructures.uninitialized)
 						encoder.structures = sharedStructures = encoder.getStructures();
 					let sharedStructuresLength = sharedStructures.length;
-					if (sharedStructuresLength >  maxSharedStructures && !isSequential)
+					if (sharedStructuresLength > maxSharedStructures && !isSequential)
 						sharedStructuresLength = maxSharedStructures;
 					if (!sharedStructures.transitions) {
 						// rebuild our structure transitions
@@ -834,8 +877,8 @@
 							if (!keys)
 								continue
 							let nextTransition, transition = sharedStructures.transitions;
-							for (let i =0, l = keys.length; i < l; i++) {
-								let key = keys[i];
+							for (let j = 0, l = keys.length; j < l; j++) {
+								let key = keys[j];
 								nextTransition = transition[key];
 								if (!nextTransition) {
 									nextTransition = transition[key] = Object.create(null);
@@ -864,7 +907,12 @@
 						referenceMap = null;
 						return serialized
 					}
-					return target.subarray(start, position$1) // position can change if we call encode again in saveStructures, so we get the buffer now
+					if (encodeOptions === REUSE_BUFFER_MODE) {
+						target.start = start;
+						target.end = position$1;
+						return target
+					}
+					return target.subarray(start, position$1) // position can change if we call pack again in saveStructures, so we get the buffer now
 				} finally {
 					if (sharedStructures) {
 						if (serializationsSinceTransitionRebuild < 10)
@@ -878,7 +926,7 @@
 								recordIdsToRemove = [];
 						} else if (recordIdsToRemove.length > 0 && !isSequential) {
 							for (let i = 0, l = recordIdsToRemove.length; i < l; i++) {
-								recordIdsToRemove[i][RECORD_SYMBOL] = 0;
+								recordIdsToRemove[i][RECORD_SYMBOL] = undefined;
 							}
 							recordIdsToRemove = [];
 						}
@@ -886,13 +934,15 @@
 							if (encoder.structures.length > maxSharedStructures) {
 								encoder.structures = encoder.structures.slice(0, maxSharedStructures);
 							}
-
+							// we can't rely on start/end with REUSE_BUFFER_MODE since they will (probably) change when we save
+							let returnBuffer = target.subarray(start, position$1);
 							if (encoder.saveStructures(encoder.structures, lastSharedStructuresLength) === false) {
 								// get updated structures and try again if the update failed
 								encoder.structures = encoder.getStructures() || [];
 								return encoder.encode(value)
 							}
 							lastSharedStructuresLength = encoder.structures.length;
+							return returnBuffer
 						}
 					}
 				}
@@ -1013,7 +1063,7 @@
 							targetView.setFloat32(position$1, value);
 							let xShifted;
 							if (useFloat32 < 4 ||
-								// this checks for  rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
+									// this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
 									((xShifted = value * mult10[((target[position$1] & 0x7f) << 1) | (target[position$1 + 1] >> 7)]) >> 0) === xShifted) {
 								position$1 += 4;
 								return
@@ -1059,6 +1109,12 @@
 								encode(value[i]);
 							}
 						} else if (constructor === Map) {
+							if (this.mapsAsObjects ? this.useTag259ForMaps !== false : this.useTag259ForMaps) {
+								// use Tag 259 (https://github.com/shanewholloway/js-cbor-codec/blob/master/docs/CBOR-259-spec--explicit-maps.md) for maps if the user wants it that way
+								target[position$1++] = 0xd9;
+								target[position$1++] = 1;
+								target[position$1++] = 3;
+							}
 							length = value.size;
 							if (length < 0x18) {
 								target[position$1++] = 0xa0 | length;
@@ -1136,10 +1192,9 @@
 					}
 					position$1 += 8;
 				} else if (type === 'undefined') {
-					//target[position++] = 0xc1 // this is the "never-used" byte
 					target[position$1++] = 0xf7;
 				} else {
-					throw new Error('Unknown type ' + type)
+					throw new Error('Unknown type: ' + type)
 				}
 			};
 
@@ -1228,7 +1283,7 @@
 				let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
 				let newTransitions = 0;
 				let length = keys.length;
-				for (let i =0; i < length; i++) {
+				for (let i = 0; i < length; i++) {
 					let key = keys[i];
 					nextTransition = transition[key];
 					if (!nextTransition) {
@@ -1238,7 +1293,7 @@
 					transition = nextTransition;
 				}
 				let recordId = transition[RECORD_SYMBOL];
-				if (recordId) {
+				if (recordId !== undefined) {
 					target[position$1++] = 0xd9; // tag two byte
 					target[position$1++] = RECORD_STARTING_ID_PREFIX;
 					target[position$1++] = recordId;
@@ -1265,7 +1320,7 @@
 							transitionsCount += serializationsSinceTransitionRebuild * newTransitions;
 						// record the removal of the id, we can maintain our shared structure
 						if (recordIdsToRemove.length >= MAX_STRUCTURES - maxSharedStructures)
-							recordIdsToRemove.shift()[RECORD_SYMBOL] = 0; // we are cycling back through, and have to remove old ones
+							recordIdsToRemove.shift()[RECORD_SYMBOL] = undefined; // we are cycling back through, and have to remove old ones
 						recordIdsToRemove.push(transition);
 						if (length < 0x16)
 							target[position$1++] = 0x82 + length; // array header, length of values + 2
@@ -1405,7 +1460,9 @@
 	}
 	function writeBuffer(buffer, makeRoom) {
 		let length = buffer.byteLength;
-		if (length < 0x100) {
+		if (length < 0x18) {
+			target[position$1++] = 0x40 + length;
+		} else if (length < 0x100) {
 			target[position$1++] = 0x58;
 			target[position$1++] = length;
 		} else if (length < 0x10000) {
@@ -1460,7 +1517,91 @@
 	}
 	let defaultEncoder = new Encoder({ useRecords: false });
 	const encode = defaultEncoder.encode;
-	const { NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS;
+	const { NEVER, ALWAYS, DECIMAL_ROUND, DECIMAL_FIT } = FLOAT32_OPTIONS;
+	const REUSE_BUFFER_MODE = 1000;
+
+	/**
+	 * Given an Iterable first argument, returns an Iterable where each value is encoded 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] - cbor-x Encoder options
+	 * @returns {IterableIterator|Promise.<AsyncIterableIterator>}
+	 */
+	function encodeIter (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 encodeIterSync(objectIterator, options)
+	  } else if (typeof objectIterator.then === 'function' || typeof objectIterator[Symbol.asyncIterator] === 'function') {
+	    return encodeIterAsync(objectIterator, options)
+	  } else {
+	    throw new Error('first argument must be an Iterable, Async Iterable, Iterator, Async Iterator, or a Promise')
+	  }
+	}
+
+	function * encodeIterSync (objectIterator, options) {
+	  const encoder = new Encoder(options);
+	  for (const value of objectIterator) {
+	    yield encoder.encode(value);
+	  }
+	}
+
+	async function * encodeIterAsync (objectIterator, options) {
+	  const encoder = new Encoder(options);
+	  for await (const value of objectIterator) {
+	    yield encoder.encode(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] - Decoder options
+	 * @returns {IterableIterator|Promise.<AsyncIterableIterator}
+	 */
+	function decodeIter (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 decoder = new Decoder(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 = decoder.decodeMultiple(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 useRecords = false;
 	const mapsAsObjects = true;
@@ -1474,10 +1615,14 @@
 	exports.NEVER = NEVER;
 	exports.Tag = Tag;
 	exports.addExtension = addExtension$1;
+	exports.clearSource = clearSource;
 	exports.decode = decode;
+	exports.decodeIter = decodeIter;
 	exports.decodeMultiple = decodeMultiple;
 	exports.encode = encode;
+	exports.encodeIter = encodeIter;
 	exports.mapsAsObjects = mapsAsObjects;
+	exports.roundFloat32 = roundFloat32;
 	exports.useRecords = useRecords;
 
 	Object.defineProperty(exports, '__esModule', { value: true });