cbor-x 1.0.0 → 1.2.1

package/README.md

@@ -7,10 +7,9 @@
 [![module](https://img.shields.io/badge/module-ESM%2FCJS-blue)](README.md)
 [![license](https://img.shields.io/badge/license-MIT-brightgreen)](LICENSE)
 
-
-The cbor-x package is an extremely fast and conformant CBOR NodeJS/JavaScript implementation. Currently, it is over 3-10x faster than any other CBOR JS implementation (including cbor-js and cborg) and faster than most MessagePack encoders, Avro, and generally faster than native V8 JSON.stringify/parse, on NodeJS. It implements the CBOR format as specificed in [RFC-8949](https://www.rfc-editor.org/rfc/rfc8949.html), [RFC-8746](https://tools.ietf.org/html/rfc8746), [RFC-8742](https://datatracker.ietf.org/doc/html/rfc8742), [Packed CBOR](https://www.ietf.org/id/draft-ietf-cbor-packed-03.html), numerous [registered IANA tag extensions](https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml) (the `x` in cbor-x),  and proposed optional [record extension](https://github.com/kriszyp/cbor-records), for defining record structures that makes CBOR even faster and more compact, often over twice as fast as even native JSON functions, and 15-50% more compact. See the performance section for more details. Structured cloning (with support for cyclical references) is supported through these tag extensions.
 <img align="right" src="./assets/performance.png" width="380"/>
 
+The cbor-x package is an extremely fast and conformant CBOR NodeJS/JavaScript implementation. Currently, it is over 3-10x faster than any other CBOR JS implementation (including cbor-js and cborg) and faster than most MessagePack encoders, Avro, and generally faster than native V8 JSON.stringify/parse, on NodeJS. It implements the CBOR format as specificed in [RFC-8949](https://www.rfc-editor.org/rfc/rfc8949.html), [RFC-8746](https://tools.ietf.org/html/rfc8746), [RFC-8742](https://datatracker.ietf.org/doc/html/rfc8742), [Packed CBOR](https://www.ietf.org/id/draft-ietf-cbor-packed-03.html), numerous [registered IANA tag extensions](https://www.iana.org/assignments/cbor-tags/cbor-tags.xhtml) (the `x` in cbor-x),  and proposed optional [record extension](https://github.com/kriszyp/cbor-records), for defining record structures that makes CBOR even faster and more compact, often over twice as fast as even native JSON functions, and 15-50% more compact. See the performance section for more details. Structured cloning (with support for cyclical references) is supported through these tag extensions.
 
 ## Basic Usage
 Install on NodeJS with:

package/decode.d.ts

@@ -19,6 +19,7 @@ export interface Options {
 	encodeUndefinedAsNil?: boolean
 	maxSharedStructures?: number
 	maxOwnStructures?: number
+	useSelfDescribedHeader?: boolean
 	shouldShareStructure?: (keys: string[]) => boolean
 	getStructures?(): {}[]
 	saveStructures?(structures: {}[]): boolean | void

package/decode.js

@@ -254,7 +254,11 @@ export 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
@@ -434,21 +438,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
 }
 
@@ -811,7 +824,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) => {
@@ -837,11 +850,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++) {
@@ -985,19 +1003,40 @@ currentExtensionRanges.push((tag, input) => {
 			version: input,
 		}
 	}
+	if (tag == 55799) // self-descriptive CBOR tag, just return input value
+		return input
 })
 
-export 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
+export 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
+		}
 	}
 }
 

package/dist/index.js

@@ -250,7 +250,11 @@
 						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
@@ -430,21 +434,30 @@
 				}
 			}
 			// 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
 	}
 
@@ -696,7 +709,7 @@
 
 	currentExtensions[1] = (epochSec) => {
 		// numeric date extension
-		return new Date(epochSec * 1000)
+		return new Date(Math.round(epochSec * 1000))
 	};
 
 	currentExtensions[2] = (buffer) => {
@@ -722,11 +735,16 @@
 		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++) {
@@ -870,20 +888,41 @@
 				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() {
@@ -1037,12 +1076,18 @@
 				} : 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;
@@ -1090,6 +1135,10 @@
 				} 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 = [];
@@ -1123,6 +1172,8 @@
 								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) {
@@ -1130,7 +1181,7 @@
 								}
 								transition = nextTransition;
 							}
-							transition[RECORD_SYMBOL] = i;
+							transition[RECORD_SYMBOL] = i | 0x100000;
 						}
 					}
 					if (!isSequential)
@@ -1182,11 +1233,13 @@
 						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;
@@ -1199,6 +1252,7 @@
 								recordIdsToRemove[i][RECORD_SYMBOL] = undefined;
 							}
 							recordIdsToRemove = [];
+							//sharedStructures.nextId = maxSharedStructures
 						}
 					}
 					if (hasSharedUpdate && encoder.saveShared) {
@@ -1498,7 +1552,9 @@
 								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) {
@@ -1609,88 +1665,74 @@
 				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)
@@ -1711,7 +1753,9 @@
 				} 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;
@@ -1750,15 +1794,22 @@
 		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
 		}
 	}
@@ -1836,7 +1887,7 @@
 			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,
@@ -1891,17 +1942,17 @@
 		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 || [];
@@ -1930,8 +1981,9 @@
 				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) {