cbor-x 0.8.0 → 0.9.0

package/dist/node.cjs

@@ -25,10 +25,12 @@ let srcStringEnd = 0;
 let referenceMap;
 let currentExtensions = [];
 let dataView;
+let restoreMapsAsObject;
 let defaultOptions = {
 	useRecords: false,
 	mapsAsObjects: true
 };
+let sequentialMode = false;
 
 class Decoder {
 	constructor(options) {
@@ -40,12 +42,12 @@ class Decoder {
 		}
 		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;
@@ -63,17 +65,7 @@ class Decoder {
 			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 = [];
 			}
@@ -82,26 +74,19 @@ class Decoder {
 			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
 					}
 				}
@@ -109,17 +94,47 @@ class Decoder {
 			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 getPosition() {
-	return position
+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() {
@@ -185,6 +200,10 @@ function read() {
 								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());
@@ -231,6 +250,10 @@ function read() {
 				}
 				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());
@@ -338,10 +361,18 @@ function setExtractor(extractStrings) {
 		return function readString(length) {
 			let string = strings[stringPosition++];
 			if (string == null) {
-				strings = extractStrings(position, srcEnd, length, src);
-				stringPosition = 0;
-				srcStringEnd = 1; // even if a utf-8 string was decoded, must indicate we are in the midst of extracted strings and can't skip strings
-				string = strings[stringPosition++];
+				let extraction = extractStrings(position, srcEnd, length, src);
+				if (typeof extraction == 'string') {
+					string = extraction;
+					strings = EMPTY_ARRAY;
+				} else {
+					strings = extraction;
+					stringPosition = 1;
+					srcStringEnd = 1; // even if a utf-8 string was decoded, must indicate we are in the midst of extracted strings and can't skip strings
+					string = strings[0];
+					if (string === undefined)
+						throw new Error('Unexpected end of buffer')
+				}
 			}
 			let srcStringLength = string.length;
 			if (srcStringLength <= length) {
@@ -727,6 +758,16 @@ currentExtensions[40010] = (id) => {
 };
 
 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];
@@ -755,6 +796,7 @@ function saveState(callback) {
 	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;
@@ -765,6 +807,7 @@ function saveState(callback) {
 	strings = savedStrings;
 	referenceMap = savedReferenceMap;
 	src = savedSrc;
+	sequentialMode = savedSequentialMode;
 	currentStructures = savedStructures;
 	currentDecoder = savedDecoder;
 	dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
@@ -780,7 +823,7 @@ function addExtension(extension) {
 	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));
 }
@@ -792,7 +835,14 @@ const FLOAT32_OPTIONS = {
 	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 {
@@ -837,11 +887,8 @@ class Encoder extends Decoder {
 		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);
@@ -854,7 +901,8 @@ class Encoder extends Decoder {
 				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;
@@ -862,7 +910,7 @@ class Encoder extends Decoder {
 				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
@@ -872,8 +920,8 @@ class Encoder extends Decoder {
 						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);
@@ -902,7 +950,12 @@ class Encoder extends Decoder {
 					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)
@@ -916,7 +969,7 @@ class Encoder extends Decoder {
 							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 = [];
 					}
@@ -924,13 +977,15 @@ class Encoder extends Decoder {
 						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
 					}
 				}
 			}
@@ -1051,7 +1106,7 @@ class Encoder extends Decoder {
 						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
@@ -1097,6 +1152,12 @@ class Encoder extends Decoder {
 							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;
@@ -1174,10 +1235,9 @@ class Encoder extends Decoder {
 				}
 				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)
 			}
 		};
 
@@ -1266,7 +1326,7 @@ class Encoder extends Decoder {
 			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) {
@@ -1276,7 +1336,7 @@ class Encoder extends Decoder {
 				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;
@@ -1303,7 +1363,7 @@ class Encoder extends Decoder {
 						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
@@ -1443,7 +1503,9 @@ function typedArrayEncoder(tag) {
 }
 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) {
@@ -1498,24 +1560,21 @@ function addExtension$1(extension) {
 }
 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;
 
 class EncoderStream extends stream.Transform {
 	constructor(options) {
 		if (!options)
 			options = {};
+		options.writableObjectMode = true;
 		super(options);
 		options.sequential = true;
-		this.encoder = new Encoder(options);
+		this.encoder = options.encoder || new Encoder(options);
 	}
-	write(value) {
+	_transform(value, encoding, callback) {
 		this.push(this.encoder.encode(value));
-	}
-
-	end(value) {
-		if (value != null)
-			this.push(this.encoder.encode(value));
-		this.push(null);
+		callback();
 	}
 }
 
@@ -1526,53 +1585,136 @@ class DecoderStream extends stream.Transform {
 		options.objectMode = true;
 		super(options);
 		options.structures = [];
-		this.decoder = new Decoder(options);
+		this.decoder = options.decoder || new Decoder(options);
 	}
 	_transform(chunk, encoding, callback) {
 		if (this.incompleteBuffer) {
 			chunk = Buffer.concat([this.incompleteBuffer, chunk]);
 			this.incompleteBuffer = null;
 		}
-		let position = 0;
-		let size = chunk.length;
+		let values;
 		try {
-			this.push(this.decoder.decode(chunk, size, true));
-			position = getPosition();
-			while (position < size) {
-				let value = read();
-				this.push(value);
-				position = getPosition();
-			}
+			values = this.decoder.decodeMultiple(chunk);
 		} catch(error) {
-			if (error.incomplete)
-				this.incompleteBuffer = chunk.slice(position);
+			if (error.incomplete) {
+				this.incompleteBuffer = chunk.slice(error.lastPosition);
+				values = error.values;
+			}
 			else
 				throw error
 		} finally {
-			clearSource();
+			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 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;
 
-const extractor = tryRequire('msgpackr-extract');
+const extractor = tryRequire('cbor-extract');
 if (extractor)
 	setExtractor(extractor.extractStrings);
-/*
-Object.assign(exports, unpackModule.FLOAT32_OPTIONS)
-*/
+
 function tryRequire(moduleId) {
 	try {
 		let require$1 = module$1.createRequire((typeof document === 'undefined' ? new (require('u' + 'rl').URL)('file:' + __filename).href : (document.currentScript && document.currentScript.src || new URL('node.cjs', document.baseURI).href)));
 		return require$1(moduleId)
 	} catch (error) {
 		if (typeof window == 'undefined')
-			console.warn('Native extraction module not loaded, msgpackr will still run, but with decreased performance. ' + error.message.split('\n')[0]);
+			console.warn('Native extraction module not loaded, cbor-x will still run, but with decreased performance. ' + error.message.split('\n')[0]);
 		else
-			console.warn('For browser usage, directly use msgpackr/unpack or msgpackr/pack modules. ' + error.message.split('\n')[0]);
+			console.warn('For browser usage, directly use cbor-x/decode or cbor-x/encode modules. ' + error.message.split('\n')[0]);
 	}
 }
 
@@ -1585,10 +1727,15 @@ exports.Encoder = Encoder;
 exports.EncoderStream = EncoderStream;
 exports.FLOAT32_OPTIONS = FLOAT32_OPTIONS;
 exports.NEVER = NEVER;
+exports.REUSE_BUFFER_MODE = REUSE_BUFFER_MODE;
 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;

package/dist/test.js

@@ -581,7 +581,7 @@
 		outcomesScore: outcomesScore
 	};
 
-	//import inspector from 'inspector'; inspector.open(9330, null, true); debugger
+	//import inspector from 'inspector'; inspector.open(9229, null, true); debugger
 	function tryRequire(module) {
 		try {
 			return require(module)
@@ -659,6 +659,13 @@
 			assert.deepEqual(deserialized, data);
 		});
 
+		test('255 chars', function() {
+			const data = 'RRZG9A6I7xupPeOZhxcOcioFsuhszGOdyDUcbRf4Zef2kdPIfC9RaLO4jTM5JhuZvTsF09fbRHMGtqk7YAgu3vespeTe9l61ziZ6VrMnYu2CamK96wCkmz0VUXyqaiUoTPgzk414LS9yYrd5uh7w18ksJF5SlC2e91rukWvNqAZJjYN3jpkqHNOFchCwFrhbxq2Lrv1kSJPYCx9blRg2hGmYqTbElLTZHv20iNqwZeQbRMgSBPT6vnbCBPnOh1W';
+			var serialized = CBOR.encode(data);
+			var deserialized = CBOR.decode(serialized);
+			assert.equal(deserialized, data);
+		});
+
 		test('encode/decode sample data', function(){
 			var data = sampleData;
 			var serialized = CBOR.encode(data);
@@ -787,10 +794,13 @@
 			let fa = new Float32Array(b.buffer, 8, 2);
 			fa[0] = 2.25;
 			fa[1] = 6;
+			let map = new Map();
+			map.set('key', 'value');
 			let object = {
 				error: new Error('test'),
 				set: new Set(['a', 'b']),
 				regexp: /test/gi,
+				map,
 				float32Array: fa,
 				uint16Array: new Uint16Array([3,4])
 			};
@@ -800,6 +810,7 @@
 			var serialized = encoder.encode(object);
 			var deserialized = encoder.decode(serialized);
 			assert.deepEqual(Array.from(deserialized.set), Array.from(object.set));
+			assert.equal(deserialized.map.get('key'), 'value');
 			assert.equal(deserialized.error.message, object.error.message);
 			assert.equal(deserialized.regexp.test('TEST'), true);
 			assert.equal(deserialized.float32Array.constructor.name, 'Float32Array');
@@ -810,6 +821,19 @@
 			assert.equal(deserialized.uint16Array[1], 4);
 		});
 
+		test('explicit maps and sets', function () {
+			let map = new Map();
+			map.set('key', { inside: 'value'});
+			let object = {
+				set: new Set(['a', 'b']),
+				map,
+			};
+			var serialized = encode(object); // default encoder
+			var deserialized = decode(serialized);
+			assert.deepEqual(Array.from(deserialized.set), Array.from(object.set));
+			assert.equal(deserialized.map.get('key').inside, 'value');
+		});
+
 		test('object without prototype', function(){
 			var data = Object.create(null);
 			data.test = 3;
@@ -825,6 +849,13 @@
 			var decoded = decode(encoded);
 			assert.equal(decoded.length, size);
 		});
+		test('little buffer', function() {
+			var data = typeof Buffer == 'undefined' ? new Uint8Array(0) : Buffer.alloc(0);
+			var encoded = encode(data);
+			assert.equal(encoded.length, 1); // make sure to use canonical form
+			var decoded = decode(encoded);
+			assert.equal(decoded.length, 0);
+		});
 
 		test('random strings', function(){
 			var data = [];
@@ -872,6 +903,7 @@
 			let encoder = new Encoder({
 				mapsAsObjects: true,
 				useTimestamp32: true,
+				useTag259ForMaps: false,
 			});
 			var serialized = encoder.encode(data);
 			var deserialized = encoder.decode(serialized);

package/encode.d.ts

@@ -0,0 +1,6 @@
+import { Decoder } from './decode'
+export { addExtension, FLOAT32_OPTIONS } from './unpack'
+export class Encoder extends Decoder {
+	encode(value: any): Buffer
+}
+export function encode(value: any): Buffer