[Fix] ES2024+: ArrayBufferCopyAndDetach: properly handle resizable ArrayBuffers; add tests

Author: ljharb

2024/ArrayBufferCopyAndDetach.js

@@ -36,13 +36,15 @@ var ToIndex = require('./ToIndex');
 var isArrayBuffer = require('is-array-buffer');
 var isSharedArrayBuffer = require('is-shared-array-buffer');
 
+// https://262.ecma-international.org/15.0/#sec-arraybuffercopyanddetach
+
 module.exports = function ArrayBufferCopyAndDetach(arrayBuffer, newLength, preserveResizability) {
 	if (preserveResizability !== 'PRESERVE-RESIZABILITY' && preserveResizability !== 'FIXED-LENGTH') {
 		throw new $TypeError('`preserveResizability` must be ~PRESERVE-RESIZABILITY~ or ~FIXED-LENGTH~');
 	}
 
 	if (!isArrayBuffer(arrayBuffer) || isSharedArrayBuffer(arrayBuffer)) {
-		throw new $TypeError('`arrayBuffer` must be an ArrayBuffer'); // steps 1 - 2
+		throw new $TypeError('`arrayBuffer` must be a non-shared ArrayBuffer'); // steps 1 - 2
 	}
 
 	var abByteLength;
@@ -77,7 +79,7 @@ module.exports = function ArrayBufferCopyAndDetach(arrayBuffer, newLength, prese
 		abByteLength = byteLength(arrayBuffer);
 	}
 	var copyLength = min(newByteLength, abByteLength); // step 10
-	if (newByteLength > copyLength) {
+	if (newByteLength > copyLength || newMaxByteLength !== 'EMPTY') {
 		var taNew = new $Uint8Array(newBuffer);
 		var taOld = new $Uint8Array(arrayBuffer);
 		for (var i = 0; i < copyLength; i++) {

test/tests.js

@@ -15048,6 +15048,103 @@ var es2024 = function ES2024(ES, ops, expectedMissing, skips) {
 		t.end();
 	});
 
+	test('ArrayBufferCopyAndDetach', function (t) {
+		forEach([].concat(
+			v.primitives,
+			v.objects
+		), function (nonAB) {
+			t['throws'](
+				function () { ES.ArrayBufferCopyAndDetach(nonAB, 0, 'FIXED-LENGTH'); },
+				TypeError,
+				debug(nonAB) + ' is not an ArrayBuffer or a SharedArrayBuffer'
+			);
+		});
+
+		t.test('ArrayBuffers supported', { skip: typeof ArrayBuffer !== 'function' }, function (st) {
+			var ab = new Uint8Array([1, 2, 3, 4]).buffer;
+
+			st.test('can not detach', { skip: canDetach }, function (s2t) {
+				s2t['throws'](
+					function () { ES.ArrayBufferCopyAndDetach(new ArrayBuffer(8), 0, 'FIXED-LENGTH'); },
+					SyntaxError,
+					'throws a syntax error when it can not detach'
+				);
+
+				s2t.end();
+			});
+
+			st.test('can detach', { skip: !canDetach }, function (s2t) {
+				forEach(v.nonStrings, function (nonString) {
+					s2t['throws'](
+						function () { ES.ArrayBufferCopyAndDetach(ab, 0, nonString); },
+						TypeError,
+						debug(nonString) + ' is not a valid preserveResizability value'
+					);
+				});
+
+				s2t.equal(ES.IsDetachedBuffer(ab), false, 'buffer is not detached');
+				var newBuffer = ES.ArrayBufferCopyAndDetach(ab, undefined, 'FIXED-LENGTH');
+				s2t.equal(ES.IsDetachedBuffer(ab), true, 'buffer is now detached');
+				s2t.deepEqual(new Uint8Array(newBuffer), new Uint8Array([1, 2, 3, 4]), 'new buffer has expected data');
+
+				var newSameBuffer = ES.ArrayBufferCopyAndDetach(newBuffer, 4, 'FIXED-LENGTH');
+				s2t.equal(ES.IsDetachedBuffer(newBuffer), true, 'buffer is now detached');
+				s2t.deepEqual(new Uint8Array(newSameBuffer), new Uint8Array([1, 2, 3, 4]), 'new buffer has expected data');
+
+				var newSmallerBuffer = ES.ArrayBufferCopyAndDetach(newSameBuffer, 2, 'FIXED-LENGTH');
+				s2t.equal(ES.IsDetachedBuffer(newSameBuffer), true, 'buffer is now detached');
+				s2t.deepEqual(new Uint8Array(newSmallerBuffer), new Uint8Array([1, 2]), 'new buffer has expected data');
+
+				var newLargerBuffer = ES.ArrayBufferCopyAndDetach(newSmallerBuffer, 4, 'FIXED-LENGTH');
+				s2t.equal(ES.IsDetachedBuffer(newSmallerBuffer), true, 'buffer is now detached');
+				s2t.deepEqual(new Uint8Array(newLargerBuffer), new Uint8Array([1, 2, 0, 0]), 'new buffer has expected data');
+
+				s2t['throws'](
+					function () { ES.ArrayBufferCopyAndDetach(ab, 0, 'FIXED-LENGTH'); },
+					TypeError,
+					'throws on already-detached buffer'
+				);
+
+				s2t.test('resizables', { skip: !('resizable' in ArrayBuffer.prototype) }, function (s3t) {
+					var rab = new ArrayBuffer(4, { maxByteLength: 64 });
+					assign(new Uint8Array(rab), [1, 2, 3, 4]);
+
+					s3t.equal(ES.IsDetachedBuffer(rab), false, 'buffer is not detached');
+					s3t.equal(rab.resizable, true, 'buffer is resizable');
+					var newResizableBuffer = ES.ArrayBufferCopyAndDetach(rab, undefined, 'PRESERVE-RESIZABILITY');
+					s3t.equal(ES.IsDetachedBuffer(rab), true, 'buffer is now detached');
+					s3t.deepEqual(new Uint8Array(newResizableBuffer), new Uint8Array([1, 2, 3, 4]), 'new buffer has expected data');
+					s3t.equal(newResizableBuffer.resizable, true, 'new buffer is resizable');
+
+					var newFixedBuffer = ES.ArrayBufferCopyAndDetach(newResizableBuffer, undefined, 'FIXED-LENGTH');
+					s3t.equal(ES.IsDetachedBuffer(newResizableBuffer), true, 'buffer is now detached');
+					s3t.deepEqual(new Uint8Array(newFixedBuffer), new Uint8Array([1, 2, 3, 4]), 'new buffer has expected data');
+					s3t.equal(newFixedBuffer.resizable, false, 'new buffer is not resizable');
+
+					s3t.end();
+				});
+
+				s2t.end();
+			});
+
+			st.end();
+		});
+
+		t.test('SharedArrayBuffers supported', { skip: typeof SharedArrayBuffer !== 'function' }, function (st) {
+			var sab = new SharedArrayBuffer(1);
+
+			st['throws'](
+				function () { ES.ArrayBufferCopyAndDetach(sab, undefined, 'FIXED-LENGTH'); },
+				TypeError,
+				debug(sab) + ' is not a non-shared ArrayBuffer'
+			);
+
+			st.end();
+		});
+
+		t.end();
+	});
+
 	test('FindViaPredicate', function (t) {
 		forEach(v.primitives, function (primitive) {
 			t['throws'](