LibJS+LibWeb: Implement resizable ArrayBuffer support for TypedArray

This is (part of) a normative change in the ECMA-262 spec. See:
a9ae96e

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.notify.js

@@ -11,7 +11,10 @@ describe("errors", () => {
             detachArrayBuffer(typedArray.buffer);
 
             Atomics.notify(typedArray, 0, 0);
-        }).toThrowWithMessage(TypeError, "ArrayBuffer is detached");
+        }).toThrowWithMessage(
+            TypeError,
+            "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+        );
     });
 
     test("invalid TypedArray type", () => {

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.wait.js

@@ -11,7 +11,10 @@ describe("errors", () => {
             detachArrayBuffer(typedArray.buffer);
 
             Atomics.wait(typedArray, 0, 0, 0);
-        }).toThrowWithMessage(TypeError, "ArrayBuffer is detached");
+        }).toThrowWithMessage(
+            TypeError,
+            "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+        );
     });
 
     test("invalid TypedArray type", () => {

Userland/Libraries/LibJS/Tests/builtins/Atomics/Atomics.waitAsync.js

@@ -11,7 +11,10 @@ describe("errors", () => {
             detachArrayBuffer(typedArray.buffer);
 
             Atomics.waitAsync(typedArray, 0, 0, 0);
-        }).toThrowWithMessage(TypeError, "ArrayBuffer is detached");
+        }).toThrowWithMessage(
+            TypeError,
+            "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+        );
     });
 
     test("invalid TypedArray type", () => {

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.at.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.at(0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.at).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.byteLength.js

@@ -24,3 +24,17 @@ test("basic functionality", () => {
         expect(typedArray.byteLength).toBe(T.expected);
     });
 });
+
+test("resizable ArrayBuffer", () => {
+    TYPED_ARRAYS.forEach(T => {
+        let arrayBuffer = new ArrayBuffer(T.array.BYTES_PER_ELEMENT * 2, {
+            maxByteLength: T.array.BYTES_PER_ELEMENT * 4,
+        });
+
+        let typedArray = new T.array(arrayBuffer, T.array.BYTES_PER_ELEMENT, 1);
+        expect(typedArray.byteLength).toBe(T.array.BYTES_PER_ELEMENT);
+
+        arrayBuffer.resize(T.array.BYTES_PER_ELEMENT);
+        expect(typedArray.byteLength).toBe(0);
+    });
+});

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.byteOffset.js

@@ -33,3 +33,17 @@ test("basic functionality", () => {
         expect(arrayFromOffset[1]).toBe(!isBigIntArray ? 3 : 3n);
     });
 });
+
+test("resizable ArrayBuffer", () => {
+    TYPED_ARRAYS.forEach(T => {
+        let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+            maxByteLength: T.BYTES_PER_ELEMENT * 4,
+        });
+
+        let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+        expect(typedArray.byteOffset).toBe(T.BYTES_PER_ELEMENT);
+
+        arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+        expect(typedArray.byteOffset).toBe(0);
+    });
+});

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.copyWithin.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.copyWithin(0, 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("length is 2", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.copyWithin).toHaveLength(2);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.entries.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.entries();
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("length is 0", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.entries).toHaveLength(0);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.every.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.every(value => value === 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("length is 1", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.every).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.fill.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.fill(0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.fill).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.filter.js

@@ -38,6 +38,22 @@ describe("errors", () => {
                 new T().filter(undefined);
             }).toThrowWithMessage(TypeError, "undefined is not a function");
         });
+
+        test(`ArrayBuffer out of bounds (${T.name})`, () => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.filter(value => value === 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
     }
 
     TYPED_ARRAYS.forEach(T => argumentErrorTests(T));

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.find.js

@@ -38,6 +38,22 @@ describe("errors", () => {
                 new T().find(undefined);
             }).toThrowWithMessage(TypeError, "undefined is not a function");
         });
+
+        test(`ArrayBuffer out of bounds (${T.name})`, () => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.find(value => value === 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
     }
 
     TYPED_ARRAYS.forEach(T => errorTests(T));

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.findIndex.js

@@ -38,6 +38,22 @@ describe("errors", () => {
                 new T().findIndex(undefined);
             }).toThrowWithMessage(TypeError, "undefined is not a function");
         });
+
+        test(`ArrayBuffer out of bounds (${T.name})`, () => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.findIndex(value => value === 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
     }
 
     TYPED_ARRAYS.forEach(T => errorTests(T));

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.findLast.js

@@ -38,6 +38,22 @@ describe("errors", () => {
                 new T().findLast(undefined);
             }).toThrowWithMessage(TypeError, "undefined is not a function");
         });
+
+        test(`ArrayBuffer out of bounds (${T.name})`, () => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.findLast(value => value === 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
     }
 
     TYPED_ARRAYS.forEach(T => errorTests(T));

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.findLastIndex.js

@@ -38,6 +38,22 @@ describe("errors", () => {
                 new T().findLastIndex(undefined);
             }).toThrowWithMessage(TypeError, "undefined is not a function");
         });
+
+        test(`ArrayBuffer out of bounds (${T.name})`, () => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.findLastIndex(value => value === 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
     }
 
     TYPED_ARRAYS.forEach(T => errorTests(T));

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.forEach.js

@@ -38,6 +38,22 @@ describe("errors", () => {
                 new T().forEach(undefined);
             }).toThrowWithMessage(TypeError, "undefined is not a function");
         });
+
+        test(`ArrayBuffer out of bounds (${T.name})`, () => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.forEach(() => {});
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
     }
 
     TYPED_ARRAYS.forEach(T => errorTests(T));

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.includes.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.includes(0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.includes).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.indexOf.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.indexOf(0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.indexOf).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.keys.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.keys();
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("length is 0", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.keys).toHaveLength(0);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.lastIndexOf.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.lastIndexOf(0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.lastIndexOf).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.length.js

@@ -19,3 +19,17 @@ test("basic functionality", () => {
         expect(typedArray.length).toBe(42);
     });
 });
+
+test("resizable ArrayBuffer", () => {
+    TYPED_ARRAYS.forEach(T => {
+        let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+            maxByteLength: T.BYTES_PER_ELEMENT * 4,
+        });
+
+        let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+        expect(typedArray.length).toBe(1);
+
+        arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+        expect(typedArray.length).toBe(0);
+    });
+});

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.map.js

@@ -38,6 +38,22 @@ describe("errors", () => {
                 new T().map(undefined);
             }).toThrowWithMessage(TypeError, "undefined is not a function");
         });
+
+        test(`ArrayBuffer out of bounds (${T.name})`, () => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.map(value => value);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
     }
 
     TYPED_ARRAYS.forEach(T => argumentErrorTests(T));

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.reduce.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.reduce((accumulator, value) => accumulator + value);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.reduce).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.reduceRight.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.reduceRight((accumulator, value) => accumulator + value);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.reduceRight).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.reverse.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.reverse();
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("length is 0", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.reverse).toHaveLength(0);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.set.js

@@ -15,6 +15,33 @@ const BIGINT_TYPED_ARRAYS = [
     { array: BigInt64Array, maxUnsignedInteger: 2n ** 63n - 1n },
 ];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.array.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.array.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T.array(arrayBuffer, T.array.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.array.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.set([0]);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+
+            expect(() => {
+                typedArray.set(new T.array());
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 // FIXME: Write out a full test suite for this function. This currently only performs a single regression test.
 describe("normal behavior", () => {
     // Previously, we didn't apply source's byte offset on the code path for setting a typed array

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.slice.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.slice(0, 1);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.slice).toHaveLength(2);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.some.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.some(value => value === 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("length is 1", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.some).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.sort.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.sort();
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.sort).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.subarray.js

@@ -43,3 +43,17 @@ test("basic functionality", () => {
         expect(typedArray[1]).toBe(4n);
     });
 });
+
+test("resizable ArrayBuffer", () => {
+    TYPED_ARRAYS.forEach(T => {
+        let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+            maxByteLength: T.BYTES_PER_ELEMENT * 4,
+        });
+
+        let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+        expect(typedArray.subarray(0, 1).byteLength).toBe(T.BYTES_PER_ELEMENT);
+
+        arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+        expect(typedArray.subarray(0, 1).byteLength).toBe(0);
+    });
+});

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.toLocaleString.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.toLocaleString();
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.toLocaleString).toHaveLength(0);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.toReversed.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.toReversed();
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("length is 0", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.toReversed).toHaveLength(0);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.toSorted.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.toSorted();
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("basic functionality", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.toSorted).toHaveLength(1);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.values.js

@@ -12,6 +12,26 @@ const TYPED_ARRAYS = [
 
 const BIGINT_TYPED_ARRAYS = [BigUint64Array, BigInt64Array];
 
+describe("errors", () => {
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.values();
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
+});
+
 test("length is 0", () => {
     TYPED_ARRAYS.forEach(T => {
         expect(T.prototype.values).toHaveLength(0);

Userland/Libraries/LibJS/Tests/builtins/TypedArray/TypedArray.prototype.with.js

@@ -48,6 +48,24 @@ describe("errors", () => {
             }).toThrowWithMessage(RangeError, "Invalid integer index: -inf");
         });
     });
+
+    test("ArrayBuffer out of bounds", () => {
+        TYPED_ARRAYS.forEach(T => {
+            let arrayBuffer = new ArrayBuffer(T.BYTES_PER_ELEMENT * 2, {
+                maxByteLength: T.BYTES_PER_ELEMENT * 4,
+            });
+
+            let typedArray = new T(arrayBuffer, T.BYTES_PER_ELEMENT, 1);
+            arrayBuffer.resize(T.BYTES_PER_ELEMENT);
+
+            expect(() => {
+                typedArray.with(0, 0);
+            }).toThrowWithMessage(
+                TypeError,
+                "TypedArray contains a property which references a value at an index not contained within its buffer's bounds"
+            );
+        });
+    });
 });
 
 describe("normal behavior", () => {