cbor-x 1.0.0 → 1.2.1

package/dist/node-index.js

@@ -0,0 +1,93 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  __markAsModule(target);
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __reExport(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? { get: () => module2.default, enumerable: true } : { value: module2, enumerable: true })), module2);
+};
+__export(exports, {
+  ALWAYS: () => import_encode.ALWAYS,
+  DECIMAL_FIT: () => import_encode.DECIMAL_FIT,
+  DECIMAL_ROUND: () => import_encode.DECIMAL_ROUND,
+  Decoder: () => import_decode.Decoder,
+  DecoderStream: () => import_stream.DecoderStream,
+  Encoder: () => import_encode.Encoder,
+  EncoderStream: () => import_stream.EncoderStream,
+  FLOAT32_OPTIONS: () => import_decode.FLOAT32_OPTIONS,
+  NEVER: () => import_encode.NEVER,
+  REUSE_BUFFER_MODE: () => import_encode.REUSE_BUFFER_MODE,
+  Tag: () => import_decode.Tag,
+  addExtension: () => import_encode.addExtension,
+  clearSource: () => import_decode.clearSource,
+  decode: () => import_decode.decode,
+  decodeIter: () => import_iterators.decodeIter,
+  decodeMultiple: () => import_decode.decodeMultiple,
+  encode: () => import_encode.encode,
+  encodeIter: () => import_iterators.encodeIter,
+  isNativeAccelerationEnabled: () => import_decode.isNativeAccelerationEnabled,
+  mapsAsObjects: () => mapsAsObjects,
+  roundFloat32: () => import_decode.roundFloat32,
+  useRecords: () => useRecords
+});
+var import_encode = __toModule(require("./encode.js"));
+var import_decode = __toModule(require("./decode.js"));
+var import_stream = __toModule(require("./stream.js"));
+var import_iterators = __toModule(require("./iterators.js"));
+var import_decode2 = __toModule(require("./decode.js"));
+var import_module = __toModule(require("module"));
+const import_meta = {};
+const useRecords = false;
+const mapsAsObjects = true;
+const extractor = tryRequire("cbor-extract");
+if (extractor)
+  (0, import_decode2.setExtractor)(extractor.extractStrings);
+function tryRequire(moduleId) {
+  try {
+    let require2 = (0, import_module.createRequire)(import_meta.url);
+    return require2(moduleId);
+  } catch (error) {
+    if (typeof window != "undefined")
+      console.warn("For browser usage, directly use cbor-x/decode or cbor-x/encode modules. " + error.message.split("\n")[0]);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALWAYS,
+  DECIMAL_FIT,
+  DECIMAL_ROUND,
+  Decoder,
+  DecoderStream,
+  Encoder,
+  EncoderStream,
+  FLOAT32_OPTIONS,
+  NEVER,
+  REUSE_BUFFER_MODE,
+  Tag,
+  addExtension,
+  clearSource,
+  decode,
+  decodeIter,
+  decodeMultiple,
+  encode,
+  encodeIter,
+  isNativeAccelerationEnabled,
+  mapsAsObjects,
+  roundFloat32,
+  useRecords
+});

package/dist/node.cjs

@@ -256,7 +256,11 @@ function read() {
 					position += 8;
 					return value
 				}
-				if (currentDecoder.int64AsNumber) {
+				if (majorType > 1) {
+					if (dataView.getUint32(position) > 0)
+						throw new Error('JavaScript does not support arrays, maps, or strings with length over 4294967295')
+					token = dataView.getUint32(position + 4);
+				} else if (currentDecoder.int64AsNumber) {
 					token = dataView.getUint32(position) * 0x100000000;
 					token += dataView.getUint32(position + 4);
 				} else
@@ -436,21 +440,30 @@ function createStructureReader(structure) {
 			}
 		}
 		// This initial function is quick to instantiate, but runs slower. After several iterations pay the cost to build the faster function
-		if (this.objectLiteralSize === length) // we have a fast object literal reader, use it (assuming it is the right length)
-			return this.objectLiteral(read)
-		if (this.count++ == 3) { // create a fast reader
-			this.objectLiteralSize = length;
-			this.objectLiteral = currentDecoder.keyMap 
-				? new Function('r', 'return {' + this.map(k => currentDecoder.decodeKey(k)).map(k => validName.test(k) ? k + ':r()' : ('[' + JSON.stringify(k) + ']:r()')).join(',') + '}')
-				: new Function('r', 'return {' + this.map(key => validName.test(key) ? key + ':r()' : ('[' + JSON.stringify(key) + ']:r()')).join(',') + '}');
-			return this.objectLiteral(read)
+		let compiledReader = this.compiledReader; // first look to see if we have the fast compiled function
+		while(compiledReader) {
+			// we have a fast compiled object literal reader
+			if (compiledReader.propertyCount === length)
+				return compiledReader(read) // with the right length, so we use it
+			compiledReader = compiledReader.next; // see if there is another reader with the right length
+		}
+		if (this.slowReads++ >= 3) { // create a fast compiled reader
+			let array = this.length == length ? this : this.slice(0, length);
+			compiledReader = currentDecoder.keyMap 
+			? new Function('r', 'return {' + array.map(k => currentDecoder.decodeKey(k)).map(k => validName.test(k) ? k + ':r()' : ('[' + JSON.stringify(k) + ']:r()')).join(',') + '}')
+			: new Function('r', 'return {' + array.map(key => validName.test(key) ? key + ':r()' : ('[' + JSON.stringify(key) + ']:r()')).join(',') + '}');
+			if (this.compiledReader)
+				compiledReader.next = this.compiledReader; // if there is an existing one, we store multiple readers as a linked list because it is usually pretty rare to have multiple readers (of different length) for the same structure
+			compiledReader.propertyCount = length;
+			this.compiledReader = compiledReader;
+			return compiledReader(read)
 		}
 		let object = {};
 		if (currentDecoder.keyMap) for (let i = 0; i < length; i++) object[currentDecoder.decodeKey(this[i])] = read();
 		else for (let i = 0; i < length; i++) object[this[i]] = read();
 		return object
 	}
-	structure.count = 0;
+	structure.slowReads = 0;
 	return readObject
 }
 
@@ -737,7 +750,7 @@ currentExtensions[0] = (dateString) => {
 
 currentExtensions[1] = (epochSec) => {
 	// numeric date extension
-	return new Date(epochSec * 1000)
+	return new Date(Math.round(epochSec * 1000))
 };
 
 currentExtensions[2] = (buffer) => {
@@ -763,11 +776,16 @@ currentExtensions[5] = (fraction) => {
 	return fraction[1] * Math.exp(fraction[0] * Math.log(2))
 };
 
-// the registration of the record definition extension (tag 105)
+// the registration of the record definition extension
 const recordDefinition = (definition) => {
 	let id = definition[0] - 0xe000;
 	let structure = definition[1];
+	let existingStructure = currentStructures[id];
+	if (existingStructure && existingStructure.isShared) {
+		(currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
+	}
 	currentStructures[id] = structure;
+
 	structure.read = createStructureReader(structure);
 	let object = {};
 	if (currentDecoder.keyMap) for (let i = 2,l = definition.length; i < l; i++) {
@@ -911,20 +929,41 @@ currentExtensionRanges.push((tag, input) => {
 			version: input,
 		}
 	}
+	if (tag == 55799) // self-descriptive CBOR tag, just return input value
+		return input
 });
 
-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];
+const isLittleEndianMachine = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1;
+const typedArrays = ['Uint8', 'Uint8Clamped', 'Uint16', 'Uint32', 'BigUint64','Int8', 'Int16', 'Int32', 'BigInt64', 'Float32', 'Float64'];
+const typedArrayTags = [64, 68, 69, 70, 71, 72, 77, 78, 79, 85, 86];
 for (let i = 0; i < typedArrays.length; i++) {
 	registerTypedArray(typedArrays[i], typedArrayTags[i]);
 }
-function registerTypedArray(typedArrayName, tag) {
-	currentExtensions[tag] = (buffer) => {
-		if (!typedArrayName)
-			throw new Error('Could not find typed array for code ' + typeCode)
-		// we have to always slice/copy here to get a new ArrayBuffer that is word/byte aligned
-		return new glbl[typedArrayName](Uint8Array.prototype.slice.call(buffer, 0).buffer)
-	};
+function registerTypedArray(typedArrayId, tag, littleEndian) {
+	let TypedArray = glbl[typedArrayId + 'Array'];
+	let bytesPerElement = TypedArray.BYTES_PER_ELEMENT;
+	for (let littleEndian = 0; littleEndian < 2; littleEndian++) {
+		if (!littleEndian && bytesPerElement == 1)
+			continue
+		let sizeShift = bytesPerElement == 2 ? 1 : bytesPerElement == 4 ? 2 : 3;
+		currentExtensions[littleEndian ? tag : (tag - 4)] = (bytesPerElement == 1 || littleEndian == isLittleEndianMachine) ? (buffer) => {
+			if (!TypedArray)
+				throw new Error('Could not find typed array for code ' + tag)
+			// we have to always slice/copy here to get a new ArrayBuffer that is word/byte aligned
+			return new TypedArray(Uint8Array.prototype.slice.call(buffer, 0).buffer)
+		} : buffer => {
+			if (!TypedArray)
+				throw new Error('Could not find typed array for code ' + tag)
+			let dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+			let elements = buffer.length >> sizeShift;
+			let ta = new TypedArray(elements);
+			let method = dv['get' + typedArrayId];
+			for (let i = 0; i < elements; i++) {
+				ta[i] = method.call(dv, i << sizeShift, littleEndian);
+			}
+			return ta
+		};
+	}
 }
 
 function readBundleExt() {
@@ -1082,12 +1121,18 @@ class Encoder extends Decoder {
 			} : false;
 
 		let encoder = this;
-		let maxSharedStructures = options.maxSharedStructures || 128;
+		let hasSharedStructures = options.structures || options.saveStructures;
+		let maxSharedStructures = options.maxSharedStructures;
+		if (maxSharedStructures == null)
+			maxSharedStructures = hasSharedStructures ? 128 : 0;
+		if (maxSharedStructures > 8190)
+			throw new Error('Maximum maxSharedStructure is 8190')
 		let isSequential = options.sequential;
 		if (isSequential) {
 			maxSharedStructures = 0;
-			this.structures = [];
 		}
+		if (!this.structures)
+			this.structures = [];
 		if (this.saveStructures)
 			this.saveShared = this.saveStructures;
 		let samplingPackedValues, packedObjectMap, sharedValues = options.sharedValues;
@@ -1135,6 +1180,10 @@ class Encoder extends Decoder {
 			} 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;
+			if (encoder.useSelfDescribedHeader) {
+				targetView.setUint32(position$1, 0xd9d9f700); // tag two byte, then self-descriptive tag
+				position$1 += 3;
+			}
 			referenceMap = encoder.structuredClone ? new Map() : null;
 			if (encoder.bundleStrings && typeof value !== 'string') {
 				bundledStrings$1 = [];
@@ -1168,6 +1217,8 @@ class Encoder extends Decoder {
 							continue
 						let nextTransition, transition = sharedStructures.transitions;
 						for (let j = 0, l = keys.length; j < l; j++) {
+							if (transition[RECORD_SYMBOL] === undefined)
+								transition[RECORD_SYMBOL] = i;
 							let key = keys[j];
 							nextTransition = transition[key];
 							if (!nextTransition) {
@@ -1175,7 +1226,7 @@ class Encoder extends Decoder {
 							}
 							transition = nextTransition;
 						}
-						transition[RECORD_SYMBOL] = i;
+						transition[RECORD_SYMBOL] = i | 0x100000;
 					}
 				}
 				if (!isSequential)
@@ -1227,11 +1278,13 @@ class Encoder extends Decoder {
 					target.end = position$1;
 					return target
 				}
-				return target.subarray(start, position$1) // position can change if we call pack again in saveShared, so we get the buffer now
+				return target.subarray(start, position$1) // position can change if we call encode again in saveShared, so we get the buffer now
 			} finally {
 				if (sharedStructures) {
 					if (serializationsSinceTransitionRebuild < 10)
 						serializationsSinceTransitionRebuild++;
+					if (sharedStructures.length > maxSharedStructures)
+						sharedStructures.length = maxSharedStructures;
 					if (transitionsCount > 10000) {
 						// force a rebuild occasionally after a lot of transitions so it can get cleaned up
 						sharedStructures.transitions = null;
@@ -1244,6 +1297,7 @@ class Encoder extends Decoder {
 							recordIdsToRemove[i][RECORD_SYMBOL] = undefined;
 						}
 						recordIdsToRemove = [];
+						//sharedStructures.nextId = maxSharedStructures
 					}
 				}
 				if (hasSharedUpdate && encoder.saveShared) {
@@ -1543,7 +1597,9 @@ class Encoder extends Decoder {
 							let extensionClass = extensionClasses[i];
 							if (value instanceof extensionClass) {
 								let extension = extensions[i];
-								let tag = extension.tag || extension.getTag && extension.getTag(value);
+								let tag = extension.tag;
+								if (tag == undefined)
+									tag = extension.getTag && extension.getTag(value);
 								if (tag < 0x18) {
 									target[position$1++] = 0xc0 | tag;
 								} else if (tag < 0x100) {
@@ -1654,88 +1710,74 @@ class Encoder extends Decoder {
 			target[objectOffset++ + start] = size >> 8;
 			target[objectOffset + start] = size & 0xff;
 		} :
-
-	/*	sharedStructures ?  // For highly stable structures, using for-in can a little bit faster
 		(object, safePrototype) => {
-			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null))
-			let objectOffset = position++ - start
-			let wroteKeys
-			for (let key in object) {
-				if (safePrototype || object.hasOwnProperty(key)) {
-					nextTransition = transition[key]
+			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
+			let newTransitions = 0;
+			let length = 0;
+			let parentRecordId;
+			let keys;
+			if (this.keyMap) {
+				keys = Object.keys(object).map(k => this.encodeKey(k));
+				length = keys.length;
+				for (let i = 0; i < length; i++) {
+					let key = keys[i];
+					nextTransition = transition[key];
 					if (!nextTransition) {
-						nextTransition = transition[key] = Object.create(null)
-						nextTransition.__keys__ = (transition.__keys__ || []).concat([key])
-						/*let keys = Object.keys(object)
-						if 
-						let size = 0
-						let startBranch = transition.__keys__ ? transition.__keys__.length : 0
-						for (let i = 0, l = keys.length; i++) {
-							let key = keys[i]
-							size += key.length << 2
-							if (i >= startBranch) {
-								nextTransition = nextTransition[key] = Object.create(null)
-								nextTransition.__keys__ = keys.slice(0, i + 1)
-							}
+						nextTransition = transition[key] = Object.create(null);
+						newTransitions++;
+					}
+					transition = nextTransition;
+				}				
+			} else {
+				for (let key in object) if (safePrototype || object.hasOwnProperty(key)) {
+					nextTransition = transition[key];
+					if (!nextTransition) {
+						if (transition[RECORD_SYMBOL] & 0x100000) {// this indicates it is a brancheable/extendable terminal node, so we will use this record id and extend it
+							parentRecordId = transition[RECORD_SYMBOL] & 0xffff;
 						}
-						makeRoom(position + size)
-						nextTransition = transition[key]
-						target.copy(target, )
-						objectOffset
+						nextTransition = transition[key] = Object.create(null);
+						newTransitions++;
 					}
-					transition = nextTransition
-					encode(object[key])
+					transition = nextTransition;
+					length++;
 				}
 			}
-			let id = transition.id
-			if (!id) {
-				id = transition.id = structures.push(transition.__keys__) + 63
-				if (sharedStructures.onUpdate)
-					sharedStructures.onUpdate(id, transition.__keys__)
-			}
-			target[objectOffset + start] = id
-		}*/
-		(object) => {
-			let keys = Object.keys(object);
-			let vals = Object.values(object);
-			if (this.keyMap) keys = keys.map(k => this.encodeKey(k));
-			let nextTransition, transition = structures.transitions || (structures.transitions = Object.create(null));
-			let newTransitions = 0;
-			let length = keys.length;
-			//let parentRecordId
-			for (let i = 0; i < length; i++) {
-				//if (!parentRecordId)
-				let key = keys[i];
-				//	parentRecordId = transition[RECORD_SYMBOL]
-				nextTransition = transition[key];
-				if (!nextTransition) {
-					nextTransition = transition[key] = Object.create(null);
-					newTransitions++;
-				}
-				transition = nextTransition;
-			}
 			let recordId = transition[RECORD_SYMBOL];
 			if (recordId !== undefined) {
+				recordId &= 0xffff;
 				target[position$1++] = 0xd9;
 				target[position$1++] = (recordId >> 8) | 0xe0;
 				target[position$1++] = recordId & 0xff;
 			} else {
-				recordId = structures.nextId++;
-				if (!recordId) {
-					recordId = 0;
-					structures.nextId = 1;
-				}
-				if (recordId >= MAX_STRUCTURES) {// cycle back around
-					structures.nextId = (recordId = maxSharedStructures) + 1;
+				if (!keys)
+					keys = transition.__keys__ || (transition.__keys__ = Object.keys(object));
+				if (parentRecordId === undefined) {
+					recordId = structures.nextId++;
+					if (!recordId) {
+						recordId = 0;
+						structures.nextId = 1;
+					}
+					if (recordId >= MAX_STRUCTURES) {// cycle back around
+						structures.nextId = (recordId = maxSharedStructures) + 1;
+					}
+				} else {
+					recordId = parentRecordId;
 				}
-				transition[RECORD_SYMBOL] = recordId;
 				structures[recordId] = keys;
-				if (sharedStructures && sharedStructures.length <= maxSharedStructures) {
+				if (recordId < maxSharedStructures) {
 					target[position$1++] = 0xd9;
 					target[position$1++] = (recordId >> 8) | 0xe0;
 					target[position$1++] = recordId & 0xff;
+					transition = structures.transitions;
+					for (let i = 0; i < length; i++) {
+						if (transition[RECORD_SYMBOL] === undefined || (transition[RECORD_SYMBOL] & 0x100000))
+							transition[RECORD_SYMBOL] = recordId;
+						transition = transition[keys[i]];
+					}
+					transition[RECORD_SYMBOL] = recordId | 0x100000; // indicates it is a extendable terminal
 					hasSharedUpdate = true;
 				} else {
+					transition[RECORD_SYMBOL] = recordId;
 					targetView.setUint32(position$1, 0xd9dfff00); // tag two byte, then record definition id
 					position$1 += 3;
 					if (newTransitions)
@@ -1756,7 +1798,9 @@ class Encoder extends Decoder {
 			} else {
 				writeArrayHeader(length);
 			}
-			for (let i =0; i < length; i++) encode(vals[i]);
+			for (let key in object)
+				if (safePrototype || object.hasOwnProperty(key))
+					encode(object[key]);
 		};
 		const makeRoom = (end) => {
 			let newSize;
@@ -1795,15 +1839,22 @@ class Encoder extends Decoder {
 	updateSharedData() {
 		let lastVersion = this.sharedVersion || 0;
 		this.sharedVersion = lastVersion + 1;
-		let saveResults = this.saveShared(new SharedData(this.structures, this.sharedValues, this.sharedVersion),
+		let structuresCopy = this.structures.slice(0);
+		let sharedData = new SharedData(structuresCopy, this.sharedValues, this.sharedVersion);
+		let saveResults = this.saveShared(sharedData,
 				existingShared => (existingShared && existingShared.version || 0) == lastVersion);
 		if (saveResults === false) {
 			// get updated structures and try again if the update failed
-			let sharedData = this.getShared() || {};
+			sharedData = this.getShared() || {};
 			this.structures = sharedData.structures || [];
 			this.sharedValues = sharedData.packedValues;
 			this.sharedVersion = sharedData.version;
+			this.structures.nextId = this.structures.length;
+		} else {
+			// restore structures
+			structuresCopy.forEach((structure, i) => this.structures[i] = structure);
 		}
+		// saveShared may fail to write and reload, or may have reloaded to check compatibility and overwrite saved data, either way load the correct shared data
 		return saveResults
 	}
 }
@@ -1881,7 +1932,7 @@ function findRepetitiveStrings(value, packedValues) {
 		case 'function': console.log(value);
 	}
 }
-
+const isLittleEndianMachine$1 = new Uint8Array(new Uint16Array([1]).buffer)[0] == 1;
 extensionClasses = [ Date, Set, Error, RegExp, Tag, ArrayBuffer, ByteArray,
 	Uint8Array, Uint8ClampedArray, Uint16Array, Uint32Array,
 	typeof BigUint64Array == 'undefined' ? function() {} : BigUint64Array, Int8Array, Int16Array, Int32Array,
@@ -1936,17 +1987,17 @@ extensions = [{
 	encode(arrayBuffer, encode, makeRoom) {
 		writeBuffer(arrayBuffer, makeRoom);
 	}
-}, typedArrayEncoder(64),
-	typedArrayEncoder(68),
-	typedArrayEncoder(69),
-	typedArrayEncoder(70),
-	typedArrayEncoder(71),
-	typedArrayEncoder(72),
-	typedArrayEncoder(77),
-	typedArrayEncoder(78),
-	typedArrayEncoder(79),
-	typedArrayEncoder(81),
-	typedArrayEncoder(82),
+}, typedArrayEncoder(64, 1),
+	typedArrayEncoder(68, 1),
+	typedArrayEncoder(69, 2),
+	typedArrayEncoder(70, 4),
+	typedArrayEncoder(71, 8),
+	typedArrayEncoder(72, 1),
+	typedArrayEncoder(77, 2),
+	typedArrayEncoder(78, 4),
+	typedArrayEncoder(79, 8),
+	typedArrayEncoder(85, 4),
+	typedArrayEncoder(86, 8),
 {
 	encode(sharedData, encode) { // write SharedData
 		let packedValues = sharedData.packedValues || [];
@@ -1975,8 +2026,9 @@ extensions = [{
 			encode(new Tag(sharedData.version, 0x53687264));
 		}
 	}];
-
-function typedArrayEncoder(tag) {
+function typedArrayEncoder(tag, size) {
+	if (!isLittleEndianMachine$1 && size > 1)
+		tag -= 4; // the big endian equivalents are 4 less
 	return {
 		tag: tag,
 		encode: function writeExtBuffer(typedArray, encode) {

package/dist/test.js

@@ -592,7 +592,6 @@
 
 	const senmlKeys = { bs: -6, bv: -5, bu: -4, bt: -3, bn: -2, n: 0, u: 1, v: 2, vs: 3, t: 6, ut: 7, vd: 8 };
 
-
 	//import inspector from 'inspector'; inspector.open(9229, null, true); debugger
 	function tryRequire(module) {
 		try {
@@ -666,10 +665,42 @@
 			let structures = [];
 			let encoder = new Encoder({ structures });
 			var serialized = encoder.encode(data);
+			serialized = encoder.encode(data);
 			var deserialized = encoder.decode(serialized);
 			assert.deepEqual(deserialized, data);
 		});
 
+		test('mixed structures, shared', function(){
+			let data1 = { a: 1, b: 2, c: 3 };
+			let data2 = { a: 1, b: 2, d: 4 };
+			let data3 = { a: 1, b: 2, e: 5 };
+			let structures = [];
+			let encoder = new Encoder({ structures });
+			var serialized = encoder.encode(data1);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized, data1);
+			var serialized = encoder.encode(data2);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized, data2);
+			var serialized = encoder.encode(data3);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized, data3);
+		});
+
+		test('mixed structures, unshared', function(){
+			let data = [];
+			let encoder = new Encoder({ });
+			for (let i = 0; i< 1000; i++) {
+				data.push({a: 1, ['test' + i]: i});
+			}
+			var serialized = encoder.encode(data);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized, data);
+			serialized = encoder.encode(data);
+			deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized, data);
+		});
+
 		test('mixed array', function(){
 			var data = [
 				'one',
@@ -772,6 +803,16 @@
 			var deserialized = encoder.decode(serialized);
 			assert.deepEqual(deserialized, data);
 		});
+		test('pack/unpack sample data with self-descriptive header', function(){
+			var data = sampleData;
+			let encoder = new Encoder({ useSelfDescribedHeader: true });
+			var serialized = encoder.encode(data);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized, data);
+			assert.equal(serialized[0], 0xd9);
+			assert.equal(serialized[1], 0xd9);
+			assert.equal(serialized[2], 0xf7);
+		});
 		if (typeof Buffer != 'undefined')
 		test('replace data', function(){
 			var data1 = {
@@ -883,6 +924,7 @@
 			let fa = new Float32Array(b.buffer, 8, 2);
 			fa[0] = 2.25;
 			fa[1] = 6;
+			let f64a = new Float64Array([2.3, 4.7]);
 			let map = new Map();
 			map.set('key', 'value');
 			let object = {
@@ -891,6 +933,7 @@
 				regexp: /test/gi,
 				map,
 				float32Array: fa,
+				float64Array: f64a,
 				uint16Array: new Uint16Array([3,4])
 			};
 			let encoder = new Encoder({
@@ -905,6 +948,8 @@
 			assert.equal(deserialized.float32Array.constructor.name, 'Float32Array');
 			assert.equal(deserialized.float32Array[0], 2.25);
 			assert.equal(deserialized.float32Array[1], 6);
+			assert.equal(deserialized.float64Array[0], 2.3);
+			assert.equal(deserialized.float64Array[1], 4.7);
 			assert.equal(deserialized.uint16Array.constructor.name, 'Uint16Array');
 			assert.equal(deserialized.uint16Array[0], 3);
 			assert.equal(deserialized.uint16Array[1], 4);
@@ -964,13 +1009,16 @@
 			var map = new Map();
 			map.set(4, 'four');
 			map.set('three', 3);
-
+			let year2039 = new Date('2039-07-05T16:22:35.792Z');
+			let year2038 = new Date('2038-08-06T00:19:02.911Z');
 
 			var data = {
 				map: map,
 				date: new Date(1532219539733),
 				farFutureDate: new Date(3532219539133),
 				ancient: new Date(-3532219539133),
+				year2038,
+				year2039,
 				invalidDate: new Date('invalid')
 			};
 			let encoder = new Encoder();
@@ -981,6 +1029,8 @@
 			assert.equal(deserialized.date.getTime(), 1532219539733);
 			assert.equal(deserialized.farFutureDate.getTime(), 3532219539133);
 			assert.equal(deserialized.ancient.getTime(), -3532219539133);
+			assert.equal(deserialized.year2038.getTime(), year2038.getTime());
+			assert.equal(deserialized.year2039.getTime(), year2039.getTime());
 			assert.equal(deserialized.invalidDate.toString(), 'Invalid Date');
 		});
 		test('map/date with options', function(){
@@ -1162,7 +1212,10 @@
 			CBOR.decodeMultiple(new Uint8Array([1, 2, 3, 4]), value => values.push(value));
 			assert.deepEqual(values, [1, 2, 3, 4]);
 		});
-
+		test('bad input', function() {
+			let badInput = Buffer.from('7b2273657269616c6e6f223a2265343a30222c226970223a223139322e3136382e312e3335222c226b6579223a226770735f736563726574227d', 'hex');
+			assert.throws(function(){ decode(badInput); }); // should throw, not crash
+		});
 	});
 	suite('CBOR performance tests', function(){
 		test('performance JSON.parse', function() {