diff --git a/Jint.Tests.Test262/Test262Harness.settings.json b/Jint.Tests.Test262/Test262Harness.settings.json
index 76a0084d2b..867263c5b1 100644
--- a/Jint.Tests.Test262/Test262Harness.settings.json
+++ b/Jint.Tests.Test262/Test262Harness.settings.json
@@ -1,5 +1,5 @@
 {
-  "SuiteGitSha": "c2ae5ed5e90d86e17730730b003e9b6fb050693e",
+  "SuiteGitSha": "c3a326ace810e7c80a4e1b8df8c8b704ed223c28",
   //"SuiteDirectory": "//mnt/c/work/test262",
   "TargetPath": "./Generated",
   "Namespace": "Jint.Tests.Test262",
@@ -11,6 +11,7 @@
     "Float16Array",
     "import-assertions",
     "iterator-helpers",
+    "promise-try",
     "regexp-duplicate-named-groups",
     "regexp-lookbehind",
     "regexp-modifiers",
@@ -73,7 +74,7 @@
     // C# can't distinguish 1.797693134862315808e+308 and 1.797693134862315708145274237317e+308
     "language/types/number/8.5.1.js",
 
-    // inner binding is immutable (from parameters) Expected SameValue(«null», «function() {{ ... }}») to be true
+    // inner binding is immutable (from parameters) Expected SameValue(�null�, �function() {{ ... }}�) to be true
     "language/expressions/function/scope-name-var-open-non-strict.js",
     "language/expressions/function/scope-name-var-open-strict.js",
 
diff --git a/Jint/Native/Array/ArrayIteratorPrototype.cs b/Jint/Native/Array/ArrayIteratorPrototype.cs
index 21060e9432..5ed85f0eda 100644
--- a/Jint/Native/Array/ArrayIteratorPrototype.cs
+++ b/Jint/Native/Array/ArrayIteratorPrototype.cs
@@ -1,7 +1,9 @@
 using Jint.Collections;
+using Jint.Native.ArrayBuffer;
 using Jint.Native.Iterator;
 using Jint.Native.Object;
 using Jint.Native.Symbol;
+using Jint.Native.TypedArray;
 using Jint.Runtime;
 using Jint.Runtime.Descriptors;
 using Jint.Runtime.Interop;
@@ -119,7 +121,12 @@ public override bool TryIteratorStep(out ObjectInstance nextItem)
             if (_typedArray is not null)
             {
                 _typedArray._viewedArrayBuffer.AssertNotDetached();
-                len = _typedArray.GetLength();
+                var taRecord = IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(_typedArray, ArrayBufferOrder.SeqCst);
+                if (!_closed && taRecord.IsTypedArrayOutOfBounds)
+                {
+                    ExceptionHelper.ThrowTypeError(_typedArray.Engine.Realm, "TypedArray is out of bounds");
+                }
+                len = taRecord.TypedArrayLength;
             }
             else
             {
diff --git a/Jint/Native/JsTypedArray.cs b/Jint/Native/JsTypedArray.cs
index ceb46ff93b..592133d375 100644
--- a/Jint/Native/JsTypedArray.cs
+++ b/Jint/Native/JsTypedArray.cs
@@ -54,6 +54,8 @@ public JsValue this[uint index]
 
         internal override uint GetLength() => IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(this, ArrayBufferOrder.Unordered).TypedArrayLength;
 
+        internal override bool IsArrayLike => true;
+
         internal override bool IsIntegerIndexedArray => true;
 
         /// <summary>
diff --git a/Jint/Native/TypedArray/IntrinsicTypedArrayConstructor.cs b/Jint/Native/TypedArray/IntrinsicTypedArrayConstructor.cs
index 82bd9243b4..9ed6f61b83 100644
--- a/Jint/Native/TypedArray/IntrinsicTypedArrayConstructor.cs
+++ b/Jint/Native/TypedArray/IntrinsicTypedArrayConstructor.cs
@@ -174,7 +174,7 @@ internal static JsTypedArray TypedArrayCreate(Realm realm, IConstructor construc
             {
                 if (taRecord.IsTypedArrayOutOfBounds)
                 {
-                    ExceptionHelper.ThrowTypeError(realm);
+                    ExceptionHelper.ThrowTypeError(realm, "TypedArray is out of bounds");
                 }
                 if (newTypedArray.GetLength() < number._value)
                 {
diff --git a/Jint/Native/TypedArray/IntrinsicTypedArrayPrototype.cs b/Jint/Native/TypedArray/IntrinsicTypedArrayPrototype.cs
index 051e32450d..14e13916e4 100644
--- a/Jint/Native/TypedArray/IntrinsicTypedArrayPrototype.cs
+++ b/Jint/Native/TypedArray/IntrinsicTypedArrayPrototype.cs
@@ -208,7 +208,8 @@ public uint TypedArrayLength
                     var byteOffset  = o._byteOffset;
                     var elementSize = o._arrayElementType.GetElementSize();
                     var byteLength = (double) CachedBufferByteLength;
-                    return (uint) System.Math.Floor((byteLength - byteOffset) / elementSize);
+                    var floor = System.Math.Floor((byteLength - byteOffset) / elementSize);
+                    return floor < 0 ? 0 : (uint) floor;
                 }
             }
 
@@ -337,8 +338,16 @@ private JsValue CopyWithin(JsValue thisObject, JsValue[] arguments)
                 var buffer = o._viewedArrayBuffer;
                 buffer.AssertNotDetached();
 
+                taRecord = MakeTypedArrayWithBufferWitnessRecord(o, ArrayBufferOrder.SeqCst);
+                if (taRecord.IsTypedArrayOutOfBounds)
+                {
+                    ExceptionHelper.ThrowTypeError(_realm, "TypedArray is out of bounds");
+                }
+
+                len = taRecord.TypedArrayLength;
                 var elementSize = o._arrayElementType.GetElementSize();
                 var byteOffset = o._byteOffset;
+                var bufferByteLimit = len * elementSize + byteOffset;
                 var toByteIndex = to * elementSize + byteOffset;
                 var fromByteIndex = from * elementSize + byteOffset;
                 var countBytes = count * elementSize;
@@ -357,11 +366,18 @@ private JsValue CopyWithin(JsValue thisObject, JsValue[] arguments)
 
                 while (countBytes > 0)
                 {
-                    var value = buffer.GetValueFromBuffer((int) fromByteIndex, TypedArrayElementType.Uint8, true, ArrayBufferOrder.Unordered);
-                    buffer.SetValueInBuffer((int) toByteIndex, TypedArrayElementType.Uint8, value, true, ArrayBufferOrder.Unordered);
-                    fromByteIndex += direction;
-                    toByteIndex += direction;
-                    countBytes--;
+                    if (fromByteIndex < bufferByteLimit && toByteIndex < bufferByteLimit)
+                    {
+                        var value = buffer.GetValueFromBuffer((int) fromByteIndex, TypedArrayElementType.Uint8, isTypedArray: true, ArrayBufferOrder.Unordered);
+                        buffer.SetValueInBuffer((int) toByteIndex, TypedArrayElementType.Uint8, value, isTypedArray: true, ArrayBufferOrder.Unordered);
+                        fromByteIndex += direction;
+                        toByteIndex += direction;
+                        countBytes--;
+                    }
+                    else
+                    {
+                        countBytes = 0;
+                    }
                 }
             }
 
@@ -450,24 +466,33 @@ private JsValue Fill(JsValue thisObject, JsValue[] arguments)
                 k = (int) System.Math.Min(relativeStart, len);
             }
 
-            uint final;
+            uint endIndex;
             var relativeEnd = end.IsUndefined() ? len : TypeConverter.ToIntegerOrInfinity(end);
             if (double.IsNegativeInfinity(relativeEnd))
             {
-                final = 0;
+                endIndex = 0;
             }
             else if (relativeEnd < 0)
             {
-                final = (uint) System.Math.Max(len + relativeEnd, 0);
+                endIndex = (uint) System.Math.Max(len + relativeEnd, 0);
             }
             else
             {
-                final = (uint) System.Math.Min(relativeEnd, len);
+                endIndex = (uint) System.Math.Min(relativeEnd, len);
             }
 
+            taRecord = MakeTypedArrayWithBufferWitnessRecord(o, ArrayBufferOrder.SeqCst);
+            if (taRecord.IsTypedArrayOutOfBounds)
+            {
+                ExceptionHelper.ThrowTypeError(_realm, "TypedArray is out of bounds");
+            }
+
+            len = taRecord.TypedArrayLength;
+            endIndex = System.Math.Min(endIndex, len);
+
             o._viewedArrayBuffer.AssertNotDetached();
 
-            for (var i = k; i < final; ++i)
+            for (var i = k; i < endIndex; ++i)
             {
                 o[i] = value;
             }
diff --git a/Jint/Native/TypedArray/TypeArrayHelper.cs b/Jint/Native/TypedArray/TypeArrayHelper.cs
index 34b1f793b5..0770468425 100644
--- a/Jint/Native/TypedArray/TypeArrayHelper.cs
+++ b/Jint/Native/TypedArray/TypeArrayHelper.cs
@@ -16,7 +16,7 @@ internal static IntrinsicTypedArrayPrototype.TypedArrayWithBufferWitnessRecord V
         var taRecord = IntrinsicTypedArrayPrototype.MakeTypedArrayWithBufferWitnessRecord(typedArray, order);
         if (taRecord.IsTypedArrayOutOfBounds)
         {
-            ExceptionHelper.ThrowTypeError(realm);
+            ExceptionHelper.ThrowTypeError(realm, "TypedArray is out of bounds");
         }
 
         return taRecord;