cbor-x 1.6.0 → 1.6.3

package/dist/test.js

@@ -267,6 +267,7 @@
 					}
 					token = dataView.getUint32(position$1);
 					position$1 += 4;
+					if (majorType === 1) return -1 - token; // can't safely use negation operator here
 					break
 				case 0x1b:
 					if (majorType == 7) {
@@ -281,8 +282,7 @@
 					} else if (currentDecoder.int64AsNumber) {
 						token = dataView.getUint32(position$1) * 0x100000000;
 						token += dataView.getUint32(position$1 + 4);
-					} else
-						token = dataView.getBigUint64(position$1);
+					} else token = dataView.getBigUint64(position$1);
 					position$1 += 8;
 					break
 				case 0x1f: 
@@ -1233,8 +1233,8 @@
 			let structures;
 			let referenceMap;
 			options = options || {};
-			let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position, maxBytes) {
-				return target.utf8Write(string, position, maxBytes)
+			let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
+				return target.utf8Write(string, position, target.byteLength - position)
 			} : (textEncoder && textEncoder.encodeInto) ?
 				function(string, position) {
 					return textEncoder.encodeInto(string, target.subarray(position)).written
@@ -1615,7 +1615,7 @@
 							targetView.setUint32(position, value);
 							position += 4;
 						}
-					} else if (!this.alwaysUseFloat && value >> 0 === value) { // negative integer
+					} else if (!this.alwaysUseFloat && value >> 0 === value) { // negative integer, 31-bit or less
 						if (value >= -0x18) {
 							target[position++] = 0x1f - value;
 						} else if (value >= -0x100) {
@@ -1630,6 +1630,11 @@
 							targetView.setUint32(position, ~value);
 							position += 4;
 						}
+					} else if (!this.alwaysUseFloat && value < 0 && value >= -0x100000000 && Math.floor(value) === value) {
+						// negative integer, 32-bit or less
+						target[position++] = 0x3a;
+						targetView.setUint32(position, -1 - value);
+						position += 4;
 					} else {
 						let useFloat32;
 						if ((useFloat32 = this.useFloat32) > 0 && value < 0x100000000 && value >= -0x80000000) {
@@ -1671,6 +1676,9 @@
 						}
 						let constructor = value.constructor;
 						if (constructor === Object) {
+							if (this.skipFunction === true) {
+								value = Object.fromEntries([...Object.keys(value).filter(x => typeof value[x] !== "function").map(x => [x, value[x]])]);
+							}
 							writeObject(value);
 						} else if (constructor === Array) {
 							length = value.length;
@@ -2595,6 +2603,10 @@
 			assert.equal(deserialized, data);
 		});
 
+		test('string overflow', function() {
+			assert.throws(() => decode$1(Buffer.from('7a10000000', 'hex')));
+		});
+
 		test('encode/decode sample data', function(){
 			var data = sampleData;
 			var serialized = encode$1(data);
@@ -3082,7 +3094,12 @@
 			var deserialized = decode(serialized);
 			assert.deepEqual(deserialized, data);
 		});
-
+		test('numbers are compact', function(){
+			assert.equal(encode(-256).length, 2);
+			let encoding = encode(-4294967296);
+			assert.equal(encoding.length, 5);
+			assert.equal(decode(encoding), -4294967296);
+		});
 		test('encode ArrayBuffer', function() {
 			let ua = new Uint8Array([3, 4, 5]);
 			let encoded = encode(ua.buffer);
@@ -3181,6 +3198,20 @@
 			decodeMultiple(new Uint8Array([1, 2, 3, 4]), value => values.push(value));
 			assert.deepEqual(values, [1, 2, 3, 4]);
 		});
+		test('skipFunction', () => {
+			var data = {
+				a: 325283295382932843n,
+				f: () => {},
+			};
+			let encoder = new Encoder({
+				int64AsNumber: true,
+				skipFunction: true,
+			});
+			var serialized = encoder.encode(data);
+			var deserialized = encoder.decode(serialized);
+			assert.deepEqual(deserialized.a, 325283295382932843);
+			assert.equal(Object.hasOwn(deserialized, "f"), false);
+		});
 		test('bad input', function() {
 			let badInput = Buffer.from('7b2273657269616c6e6f223a2265343a30222c226970223a223139322e3136382e312e3335222c226b6579223a226770735f736563726574227d', 'hex');
 			assert.throws(function(){ decode(badInput); }); // should throw, not crash