cbor-x 1.5.0 → 1.5.1

package/dist/node.cjs

@@ -361,13 +361,28 @@ function read() {
 					return structure.read()
 				}
 				if (token < 0x10000) {
-					if (token == RECORD_INLINE_ID) // we do a special check for this so that we can keep the currentExtensions as densely stored array (v8 stores arrays densely under about 3000 elements)
-						return recordDefinition(read())
+					if (token == RECORD_INLINE_ID) { // we do a special check for this so that we can keep the
+						// currentExtensions as densely stored array (v8 stores arrays densely under about 3000 elements)
+						let length = readJustLength();
+						let id = read();
+						let structure = read();
+						recordDefinition(id, structure);
+						let object = {};
+						if (currentDecoder.keyMap) for (let i = 2; i < length; i++) {
+							let key = currentDecoder.decodeKey(structure[i - 2]);
+							object[safeKey(key)] = read();
+						}
+						else for (let i = 2; i < length; i++) {
+							let key = structure[i - 2];
+							object[safeKey(key)] = read();
+						}
+						return object
+					}
 					else if (token == RECORD_DEFINITIONS_ID) {
 						let length = readJustLength();
 						let id = read();
 						for (let i = 2; i < length; i++) {
-							recordDefinition([id++, read()]);
+							recordDefinition(id++, read());
 						}
 						return read()
 					} else if (token == BUNDLED_STRINGS_ID) {
@@ -799,9 +814,8 @@ currentExtensions[5] = (fraction) => {
 };
 
 // the registration of the record definition extension
-const recordDefinition = (definition) => {
-	let id = definition[0] - 0xe000;
-	let structure = definition[1];
+const recordDefinition = (id, structure) => {
+	id = id - 0xe000;
 	let existingStructure = currentStructures[id];
 	if (existingStructure && existingStructure.isShared) {
 		(currentStructures.restoreStructures || (currentStructures.restoreStructures = []))[id] = existingStructure;
@@ -809,18 +823,18 @@ const recordDefinition = (definition) => {
 	currentStructures[id] = structure;
 
 	structure.read = createStructureReader(structure);
+};
+currentExtensions[LEGACY_RECORD_INLINE_ID] = (data) => {
+	let length = data.length;
+	let structure = data[1];
+	recordDefinition(data[0], structure);
 	let object = {};
-	if (currentDecoder.keyMap) for (let i = 2,l = definition.length; i < l; i++) {
-			let key = currentDecoder.decodeKey(structure[i - 2]);
-			object[safeKey(key)] = definition[i];
-		}
-	else for (let i = 2,l = definition.length; i < l; i++) {
-			let key = structure[i - 2];
-			object[safeKey(key)] = definition[i];
-		}
+	for (let i = 2; i < length; i++) {
+		let key = structure[i - 2];
+		object[safeKey(key)] = data[i];
+	}
 	return object
 };
-currentExtensions[LEGACY_RECORD_INLINE_ID] = recordDefinition;
 currentExtensions[14] = (value) => {
 	if (bundledStrings$1)
 		return bundledStrings$1[0].slice(bundledStrings$1.position0, bundledStrings$1.position0 += value)
@@ -1119,10 +1133,10 @@ try {
 	textEncoder = new TextEncoder();
 } catch (error) {}
 let extensions, extensionClasses;
-const hasNodeBuffer = typeof Buffer !== 'undefined';
-const ByteArrayAllocate = hasNodeBuffer ? Buffer.allocUnsafeSlow : Uint8Array;
-const ByteArray = hasNodeBuffer ? Buffer : Uint8Array;
-const BlobConstructor = typeof Blob === 'undefined' ? {} : Blob;
+const Buffer$1 = globalThis.Buffer;
+const hasNodeBuffer = typeof Buffer$1 !== 'undefined';
+const ByteArrayAllocate = hasNodeBuffer ? Buffer$1.allocUnsafeSlow : Uint8Array;
+const ByteArray = hasNodeBuffer ? Buffer$1 : Uint8Array;
 const MAX_STRUCTURES = 0x100;
 const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000;
 let throwOnIterable;
@@ -1665,7 +1679,7 @@ class Encoder extends Decoder {
 							target[position++] = 0xff; // stop-code
 							return
 						}
-						if (value[Symbol.asyncIterator] || constructor === BlobConstructor) {
+						if (value[Symbol.asyncIterator] || isBlob(value)) {
 							let error = new Error('Iterable/blob should be serialized as iterator');
 							error.iteratorNotHandled = true;
 							throw error;
@@ -1899,7 +1913,8 @@ class Encoder extends Decoder {
 					} else encode(value);
 				}
 			} else if (constructor === Array) {
-				writeArrayHeader(object.length);
+				let length = object.length;
+				writeArrayHeader(length);
 				for (let i = 0; i < length; i++) {
 					let value = object[i];
 					if (value && (typeof value === 'object' || position - start > chunkThreshold)) {
@@ -1920,7 +1935,7 @@ class Encoder extends Decoder {
 					} else encode(value);
 				}
 				target[position++] = 0xff; // stop byte
-			} else if (constructor === BlobConstructor){
+			} else if (isBlob(object)){
 				writeEntityLength(object.size, 0x40); // encode as binary data
 				yield target.subarray(start, position);
 				yield object; // directly return blobs, they have to be encoded asynchronously
@@ -1977,7 +1992,7 @@ class Encoder extends Decoder {
 				let constructor = encodedValue.constructor;
 				if (constructor === ByteArray || constructor === Uint8Array)
 					yield encodedValue;
-				else if (constructor === BlobConstructor) {
+				else if (isBlob(encodedValue)) {
 					let reader = encodedValue.stream().getReader();
 					let next;
 					while (!(next = await reader.read()).done) {
@@ -2072,6 +2087,13 @@ function writeArrayHeader(length) {
 	}
 }
 
+const BlobConstructor = typeof Blob === 'undefined' ? function(){} : Blob;
+function isBlob(object) {
+	if (object instanceof BlobConstructor)
+		return true;
+	let tag = object[Symbol.toStringTag];
+	return tag === 'Blob' || tag === 'File';
+}
 function findRepetitiveStrings(value, packedValues) {
 	switch(typeof value) {
 		case 'string':
@@ -2230,7 +2252,7 @@ function typedArrayEncoder(tag, size) {
 			let length = typedArray.byteLength;
 			let offset = typedArray.byteOffset || 0;
 			let buffer = typedArray.buffer || typedArray;
-			encode(hasNodeBuffer ? Buffer.from(buffer, offset, length) :
+			encode(hasNodeBuffer ? Buffer$1.from(buffer, offset, length) :
 				new Uint8Array(buffer, offset, length));
 		}
 	}