From c2a63b819fef24dc0bd73d134016d3ba4e7795d1 Mon Sep 17 00:00:00 2001
From: Hans Larsen <hans@larsen.online>
Date: Wed, 11 Dec 2024 14:55:08 -0800
Subject: [PATCH 1/5] Replace all u64/i64 for length, index or offsets into
 usize/isize

On platforms that are 32-bits (or 128?) this should make array and
iterations faster in general. On platforms that are 64-bits, this
will have no effect.
---
 cli/src/debug/limits.rs                       |  16 +--
 .../src/builtins/array/array_iterator.rs      |   2 +-
 core/engine/src/builtins/array/mod.rs         | 109 +++++++++---------
 core/engine/src/builtins/array/tests.rs       |   4 +-
 core/engine/src/builtins/array_buffer/mod.rs  |  33 +++---
 .../src/builtins/array_buffer/shared.rs       |  23 ++--
 .../engine/src/builtins/array_buffer/tests.rs |   4 +-
 .../engine/src/builtins/array_buffer/utils.rs |   2 +-
 core/engine/src/builtins/atomics/mod.rs       |   7 +-
 core/engine/src/builtins/dataview/mod.rs      |  25 ++--
 core/engine/src/builtins/regexp/mod.rs        |  42 +++----
 core/engine/src/builtins/string/mod.rs        |  12 +-
 .../src/builtins/typed_array/builtin.rs       | 103 +++++++++--------
 core/engine/src/builtins/typed_array/mod.rs   |  10 +-
 .../engine/src/builtins/typed_array/object.rs |  30 +++--
 core/engine/src/context/hooks.rs              |   2 +-
 core/engine/src/error.rs                      |   2 +-
 core/engine/src/object/builtins/jsarray.rs    |   4 +-
 .../src/object/builtins/jsarraybuffer.rs      |   2 +-
 core/engine/src/object/builtins/jsdataview.rs |  20 ++--
 .../object/builtins/jssharedarraybuffer.rs    |   2 +-
 core/engine/src/object/operations.rs          |   6 +-
 .../src/value/conversions/serde_json.rs       |   2 +-
 core/engine/src/value/mod.rs                  |   8 +-
 core/engine/src/value/tests.rs                |   2 +-
 core/engine/src/vm/opcode/templates/mod.rs    |   4 +-
 examples/src/bin/jsarraybuffer.rs             |   2 +-
 27 files changed, 233 insertions(+), 245 deletions(-)

diff --git a/cli/src/debug/limits.rs b/cli/src/debug/limits.rs
index b73e7a45fa5..84017a3e1e1 100644
--- a/cli/src/debug/limits.rs
+++ b/cli/src/debug/limits.rs
@@ -2,7 +2,7 @@ use boa_engine::{
     js_string,
     object::{FunctionObjectBuilder, ObjectInitializer},
     property::Attribute,
-    Context, JsArgs, JsNativeError, JsObject, JsResult, JsValue, NativeFunction,
+    Context, JsArgs, JsObject, JsResult, JsValue, NativeFunction,
 };
 
 fn get_loop(_: &JsValue, _: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
@@ -12,7 +12,9 @@ fn get_loop(_: &JsValue, _: &[JsValue], context: &mut Context) -> JsResult<JsVal
 
 fn set_loop(_: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
     let value = args.get_or_undefined(0).to_length(context)?;
-    context.runtime_limits_mut().set_loop_iteration_limit(value);
+    context
+        .runtime_limits_mut()
+        .set_loop_iteration_limit(value as u64);
     Ok(JsValue::undefined())
 }
 
@@ -23,11 +25,6 @@ fn get_stack(_: &JsValue, _: &[JsValue], context: &mut Context) -> JsResult<JsVa
 
 fn set_stack(_: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
     let value = args.get_or_undefined(0).to_length(context)?;
-    let Ok(value) = value.try_into() else {
-        return Err(JsNativeError::range()
-            .with_message(format!("Argument {value} greater than usize::MAX"))
-            .into());
-    };
     context.runtime_limits_mut().set_stack_size_limit(value);
     Ok(JsValue::undefined())
 }
@@ -39,11 +36,6 @@ fn get_recursion(_: &JsValue, _: &[JsValue], context: &mut Context) -> JsResult<
 
 fn set_recursion(_: &JsValue, args: &[JsValue], context: &mut Context) -> JsResult<JsValue> {
     let value = args.get_or_undefined(0).to_length(context)?;
-    let Ok(value) = value.try_into() else {
-        return Err(JsNativeError::range()
-            .with_message(format!("Argument {value} greater than usize::MAX"))
-            .into());
-    };
     context.runtime_limits_mut().set_recursion_limit(value);
     Ok(JsValue::undefined())
 }
diff --git a/core/engine/src/builtins/array/array_iterator.rs b/core/engine/src/builtins/array/array_iterator.rs
index d323a7ad60a..1290769f35d 100644
--- a/core/engine/src/builtins/array/array_iterator.rs
+++ b/core/engine/src/builtins/array/array_iterator.rs
@@ -31,7 +31,7 @@ use boa_profiler::Profiler;
 #[derive(Debug, Clone, Finalize, Trace, JsData)]
 pub(crate) struct ArrayIterator {
     array: JsObject,
-    next_index: u64,
+    next_index: usize,
     #[unsafe_ignore_trace]
     kind: PropertyNameKind,
     done: bool,
diff --git a/core/engine/src/builtins/array/mod.rs b/core/engine/src/builtins/array/mod.rs
index f392efbe74f..4f0f109f12a 100644
--- a/core/engine/src/builtins/array/mod.rs
+++ b/core/engine/src/builtins/array/mod.rs
@@ -267,7 +267,7 @@ impl BuiltInConstructor for Array {
             debug_assert!(number_of_args >= 2);
 
             // b. Let array be ? ArrayCreate(numberOfArgs, proto).
-            let array = Self::array_create(number_of_args as u64, Some(prototype), context)?;
+            let array = Self::array_create(number_of_args, Some(prototype), context)?;
 
             // c. Let k be 0.
             // d. Repeat, while k < numberOfArgs,
@@ -289,8 +289,8 @@ impl BuiltInConstructor for Array {
 
 impl Array {
     /// Optimized helper function, that sets the length of the array.
-    fn set_length(o: &JsObject, len: u64, context: &mut Context) -> JsResult<()> {
-        if o.is_array() && len < (2u64.pow(32) - 1) {
+    fn set_length(o: &JsObject, len: usize, context: &mut Context) -> JsResult<()> {
+        if o.is_array() && len < (u32::MAX - 1) as usize {
             let mut borrowed_object = o.borrow_mut();
             if borrowed_object.properties().shape.to_addr_usize()
                 == context
@@ -317,12 +317,12 @@ impl Array {
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-arraycreate
     pub(crate) fn array_create(
-        length: u64,
+        length: usize,
         prototype: Option<JsObject>,
         context: &mut Context,
     ) -> JsResult<JsObject> {
         // 1. If length > 2^32 - 1, throw a RangeError exception.
-        if length > 2u64.pow(32) - 1 {
+        if length > (u32::MAX - 1) as usize {
             return Err(JsNativeError::range()
                 .with_message("array exceeded max size")
                 .into());
@@ -455,7 +455,7 @@ impl Array {
     /// see: <https://tc39.es/ecma262/#sec-arrayspeciescreate>
     pub(crate) fn array_species_create(
         original_array: &JsObject,
-        length: u64,
+        length: usize,
         context: &mut Context,
     ) -> JsResult<JsObject> {
         // 1. Let isArray be ? IsArray(originalArray).
@@ -617,7 +617,7 @@ impl Array {
         //     i. If k ≥ 2^53 - 1 (MAX_SAFE_INTEGER), then
         //     ...
         //     ix. Set k to k + 1.
-        for k in 0..9_007_199_254_740_991_u64 {
+        for k in 0..(Number::MAX_SAFE_INTEGER as usize) {
             // iii. Let next be ? IteratorStepValue(iteratorRecord).
             let Some(next) = iterator_record.step_value(context)? else {
                 // iv. If next is done, then
@@ -702,7 +702,7 @@ impl Array {
         //     a. Let A be ? ArrayCreate(len).
         let a = match this.as_constructor() {
             Some(constructor) => constructor.construct(&[len.into()], None, context)?,
-            _ => Self::array_create(len as u64, None, context)?,
+            _ => Self::array_create(len, None, context)?,
         };
 
         // 6. Let k be 0.
@@ -716,7 +716,7 @@ impl Array {
         }
 
         // 8. Perform ? Set(A, "length", lenNumber, true).
-        Self::set_length(&a, len as u64, context)?;
+        Self::set_length(&a, len, context)?;
 
         // 9. Return A.
         Ok(a.into())
@@ -781,7 +781,7 @@ impl Array {
         // 2. Let A be ? ArraySpeciesCreate(O, 0).
         let arr = Self::array_species_create(&obj, 0, context)?;
         // 3. Let n be 0.
-        let mut n = 0;
+        let mut n: usize = 0;
         // 4. Prepend O to items.
         // 5. For each element E of items, do
         for item in std::iter::once(&JsValue::new(obj)).chain(args.iter()) {
@@ -796,7 +796,7 @@ impl Array {
                 // ii. Let len be ? LengthOfArrayLike(E).
                 let len = item.length_of_array_like(context)?;
                 // iii. If n + len > 2^53 - 1, throw a TypeError exception.
-                if n + len > Number::MAX_SAFE_INTEGER as u64 {
+                if n.saturating_add(len) > Number::MAX_SAFE_INTEGER as usize {
                     return Err(JsNativeError::typ()
                         .with_message(
                             "length + number of arguments exceeds the max safe integer limit",
@@ -822,7 +822,7 @@ impl Array {
             else {
                 // i. NOTE: E is added as a single item rather than spread.
                 // ii. If n ≥ 2^53 - 1, throw a TypeError exception.
-                if n >= Number::MAX_SAFE_INTEGER as u64 {
+                if n >= Number::MAX_SAFE_INTEGER as usize {
                     return Err(JsNativeError::typ()
                         .with_message("length exceeds the max safe integer limit")
                         .into());
@@ -862,9 +862,9 @@ impl Array {
         // 2. Let len be ? LengthOfArrayLike(O).
         let mut len = o.length_of_array_like(context)?;
         // 3. Let argCount be the number of elements in items.
-        let arg_count = args.len() as u64;
+        let arg_count = args.len();
         // 4. If len + argCount > 2^53 - 1, throw a TypeError exception.
-        if len + arg_count > 2u64.pow(53) - 1 {
+        if len + arg_count > (Number::MAX_SAFE_INTEGER as usize) {
             return Err(JsNativeError::typ()
                 .with_message(
                     "the length + the number of arguments exceed the maximum safe integer limit",
@@ -1200,7 +1200,7 @@ impl Array {
             if let IndexedProperties::DenseI32(dense) =
                 &mut o_borrow.properties_mut().indexed_properties
             {
-                if len <= dense.len() as u64 {
+                if len <= dense.len() {
                     let v = dense.remove(0);
                     drop(o_borrow);
                     Self::set_length(&o, len - 1, context)?;
@@ -1210,7 +1210,7 @@ impl Array {
             if let IndexedProperties::DenseF64(dense) =
                 &mut o_borrow.properties_mut().indexed_properties
             {
-                if len <= dense.len() as u64 {
+                if len <= dense.len() {
                     let v = dense.remove(0);
                     drop(o_borrow);
                     Self::set_length(&o, len - 1, context)?;
@@ -1218,7 +1218,7 @@ impl Array {
                 }
             }
             if let Some(dense) = o_borrow.properties_mut().dense_indexed_properties_mut() {
-                if len <= dense.len() as u64 {
+                if len <= dense.len() {
                     let v = dense.remove(0);
                     drop(o_borrow);
                     Self::set_length(&o, len - 1, context)?;
@@ -1280,11 +1280,11 @@ impl Array {
         // 2. Let len be ? LengthOfArrayLike(O).
         let len = o.length_of_array_like(context)?;
         // 3. Let argCount be the number of elements in items.
-        let arg_count = args.len() as u64;
+        let arg_count = args.len();
         // 4. If argCount > 0, then
         if arg_count > 0 {
             // a. If len + argCount > 2^53 - 1, throw a TypeError exception.
-            if len + arg_count > 2u64.pow(53) - 1 {
+            if len + arg_count > Number::MAX_SAFE_INTEGER as usize {
                 return Err(JsNativeError::typ()
                     .with_message("length + number of arguments exceeds the max safe integer limit")
                     .into());
@@ -1768,8 +1768,8 @@ impl Array {
             // a. Set depthNum to ? ToIntegerOrInfinity(depth).
             // b. If depthNum < 0, set depthNum to 0.
             match depth.to_integer_or_infinity(context)? {
-                IntegerOrInfinity::Integer(value) if value >= 0 => depth_num = value as u64,
-                IntegerOrInfinity::PositiveInfinity => depth_num = u64::MAX,
+                IntegerOrInfinity::Integer(value) if value >= 0 => depth_num = value as usize,
+                IntegerOrInfinity::PositiveInfinity => depth_num = usize::MAX,
                 _ => depth_num = 0,
             }
         };
@@ -1850,13 +1850,13 @@ impl Array {
     fn flatten_into_array(
         target: &JsObject,
         source: &JsObject,
-        source_len: u64,
-        start: u64,
-        depth: u64,
+        source_len: usize,
+        start: usize,
+        depth: usize,
         mapper_function: Option<&JsObject>,
         this_arg: &JsValue,
         context: &mut Context,
-    ) -> JsResult<u64> {
+    ) -> JsResult<usize> {
         // 1. Assert target is Object
         // 2. Assert source is Object
 
@@ -1905,8 +1905,8 @@ impl Array {
                     let element = element.as_object().expect("must be an object");
 
                     // 1. If depth is +Infinity let newDepth be +Infinity
-                    let new_depth = if depth == u64::MAX {
-                        u64::MAX
+                    let new_depth = if depth == usize::MAX {
+                        usize::MAX
                     // 2. Else, let newDepth be depth - 1
                     } else {
                         depth - 1
@@ -1930,7 +1930,7 @@ impl Array {
                 // vi. Else
                 } else {
                     // 1. If targetIndex >= 2^53 - 1, throw a TypeError exception
-                    if target_index >= Number::MAX_SAFE_INTEGER as u64 {
+                    if target_index >= Number::MAX_SAFE_INTEGER as usize {
                         return Err(JsNativeError::typ()
                             .with_message("Target index exceeded max safe integer value")
                             .into());
@@ -2117,7 +2117,7 @@ impl Array {
         let a = Self::array_species_create(&o, count, context)?;
 
         // 13. Let n be 0.
-        let mut n: u64 = 0;
+        let mut n = 0;
         // 14. Repeat, while k < final,
         while k < final_ {
             // a. Let Pk be ! ToString(𝔽(k)).
@@ -2210,12 +2210,12 @@ impl Array {
 
     /// Gets the delete count of a splice operation.
     fn get_delete_count(
-        len: u64,
-        actual_start: u64,
+        len: usize,
+        actual_start: usize,
         start: Option<&JsValue>,
         delete_count: Option<&JsValue>,
         context: &mut Context,
-    ) -> JsResult<u64> {
+    ) -> JsResult<usize> {
         // 8. If start is not present, then
         let actual_delete_count = if start.is_none() {
             // a. Let actualDeleteCount be 0.
@@ -2229,7 +2229,7 @@ impl Array {
             // b. Let actualDeleteCount be the result of clamping dc between 0 and len - actualStart.
             let max = len - actual_start;
             match dc {
-                IntegerOrInfinity::Integer(i) => u64::try_from(i)
+                IntegerOrInfinity::Integer(i) => usize::try_from(i)
                     .unwrap_or_default()
                     .clamp(0, len - actual_start),
                 IntegerOrInfinity::PositiveInfinity => max,
@@ -2272,13 +2272,13 @@ impl Array {
             Self::get_relative_start(context, start.unwrap_or(&JsValue::undefined()), len)?;
 
         // 7. Let itemCount be the number of elements in items.
-        let item_count = items.len() as u64;
+        let item_count = items.len();
 
         let actual_delete_count =
             Self::get_delete_count(len, actual_start, start, delete_count, context)?;
 
         // If len + itemCount - actualDeleteCount > 2**53 - 1, throw a TypeError exception.
-        if len + item_count - actual_delete_count > Number::MAX_SAFE_INTEGER as u64 {
+        if len + item_count - actual_delete_count > Number::MAX_SAFE_INTEGER as usize {
             return Err(JsNativeError::typ()
                 .with_message("Target splice exceeded max safe integer value")
                 .into());
@@ -2303,7 +2303,7 @@ impl Array {
         // 15. Perform ? Set(A, "length", 𝔽(actualDeleteCount), true).
         Self::set_length(&arr, actual_delete_count, context)?;
 
-        let item_count = items.len() as u64;
+        let item_count = items.len();
 
         match item_count.cmp(&actual_delete_count) {
             Ordering::Equal => {}
@@ -2372,7 +2372,7 @@ impl Array {
         for (i, item) in items.iter().enumerate() {
             //     a. Perform ? Set(O, ! ToString(𝔽(k)), E, true).
             //     b. Set k to k + 1.
-            o.set(actual_start + i as u64, item.clone(), true, context)?;
+            o.set(actual_start + i, item.clone(), true, context)?;
         }
 
         // 20. Perform ? Set(O, "length", 𝔽(len - actualDeleteCount + itemCount), true).
@@ -2406,7 +2406,7 @@ impl Array {
             Self::get_relative_start(context, start.unwrap_or(&JsValue::undefined()), len)?;
 
         // 7. Let insertCount be the number of elements in items.
-        let insert_count = items.len() as u64;
+        let insert_count = items.len();
 
         let actual_skip_count =
             Self::get_delete_count(len, actual_start, start, skip_count, context)?;
@@ -2415,7 +2415,7 @@ impl Array {
         let new_len = len + insert_count - actual_skip_count;
 
         // 12. If newLen > 2**53 - 1, throw a TypeError exception.
-        if new_len > Number::MAX_SAFE_INTEGER as u64 {
+        if new_len > Number::MAX_SAFE_INTEGER as usize {
             return Err(JsNativeError::typ()
                 .with_message("Target splice exceeded max safe integer value")
                 .into());
@@ -2593,7 +2593,7 @@ impl Array {
     /// [spec]: https://tc39.es/ecma262/#sec-sortindexedproperties
     pub(crate) fn sort_indexed_properties<F>(
         obj: &JsObject,
-        len: u64,
+        len: usize,
         sort_compare: F,
         skip_holes: bool,
         context: &mut Context,
@@ -2603,7 +2603,7 @@ impl Array {
     {
         // 1. Let items be a new empty List.
         // doesn't matter if it clamps since it's just a best-effort optimization
-        let mut items = Vec::with_capacity(len as usize);
+        let mut items = Vec::with_capacity(len);
 
         // 2. Let k be 0.
         // 3. Repeat, while k < len,
@@ -2691,7 +2691,7 @@ impl Array {
         // 5. Let sortedList be ? SortIndexedProperties(obj, len, SortCompare, skip-holes).
         let sorted = Self::sort_indexed_properties(&obj, len, sort_compare, true, context)?;
 
-        let sorted_len = sorted.len() as u64;
+        let sorted_len = sorted.len();
 
         // 6. Let itemCount be the number of elements in sortedList.
         // 7. Let j be 0.
@@ -3144,11 +3144,12 @@ impl Array {
                 .with_message("invalid integer index for TypedArray operation")
                 .into());
         };
+        let relative_index = relative_index as isize;
 
         let value = args.get_or_undefined(1);
 
         // 4. If relativeIndex ≥ 0, let actualIndex be relativeIndex.
-        let actual_index = u64::try_from(relative_index) // should succeed if `relative_index >= 0`
+        let actual_index = usize::try_from(relative_index) // should succeed if `relative_index >= 0`
             .ok()
             // 5. Else, let actualIndex be len + relativeIndex.
             .or_else(|| len.checked_add_signed(relative_index))
@@ -3190,17 +3191,19 @@ impl Array {
     pub(super) fn get_relative_start(
         context: &mut Context,
         arg: &JsValue,
-        len: u64,
-    ) -> JsResult<u64> {
+        len: usize,
+    ) -> JsResult<usize> {
         // 1. Let relativeStart be ? ToIntegerOrInfinity(start).
         let relative_start = arg.to_integer_or_infinity(context)?;
         let start = match relative_start {
             // 2. If relativeStart is -∞, let k be 0.
             IntegerOrInfinity::NegativeInfinity => 0,
             // 3. Else if relativeStart < 0, let k be max(len + relativeStart, 0).
-            IntegerOrInfinity::Integer(i) if i < 0 => len.checked_add_signed(i).unwrap_or(0),
+            IntegerOrInfinity::Integer(i) if i < 0 => {
+                len.checked_add_signed(i as isize).unwrap_or(0)
+            }
             // 4. Else, let k be min(relativeStart, len).
-            IntegerOrInfinity::Integer(i) => min(i as u64, len),
+            IntegerOrInfinity::Integer(i) => min(i as usize, len),
 
             // Special case - positive infinity. `len` is always smaller than +inf, thus from (4)
             IntegerOrInfinity::PositiveInfinity => len,
@@ -3213,8 +3216,8 @@ impl Array {
     pub(super) fn get_relative_end(
         context: &mut Context,
         value: &JsValue,
-        len: u64,
-    ) -> JsResult<u64> {
+        len: usize,
+    ) -> JsResult<usize> {
         // 1. If end is undefined, let relativeEnd be len [and return it]
         if value.is_undefined() {
             Ok(len)
@@ -3225,10 +3228,12 @@ impl Array {
                 // 2. If relativeEnd is -∞, let final be 0.
                 IntegerOrInfinity::NegativeInfinity => 0,
                 // 3. Else if relativeEnd < 0, let final be max(len + relativeEnd, 0).
-                IntegerOrInfinity::Integer(i) if i < 0 => len.checked_add_signed(i).unwrap_or(0),
+                IntegerOrInfinity::Integer(i) if i < 0 => {
+                    len.checked_add_signed(i as isize).unwrap_or(0)
+                }
                 // 4. Else, let final be min(relativeEnd, len).
                 // Both `as` casts are safe as both variables are non-negative
-                IntegerOrInfinity::Integer(i) => min(i as u64, len),
+                IntegerOrInfinity::Integer(i) => min(i as usize, len),
 
                 // Special case - positive infinity. `len` is always smaller than +inf, thus from (4)
                 IntegerOrInfinity::PositiveInfinity => len,
@@ -3350,7 +3355,7 @@ fn compare_array_elements(
 /// [spec]: https://tc39.es/ecma262/#sec-findviapredicate
 pub(crate) fn find_via_predicate(
     o: &JsObject,
-    len: u64,
+    len: usize,
     direction: Direction,
     predicate: &JsValue,
     this_arg: &JsValue,
diff --git a/core/engine/src/builtins/array/tests.rs b/core/engine/src/builtins/array/tests.rs
index 4df066ca815..d6e8a27469a 100644
--- a/core/engine/src/builtins/array/tests.rs
+++ b/core/engine/src/builtins/array/tests.rs
@@ -874,7 +874,7 @@ fn array_spread_non_iterable() {
 #[test]
 fn get_relative_start() {
     #[track_caller]
-    fn assert(context: &mut Context, arg: Option<&JsValue>, len: u64, expected: u64) {
+    fn assert(context: &mut Context, arg: Option<&JsValue>, len: usize, expected: usize) {
         let arg = arg.unwrap_or(&JsValue::Undefined);
         assert_eq!(
             Array::get_relative_start(context, arg, len).unwrap(),
@@ -901,7 +901,7 @@ fn get_relative_start() {
 #[test]
 fn get_relative_end() {
     #[track_caller]
-    fn assert(context: &mut Context, arg: Option<&JsValue>, len: u64, expected: u64) {
+    fn assert(context: &mut Context, arg: Option<&JsValue>, len: usize, expected: usize) {
         let arg = arg.unwrap_or(&JsValue::Undefined);
         assert_eq!(
             Array::get_relative_end(context, arg, len).unwrap(),
diff --git a/core/engine/src/builtins/array_buffer/mod.rs b/core/engine/src/builtins/array_buffer/mod.rs
index 7c2e3197022..0052be69156 100644
--- a/core/engine/src/builtins/array_buffer/mod.rs
+++ b/core/engine/src/builtins/array_buffer/mod.rs
@@ -201,7 +201,7 @@ pub struct ArrayBuffer {
     data: Option<Vec<u8>>,
 
     /// The `[[ArrayBufferMaxByteLength]]` internal slot.
-    max_byte_len: Option<u64>,
+    max_byte_len: Option<usize>,
 
     /// The `[[ArrayBufferDetachKey]]` internal slot.
     detach_key: JsValue,
@@ -501,7 +501,7 @@ impl ArrayBuffer {
         // 6. Else,
         //     a. Let length be O.[[ArrayBufferMaxByteLength]].
         // 7. Return 𝔽(length).
-        Ok(buf.max_byte_len.unwrap_or(data.len() as u64).into())
+        Ok(buf.max_byte_len.unwrap_or(data.len()).into())
     }
 
     /// [`get ArrayBuffer.prototype.resizable`][spec].
@@ -609,7 +609,7 @@ impl ArrayBuffer {
         //     Implementations may implement this method as in-place growth or shrinkage.
         // 14. Set O.[[ArrayBufferData]] to newBlock.
         // 15. Set O.[[ArrayBufferByteLength]] to newByteLength.
-        buf.resize(new_byte_length as usize, 0);
+        buf.resize(new_byte_length, 0);
 
         // 16. Return undefined.
         Ok(JsValue::undefined())
@@ -642,7 +642,7 @@ impl ArrayBuffer {
                     .into());
             }
             // 5. Let len be O.[[ArrayBufferByteLength]].
-            buf.data.len() as u64
+            buf.data.len()
         };
 
         // 6. Let relativeStart be ? ToIntegerOrInfinity(start).
@@ -695,7 +695,7 @@ impl ArrayBuffer {
             };
 
             // 21. If new.[[ArrayBufferByteLength]] < newLen, throw a TypeError exception.
-            if (to_buf.len() as u64) < new_len {
+            if to_buf.len() < new_len {
                 return Err(JsNativeError::typ()
                     .with_message("new ArrayBuffer length too small")
                     .into());
@@ -712,8 +712,8 @@ impl ArrayBuffer {
             };
 
             // 26. Perform CopyDataBlockBytes(toBuf, 0, fromBuf, first, newLen).
-            let first = first as usize;
-            let new_len = new_len as usize;
+            let first = first;
+            let new_len = new_len;
             to_buf[..new_len].copy_from_slice(&from_buf[first..first + new_len]);
         }
 
@@ -756,7 +756,7 @@ impl ArrayBuffer {
         // 3. If newLength is undefined, then
         let new_len = if new_length.is_undefined() {
             // a. Let newByteLength be arrayBuffer.[[ArrayBufferByteLength]].
-            buf.borrow().data.len() as u64
+            buf.borrow().data.len()
         } else {
             // 4. Else,
             //     a. Let newByteLength be ? ToIndex(newLength).
@@ -805,9 +805,9 @@ impl ArrayBuffer {
                     .into());
             }
             // Should only truncate without reallocating.
-            bytes.resize(new_len as usize, 0);
+            bytes.resize(new_len, 0);
         } else {
-            bytes.resize(new_len as usize, 0);
+            bytes.resize(new_len, 0);
 
             // Realloc the vec to fit onto the new exact length.
             bytes.shrink_to_fit();
@@ -839,8 +839,8 @@ impl ArrayBuffer {
     /// [spec]: https://tc39.es/ecma262/#sec-allocatearraybuffer
     pub(crate) fn allocate(
         constructor: &JsValue,
-        byte_len: u64,
-        max_byte_len: Option<u64>,
+        byte_len: usize,
+        max_byte_len: Option<usize>,
         context: &mut Context,
     ) -> JsResult<JsObject<ArrayBuffer>> {
         // 1. Let slots be « [[ArrayBufferData]], [[ArrayBufferByteLength]], [[ArrayBufferDetachKey]] ».
@@ -892,7 +892,7 @@ impl ArrayBuffer {
 /// Abstract operation [`GetArrayBufferMaxByteLengthOption ( options )`][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#sec-getarraybuffermaxbytelengthoption
-fn get_max_byte_len(options: &JsValue, context: &mut Context) -> JsResult<Option<u64>> {
+fn get_max_byte_len(options: &JsValue, context: &mut Context) -> JsResult<Option<usize>> {
     // 1. If options is not an Object, return empty.
     let Some(options) = options.as_object() else {
         return Ok(None);
@@ -917,8 +917,8 @@ fn get_max_byte_len(options: &JsValue, context: &mut Context) -> JsResult<Option
 ///
 /// [spec]: https://tc39.es/ecma262/#sec-createbytedatablock
 pub(crate) fn create_byte_data_block(
-    size: u64,
-    max_buffer_size: Option<u64>,
+    size: usize,
+    max_buffer_size: Option<usize>,
     context: &mut Context,
 ) -> JsResult<Vec<u8>> {
     let alloc_size = max_buffer_size.unwrap_or(size);
@@ -942,9 +942,6 @@ pub(crate) fn create_byte_data_block(
         JsNativeError::range().with_message(format!("couldn't allocate the data block: {e}"))
     })?;
 
-    // since size <= alloc_size, then `size` must also fit inside a `usize`.
-    let size = size as usize;
-
     // 2. Set all of the bytes of db to 0.
     data_block.resize(size, 0);
 
diff --git a/core/engine/src/builtins/array_buffer/shared.rs b/core/engine/src/builtins/array_buffer/shared.rs
index d19eec5ed55..02aaf78d86a 100644
--- a/core/engine/src/builtins/array_buffer/shared.rs
+++ b/core/engine/src/builtins/array_buffer/shared.rs
@@ -228,7 +228,7 @@ impl SharedArrayBuffer {
             })?;
 
         // 4. Let length be ArrayBufferByteLength(O, seq-cst).
-        let len = buf.bytes(Ordering::SeqCst).len() as u64;
+        let len = buf.bytes(Ordering::SeqCst).len();
 
         // 5. Return 𝔽(length).
         Ok(len.into())
@@ -329,14 +329,14 @@ impl SharedArrayBuffer {
         // d. If newByteLength < currentByteLength or newByteLength > O.[[ArrayBufferMaxByteLength]], throw a RangeError exception.
         // Extracting this condition outside the CAS since throwing early doesn't affect the correct
         // behaviour of the loop.
-        if new_byte_len > buf.data.buffer.len() as u64 {
+        if new_byte_len > buf.data.buffer.len() {
             return Err(JsNativeError::range()
                 .with_message(
                     "SharedArrayBuffer.grow: new length cannot be bigger than `maxByteLength`",
                 )
                 .into());
         }
-        let new_byte_len = new_byte_len as usize;
+        let new_byte_len = new_byte_len;
 
         // If we used let-else above to avoid the expect, we would carry a borrow through the `to_index`
         // call, which could mutably borrow. Another alternative would be to clone the whole
@@ -404,13 +404,13 @@ impl SharedArrayBuffer {
         // 6. If relativeStart = -∞, let first be 0.
         // 7. Else if relativeStart < 0, let first be max(len + relativeStart, 0).
         // 8. Else, let first be min(relativeStart, len).
-        let first = Array::get_relative_start(context, args.get_or_undefined(0), len as u64)?;
+        let first = Array::get_relative_start(context, args.get_or_undefined(0), len)?;
 
         // 9. If end is undefined, let relativeEnd be len; else let relativeEnd be ? ToIntegerOrInfinity(end).
         // 10. If relativeEnd = -∞, let final be 0.
         // 11. Else if relativeEnd < 0, let final be max(len + relativeEnd, 0).
         // 12. Else, let final be min(relativeEnd, len).
-        let final_ = Array::get_relative_end(context, args.get_or_undefined(1), len as u64)?;
+        let final_ = Array::get_relative_end(context, args.get_or_undefined(1), len)?;
 
         // 13. Let newLen be max(final - first, 0).
         let new_len = final_.saturating_sub(first);
@@ -442,14 +442,13 @@ impl SharedArrayBuffer {
             }
 
             // 19. If ArrayBufferByteLength(new, seq-cst) < newLen, throw a TypeError exception.
-            if (new.len(Ordering::SeqCst) as u64) < new_len {
+            if (new.len(Ordering::SeqCst)) < new_len {
                 return Err(JsNativeError::typ()
                     .with_message("invalid size of constructed SharedArrayBuffer")
                     .into());
             }
 
-            let first = first as usize;
-            let new_len = new_len as usize;
+            let new_len = new_len;
 
             // 20. Let fromBuf be O.[[ArrayBufferData]].
             let from_buf = &buf.bytes_with_len(len)[first..];
@@ -480,8 +479,8 @@ impl SharedArrayBuffer {
     /// [spec]: https://tc39.es/ecma262/#sec-allocatesharedarraybuffer
     pub(crate) fn allocate(
         constructor: &JsValue,
-        byte_len: u64,
-        max_byte_len: Option<u64>,
+        byte_len: usize,
+        max_byte_len: Option<usize>,
         context: &mut Context,
     ) -> JsResult<JsObject<SharedArrayBuffer>> {
         // 1. Let slots be « [[ArrayBufferData]] ».
@@ -523,7 +522,7 @@ impl SharedArrayBuffer {
         // c. Perform SetValueInBuffer(byteLengthBlock, 0, biguint64, ℤ(byteLength), true, seq-cst).
         // d. Set obj.[[ArrayBufferByteLengthData]] to byteLengthBlock.
         // e. Set obj.[[ArrayBufferMaxByteLength]] to maxByteLength.
-        let current_len = max_byte_len.map(|_| AtomicUsize::new(byte_len as usize));
+        let current_len = max_byte_len.map(|_| AtomicUsize::new(byte_len));
 
         // 10. Else,
         //     a. Set obj.[[ArrayBufferByteLength]] to byteLength.
@@ -551,7 +550,7 @@ impl SharedArrayBuffer {
 ///
 /// [spec]: https://tc39.es/ecma262/#sec-createsharedbytedatablock
 pub(crate) fn create_shared_byte_data_block(
-    size: u64,
+    size: usize,
     context: &mut Context,
 ) -> JsResult<Box<[AtomicU8]>> {
     if size > context.host_hooks().max_buffer_size(context) {
diff --git a/core/engine/src/builtins/array_buffer/tests.rs b/core/engine/src/builtins/array_buffer/tests.rs
index 604bf6140fe..f3af32e5bd0 100644
--- a/core/engine/src/builtins/array_buffer/tests.rs
+++ b/core/engine/src/builtins/array_buffer/tests.rs
@@ -7,7 +7,7 @@ fn create_byte_data_block() {
     assert!(super::create_byte_data_block(100, None, context).is_ok());
 
     // Rainy day
-    assert!(super::create_byte_data_block(u64::MAX, None, context).is_err());
+    assert!(super::create_byte_data_block(usize::MAX, None, context).is_err());
 }
 
 #[test]
@@ -17,5 +17,5 @@ fn create_shared_byte_data_block() {
     assert!(super::shared::create_shared_byte_data_block(100, context).is_ok());
 
     // Rainy day
-    assert!(super::shared::create_shared_byte_data_block(u64::MAX, context).is_err());
+    assert!(super::shared::create_shared_byte_data_block(usize::MAX, context).is_err());
 }
diff --git a/core/engine/src/builtins/array_buffer/utils.rs b/core/engine/src/builtins/array_buffer/utils.rs
index d3c2e9b6c8d..391897c9678 100644
--- a/core/engine/src/builtins/array_buffer/utils.rs
+++ b/core/engine/src/builtins/array_buffer/utils.rs
@@ -151,7 +151,7 @@ impl SliceRef<'_> {
                 .array_buffer()
                 .constructor()
                 .into(),
-            self.len() as u64,
+            self.len(),
             None,
             context,
         )?;
diff --git a/core/engine/src/builtins/atomics/mod.rs b/core/engine/src/builtins/atomics/mod.rs
index 98c98cf5804..6698e9edeb3 100644
--- a/core/engine/src/builtins/atomics/mod.rs
+++ b/core/engine/src/builtins/atomics/mod.rs
@@ -644,9 +644,6 @@ fn validate_atomic_access(
     }
 
     // 8. Return (accessIndex × elementSize) + offset.
-    let offset = ((access_index * kind.element_size()) + offset) as usize;
-    Ok(AtomicAccess {
-        byte_offset: offset,
-        kind,
-    })
+    let byte_offset = (access_index * kind.element_size()) + offset;
+    Ok(AtomicAccess { byte_offset, kind })
 }
diff --git a/core/engine/src/builtins/dataview/mod.rs b/core/engine/src/builtins/dataview/mod.rs
index 1c36146715f..2e6fad5b4a5 100644
--- a/core/engine/src/builtins/dataview/mod.rs
+++ b/core/engine/src/builtins/dataview/mod.rs
@@ -38,15 +38,15 @@ use super::{
 #[derive(Debug, Clone, Trace, Finalize, JsData)]
 pub struct DataView {
     pub(crate) viewed_array_buffer: BufferObject,
-    pub(crate) byte_length: Option<u64>,
-    pub(crate) byte_offset: u64,
+    pub(crate) byte_length: Option<usize>,
+    pub(crate) byte_offset: usize,
 }
 
 impl DataView {
     /// Abstract operation [`GetViewByteLength ( viewRecord )`][spec].
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-getviewbytelength
-    fn byte_length(&self, buf_byte_len: usize) -> u64 {
+    fn byte_length(&self, buf_byte_len: usize) -> usize {
         // 1. Assert: IsViewOutOfBounds(viewRecord) is false.
         debug_assert!(!self.is_out_of_bounds(buf_byte_len));
 
@@ -62,14 +62,13 @@ impl DataView {
         // 6. Let byteLength be viewRecord.[[CachedBufferByteLength]].
         // 7. Assert: byteLength is not detached.
         // 8. Return byteLength - byteOffset.
-        buf_byte_len as u64 - self.byte_offset
+        buf_byte_len - self.byte_offset
     }
 
     /// Abstract operation [`IsViewOutOfBounds ( viewRecord )`][spec].
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-isviewoutofbounds
     fn is_out_of_bounds(&self, buf_byte_len: usize) -> bool {
-        let buf_byte_len = buf_byte_len as u64;
         // 1. Let view be viewRecord.[[Object]].
         // 2. Let bufferByteLength be viewRecord.[[CachedBufferByteLength]].
         // 3. Assert: IsDetachedBuffer(view.[[ViewedArrayBuffer]]) is true if and only if bufferByteLength is detached.
@@ -218,7 +217,7 @@ impl BuiltInConstructor for DataView {
             };
 
             // 5. Let bufferByteLength be ArrayBufferByteLength(buffer, seq-cst).
-            let buf_len = slice.len() as u64;
+            let buf_len = slice.len();
 
             // 6. If offset > bufferByteLength, throw a RangeError exception.
             if offset > buf_len {
@@ -260,11 +259,7 @@ impl BuiltInConstructor for DataView {
 
         // 11. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
         // 12. Set bufferByteLength to ArrayBufferByteLength(buffer, seq-cst).
-        let Some(buf_byte_len) = buffer
-            .as_buffer()
-            .bytes(Ordering::SeqCst)
-            .map(|s| s.len() as u64)
-        else {
+        let Some(buf_byte_len) = buffer.as_buffer().bytes(Ordering::SeqCst).map(|s| s.len()) else {
             return Err(JsNativeError::typ()
                 .with_message("ArrayBuffer can't be detached")
                 .into());
@@ -469,7 +464,7 @@ impl DataView {
         let view_size = view.byte_length(data.len());
 
         // 10. Let elementSize be the Element Size value specified in Table 71 for Element Type type.
-        let element_size = size_of::<T>() as u64;
+        let element_size = size_of::<T>();
 
         // 11. If getIndex + elementSize > viewSize, throw a RangeError exception.
         if get_index + element_size > view_size {
@@ -479,7 +474,7 @@ impl DataView {
         }
 
         // 12. Let bufferIndex be getIndex + viewOffset.
-        let buffer_index = (get_index + view_offset) as usize;
+        let buffer_index = get_index + view_offset;
 
         let src = data.subslice(buffer_index..);
 
@@ -794,14 +789,14 @@ impl DataView {
         let elem_size = size_of::<T>();
 
         // 13. If getIndex + elementSize > viewSize, throw a RangeError exception.
-        if get_index + elem_size as u64 > view_size {
+        if get_index + elem_size > view_size {
             return Err(JsNativeError::range()
                 .with_message("Offset is outside the bounds of DataView")
                 .into());
         }
 
         // 14. Let bufferIndex be getIndex + viewOffset.
-        let buffer_index = (get_index + view_offset) as usize;
+        let buffer_index = get_index + view_offset;
 
         let mut target = data.subslice_mut(buffer_index..);
 
diff --git a/core/engine/src/builtins/regexp/mod.rs b/core/engine/src/builtins/regexp/mod.rs
index 9fb6a1f7c29..ba1bd30fe85 100644
--- a/core/engine/src/builtins/regexp/mod.rs
+++ b/core/engine/src/builtins/regexp/mod.rs
@@ -847,7 +847,7 @@ impl RegExp {
         let arg_str = args.get_or_undefined(0).to_string(context)?;
 
         // 4. Return ? RegExpBuiltinExec(R, S).
-        (Self::abstract_builtin_exec(obj, &arg_str, context)?)
+        Self::abstract_builtin_exec(obj, &arg_str, context)?
             .map_or_else(|| Ok(JsValue::null()), |v| Ok(v.into()))
     }
 
@@ -915,7 +915,7 @@ impl RegExp {
             })?;
 
         // 1. Let length be the length of S.
-        let length = input.len() as u64;
+        let length = input.len();
 
         // 2. Let lastIndex be ℝ(? ToLength(? Get(R, "lastIndex"))).
         let mut last_index = this
@@ -972,14 +972,10 @@ impl RegExp {
                 let input = input.to_vec();
 
                 // NOTE: We can use the faster ucs2 variant since there will never be two byte unicode.
-                matcher.find_from_ucs2(&input, last_index as usize).next()
-            }
-            (true, JsStrVariant::Utf16(input)) => {
-                matcher.find_from_utf16(input, last_index as usize).next()
-            }
-            (false, JsStrVariant::Utf16(input)) => {
-                matcher.find_from_ucs2(input, last_index as usize).next()
+                matcher.find_from_ucs2(&input, last_index).next()
             }
+            (true, JsStrVariant::Utf16(input)) => matcher.find_from_utf16(input, last_index).next(),
+            (false, JsStrVariant::Utf16(input)) => matcher.find_from_ucs2(input, last_index).next(),
         };
 
         let Some(match_value) = r else {
@@ -1007,7 +1003,7 @@ impl RegExp {
         // SKIP: ii. Set matchSucceeded to true.
 
         // NOTE: regress currently doesn't support the sticky flag so we have to emulate it.
-        if sticky && match_value.start() != last_index as usize {
+        if sticky && match_value.start() != last_index {
             // 1. Perform ? Set(R, "lastIndex", +0𝔽, true).
             this.set(js_string!("lastIndex"), 0, true, context)?;
 
@@ -1017,7 +1013,7 @@ impl RegExp {
 
         // 13.d.ii. Set lastIndex to AdvanceStringIndex(S, lastIndex, fullUnicode).
         // NOTE: Calculation of last_index is done in regress.
-        last_index = match_value.start() as u64;
+        last_index = match_value.start();
 
         // 14. Let e be r's endIndex value.
         // 15. If fullUnicode is true, set e to GetStringIndex(S, e).
@@ -1031,10 +1027,10 @@ impl RegExp {
         }
 
         // 17. Let n be the number of elements in r's captures List.
-        let n = match_value.captures.len() as u64;
+        let n = match_value.captures.len();
         // 18. Assert: n = R.[[RegExpRecord]].[[CapturingGroupsCount]].
         // 19. Assert: n < 232 - 1.
-        debug_assert!(n < 23u64.pow(2) - 1);
+        debug_assert!(n < u32::MAX as usize);
 
         // 20. Let A be ! ArrayCreate(n + 1).
         // 21. Assert: The mathematical value of A's "length" property is n + 1.
@@ -1066,7 +1062,7 @@ impl RegExp {
             .expect("this CreateDataPropertyOrThrow call must not fail");
 
         // 28. Let matchedSubstr be GetMatchString(S, match).
-        let matched_substr = input.get_expect((last_index as usize)..(e));
+        let matched_substr = input.get_expect(last_index..e);
 
         // 29. Perform ! CreateDataPropertyOrThrow(A, "0", matchedSubstr).
         a.create_data_property_or_throw(0, matched_substr, context)
@@ -1151,7 +1147,7 @@ impl RegExp {
         // 27. For each integer i such that i ≥ 1 and i ≤ n, in ascending order, do
         for i in 1..=n {
             // a. Let captureI be ith element of r's captures List.
-            let capture = match_value.group(i as usize);
+            let capture = match_value.group(i);
 
             // b. If captureI is undefined, let capturedValue be undefined.
             // c. Else if fullUnicode is true, then
@@ -1226,7 +1222,7 @@ impl RegExp {
         // 5. If flags does not contain "g", then
         if !flags.contains(b'g') {
             // a. Return ? RegExpExec(rx, S).
-            return (Self::abstract_exec(rx, arg_str, context)?)
+            return Self::abstract_exec(rx, arg_str, context)?
                 .map_or_else(|| Ok(JsValue::null()), |v| Ok(v.into()));
         }
 
@@ -1767,7 +1763,7 @@ impl RegExp {
         }
 
         // 15. Let size be the length of S.
-        let size = arg_str.len() as u64;
+        let size = arg_str.len();
 
         // 16. If size is 0, then
         if size == 0 {
@@ -1817,7 +1813,7 @@ impl RegExp {
                     q = advance_string_index(&arg_str, q, unicode);
                 } else {
                     // 1. Let T be the substring of S from p to q.
-                    let arg_str_substring = arg_str.get_expect(p as usize..q as usize);
+                    let arg_str_substring = arg_str.get_expect(p..q);
 
                     // 2. Perform ! CreateDataPropertyOrThrow(A, ! ToString(𝔽(lengthA)), T).
                     a.create_data_property_or_throw(length_a, arg_str_substring, context)
@@ -1868,7 +1864,7 @@ impl RegExp {
         }
 
         // 20. Let T be the substring of S from p to size.
-        let arg_str_substring = arg_str.get_expect(p as usize..size as usize);
+        let arg_str_substring = arg_str.get_expect(p..size);
 
         // 21. Perform ! CreateDataPropertyOrThrow(A, ! ToString(𝔽(lengthA)), T).
         a.create_data_property_or_throw(length_a, arg_str_substring, context)
@@ -1941,7 +1937,7 @@ impl RegExp {
 ///  - [ECMAScript reference][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#sec-advancestringindex
-fn advance_string_index(s: &JsString, index: u64, unicode: bool) -> u64 {
+fn advance_string_index(s: &JsString, index: usize, unicode: bool) -> usize {
     // Regress only works with utf8, so this function differs from the spec.
 
     // 1. Assert: index ≤ 2^53 - 1.
@@ -1952,7 +1948,7 @@ fn advance_string_index(s: &JsString, index: u64, unicode: bool) -> u64 {
     }
 
     // 3. Let length be the number of code units in S.
-    let length = s.len() as u64;
+    let length = s.len();
 
     // 4. If index + 1 ≥ length, return index + 1.
     if index + 1 > length {
@@ -1960,7 +1956,7 @@ fn advance_string_index(s: &JsString, index: u64, unicode: bool) -> u64 {
     }
 
     // 5. Let cp be ! CodePointAt(S, index).
-    let code_point = s.code_point_at(index as usize);
+    let code_point = s.code_point_at(index);
 
-    index + code_point.code_unit_count() as u64
+    index + code_point.code_unit_count()
 }
diff --git a/core/engine/src/builtins/string/mod.rs b/core/engine/src/builtins/string/mod.rs
index baa4b24d771..b09ebca9dd8 100644
--- a/core/engine/src/builtins/string/mod.rs
+++ b/core/engine/src/builtins/string/mod.rs
@@ -382,7 +382,7 @@ impl String {
         let substitutions = args.get(1..).unwrap_or_default();
 
         // 1. Let numberOfSubstitutions be the number of elements in substitutions.
-        let number_of_substitutions = substitutions.len() as u64;
+        let number_of_substitutions = substitutions.len();
 
         // 2. Let cooked be ? ToObject(template).
         let cooked = args.get_or_undefined(0).to_object(context)?;
@@ -424,7 +424,7 @@ impl String {
 
             // e. If nextIndex < numberOfSubstitutions, let next be substitutions[nextIndex].
             let next = if next_index < number_of_substitutions {
-                substitutions.get_or_undefined(next_index as usize).clone()
+                substitutions.get_or_undefined(next_index).clone()
 
             // f. Else, let next be the empty String.
             } else {
@@ -1524,7 +1524,7 @@ impl String {
         let int_max_length = max_length.to_length(context)?;
 
         // 3. Let stringLength be the length of S.
-        let string_length = string.len() as u64;
+        let string_length = string.len();
 
         // 4. If intMaxLength ≤ stringLength, return S.
         if int_max_length <= string_length {
@@ -1546,7 +1546,7 @@ impl String {
 
         // 8. Let fillLen be intMaxLength - stringLength.
         let fill_len = int_max_length - string_length;
-        let filler_len = filler.len() as u64;
+        let filler_len = filler.len();
 
         // 9. Let truncatedStringFiller be the String value consisting of repeated
         // concatenations of filler truncated to length fillLen.
@@ -1560,8 +1560,8 @@ impl String {
             }
         };
 
-        let truncated_string_filler = filler.to_vec().repeat(repetitions as usize);
-        let truncated_string_filler = JsString::from(&truncated_string_filler[..fill_len as usize]);
+        let truncated_string_filler = filler.to_vec().repeat(repetitions);
+        let truncated_string_filler = JsString::from(&truncated_string_filler[..fill_len]);
 
         // 10. If placement is start, return the string-concatenation of truncatedStringFiller and S.
         if placement == Placement::Start {
diff --git a/core/engine/src/builtins/typed_array/builtin.rs b/core/engine/src/builtins/typed_array/builtin.rs
index 51512ee7bc7..cbca6b61f2d 100644
--- a/core/engine/src/builtins/typed_array/builtin.rs
+++ b/core/engine/src/builtins/typed_array/builtin.rs
@@ -303,7 +303,7 @@ impl BuiltinTypedArray {
     /// [spec]: https://tc39.es/ecma262/#sec-typedarray-create-same-type
     fn from_kind_and_length(
         kind: TypedArrayKind,
-        length: u64,
+        length: usize,
         context: &mut Context,
     ) -> JsResult<JsObject> {
         let constructor =
@@ -557,16 +557,16 @@ impl BuiltinTypedArray {
             let byte_offset = ta.byte_offset();
 
             // h. Let bufferByteLimit be (len × elementSize) + byteOffset.
-            let buffer_byte_limit = ((len * element_size) + byte_offset) as usize;
+            let buffer_byte_limit = (len * element_size) + byte_offset;
 
             // i. Let toByteIndex be (targetIndex × elementSize) + byteOffset.
-            let to_byte_index = (to * element_size + byte_offset) as usize;
+            let to_byte_index = to * element_size + byte_offset;
 
             // j. Let fromByteIndex be (startIndex × elementSize) + byteOffset.
-            let from_byte_index = (from * element_size + byte_offset) as usize;
+            let from_byte_index = from * element_size + byte_offset;
 
             // k. Let countBytes be count × elementSize.
-            let mut count_bytes = (count * element_size) as usize;
+            let mut count_bytes = count * element_size;
 
             // Readjust considering the buffer_byte_limit. A resize could
             // have readjusted the buffer size, which could put `count_bytes`
@@ -1076,13 +1076,15 @@ impl BuiltinTypedArray {
             IntegerOrInfinity::PositiveInfinity => return Ok(false.into()),
             // 8. Else if n is -∞, set n to 0.
             IntegerOrInfinity::NegativeInfinity => 0,
-            IntegerOrInfinity::Integer(i) => i,
+            IntegerOrInfinity::Integer(i) if i >= isize::MAX as i64 => isize::MAX,
+            IntegerOrInfinity::Integer(i) if i < isize::MIN as i64 => isize::MIN,
+            IntegerOrInfinity::Integer(i) => i as isize,
         };
 
         // 9. If n ≥ 0, then
         let k = if n >= 0 {
             // a. Let k be n.
-            n as u64
+            n as usize
         } else {
             // 10. Else,
             // a. Let k be len + n.
@@ -1140,13 +1142,15 @@ impl BuiltinTypedArray {
             IntegerOrInfinity::PositiveInfinity => return Ok((-1).into()),
             // 8. Else if n is -∞, set n to 0.
             IntegerOrInfinity::NegativeInfinity => 0,
-            IntegerOrInfinity::Integer(i) => i,
+            IntegerOrInfinity::Integer(i) if i >= isize::MAX as i64 => isize::MAX,
+            IntegerOrInfinity::Integer(i) if i < isize::MIN as i64 => isize::MIN,
+            IntegerOrInfinity::Integer(i) => i as isize,
         };
 
         // 9. If n ≥ 0, then
         let k = if n >= 0 {
             // a. Let k be n.
-            n as u64
+            n as usize
         // 10. Else,
         } else {
             // a. Let k be len + n.
@@ -1280,11 +1284,18 @@ impl BuiltinTypedArray {
                     IntegerOrInfinity::NegativeInfinity => return Ok((-1).into()),
                     // 7. If n ≥ 0, then
                     // a. Let k be min(n, len - 1).
-                    IntegerOrInfinity::Integer(i) if i >= 0 => min(i as u64 + 1, len),
+                    IntegerOrInfinity::Integer(i) if i >= 0 => {
+                        if i < usize::MAX as i64 {
+                            min(i as usize + 1, len)
+                        } else {
+                            len
+                        }
+                    }
                     IntegerOrInfinity::PositiveInfinity => len,
                     // 8. Else,
                     // a. Let k be len + n.
-                    IntegerOrInfinity::Integer(i) => len.saturating_add_signed(i + 1),
+                    IntegerOrInfinity::Integer(i) if i < isize::MIN as i64 => 0,
+                    IntegerOrInfinity::Integer(i) => len.saturating_add_signed(i as isize + 1),
                 }
             }
         };
@@ -1679,8 +1690,8 @@ impl BuiltinTypedArray {
                     .with_message("TypedArray.set called with negative offset")
                     .into())
             }
-            IntegerOrInfinity::PositiveInfinity => U64OrPositiveInfinity::PositiveInfinity,
-            IntegerOrInfinity::Integer(i) => U64OrPositiveInfinity::U64(i as u64),
+            IntegerOrInfinity::PositiveInfinity => UsizeOrPositiveInfinity::PositiveInfinity,
+            IntegerOrInfinity::Integer(i) => UsizeOrPositiveInfinity::Usize(i as usize),
         };
 
         // 6. If source is an Object that has a [[TypedArrayName]] internal slot, then
@@ -1710,7 +1721,7 @@ impl BuiltinTypedArray {
     /// [spec]: https://tc39.es/ecma262/#sec-settypedarrayfromtypedarray
     fn set_typed_array_from_typed_array(
         target: &JsObject<TypedArray>,
-        target_offset: &U64OrPositiveInfinity,
+        target_offset: &UsizeOrPositiveInfinity,
         source: &JsObject<TypedArray>,
         context: &mut Context,
     ) -> JsResult<()> {
@@ -1777,7 +1788,7 @@ impl BuiltinTypedArray {
         drop(src_array);
 
         // 15. If targetOffset = +∞, throw a RangeError exception.
-        let U64OrPositiveInfinity::U64(target_offset) = target_offset else {
+        let UsizeOrPositiveInfinity::Usize(target_offset) = target_offset else {
             return Err(JsNativeError::range()
                 .with_message("Target offset cannot be Infinity")
                 .into());
@@ -1805,8 +1816,8 @@ impl BuiltinTypedArray {
         // 19. If SameValue(srcBuffer, targetBuffer) is true or sameSharedArrayBuffer is true, then
         let src_byte_index = if BufferObject::equals(&src_buf_obj, &target_buf_obj) {
             // a. Let srcByteLength be source.[[ByteLength]].
-            let src_byte_offset = src_byte_offset as usize;
-            let src_byte_length = src_byte_length as usize;
+            let src_byte_offset = src_byte_offset;
+            let src_byte_length = src_byte_length;
 
             let s = {
                 let slice = src_buf_obj.as_buffer();
@@ -1848,9 +1859,9 @@ impl BuiltinTypedArray {
 
         // 24. If srcType is the same as targetType, then
         if src_type == target_type {
-            let src_byte_index = src_byte_index as usize;
-            let target_byte_index = target_byte_index as usize;
-            let byte_count = (target_element_size * src_length) as usize;
+            let src_byte_index = src_byte_index;
+            let target_byte_index = target_byte_index;
+            let byte_count = target_element_size * src_length;
 
             // a. NOTE: If srcType and targetType are the same, the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
             // b. Repeat, while targetByteIndex < limit,
@@ -1875,10 +1886,10 @@ impl BuiltinTypedArray {
         // 25. Else,
         else {
             // 23. Let limit be targetByteIndex + targetElementSize × srcLength.
-            let limit = (target_byte_index + target_element_size * src_length) as usize;
+            let limit = target_byte_index + target_element_size * src_length;
 
-            let mut src_byte_index = src_byte_index as usize;
-            let mut target_byte_index = target_byte_index as usize;
+            let mut src_byte_index = src_byte_index;
+            let mut target_byte_index = target_byte_index;
 
             // a. Repeat, while targetByteIndex < limit,
             while target_byte_index < limit {
@@ -1905,10 +1916,10 @@ impl BuiltinTypedArray {
                 }
 
                 // iii. Set srcByteIndex to srcByteIndex + srcElementSize.
-                src_byte_index += src_element_size as usize;
+                src_byte_index += src_element_size;
 
                 // iv. Set targetByteIndex to targetByteIndex + targetElementSize.
-                target_byte_index += target_element_size as usize;
+                target_byte_index += target_element_size;
             }
         }
 
@@ -1923,7 +1934,7 @@ impl BuiltinTypedArray {
     /// [spec]: https://tc39.es/ecma262/#sec-settypedarrayfromarraylike
     fn set_typed_array_from_array_like(
         target: &JsObject<TypedArray>,
-        target_offset: &U64OrPositiveInfinity,
+        target_offset: &UsizeOrPositiveInfinity,
         source: &JsValue,
         context: &mut Context,
     ) -> JsResult<()> {
@@ -1958,8 +1969,8 @@ impl BuiltinTypedArray {
 
         // 6. If targetOffset = +∞, throw a RangeError exception.
         let target_offset = match target_offset {
-            U64OrPositiveInfinity::U64(target_offset) => target_offset,
-            U64OrPositiveInfinity::PositiveInfinity => {
+            UsizeOrPositiveInfinity::Usize(target_offset) => target_offset,
+            UsizeOrPositiveInfinity::PositiveInfinity => {
                 return Err(JsNativeError::range()
                     .with_message("Target offset cannot be positive infinity")
                     .into())
@@ -2063,7 +2074,7 @@ impl BuiltinTypedArray {
         let end_index = min(end_index, src_borrow.data.array_length(src_buf.len()));
 
         // d. Set countBytes to max(endIndex - startIndex, 0).
-        let count = end_index.saturating_sub(start_index) as usize;
+        let count = end_index.saturating_sub(start_index);
 
         // f. Let targetType be TypedArrayElementType(A).
         let target_type = target_borrow.data.kind();
@@ -2071,7 +2082,7 @@ impl BuiltinTypedArray {
         // g. If srcType is targetType, then
         if src_type == target_type {
             {
-                let byte_count = count * src_type.element_size() as usize;
+                let byte_count = count * src_type.element_size();
 
                 // i. NOTE: The transfer must be performed in a manner that preserves the bit-level encoding of the source data.
                 // ii. Let srcBuffer be O.[[ViewedArrayBuffer]].
@@ -2089,10 +2100,10 @@ impl BuiltinTypedArray {
                 let src_byte_offset = src_borrow.data.byte_offset();
 
                 // vi. Let srcByteIndex be (startIndex × elementSize) + srcByteOffset.
-                let src_byte_index = (start_index * element_size + src_byte_offset) as usize;
+                let src_byte_index = start_index * element_size + src_byte_offset;
 
                 // vii. Let targetByteIndex be A.[[ByteOffset]].
-                let target_byte_index = target_borrow.data.byte_offset() as usize;
+                let target_byte_index = target_borrow.data.byte_offset();
 
                 // viii. Let endByteIndex be targetByteIndex + (countBytes × elementSize).
                 // Not needed by the impl.
@@ -2555,9 +2566,9 @@ impl BuiltinTypedArray {
                 .with_message("invalid integer index for TypedArray operation")
                 .into());
         };
-        let actual_index = u64::try_from(relative_index) // should succeed if `relative_index >= 0`
+        let actual_index = usize::try_from(relative_index) // should succeed if `relative_index >= 0`
             .ok()
-            .or_else(|| len.checked_add_signed(relative_index))
+            .or_else(|| len.checked_add_signed(relative_index as isize))
             // TODO: Replace with `is_valid_integer_index_u64` or equivalent.
             .filter(|&rel| is_valid_integer_index(&ta.clone().upcast(), rel as f64))
             .ok_or_else(|| {
@@ -2696,7 +2707,7 @@ impl BuiltinTypedArray {
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-allocatetypedarraybuffer
     fn allocate_buffer<T: TypedArrayMarker>(
-        length: u64,
+        length: usize,
         context: &mut Context,
     ) -> JsResult<TypedArray> {
         // 1. Assert: O.[[ViewedArrayBuffer]] is undefined.
@@ -2706,7 +2717,7 @@ impl BuiltinTypedArray {
         let element_size = T::ERASED.element_size();
 
         // 4. Let byteLength be elementSize × length.
-        let byte_length = element_size * length;
+        let byte_length = length.saturating_mul(element_size);
 
         // 5. Let data be ? AllocateArrayBuffer(%ArrayBuffer%, byteLength).
         let data = ArrayBuffer::allocate(
@@ -2742,7 +2753,7 @@ impl BuiltinTypedArray {
         context: &mut Context,
     ) -> JsResult<JsObject> {
         // 1. Let len be the number of elements in values.
-        let len = values.len() as u64;
+        let len = values.len();
         // 2. Perform ? AllocateTypedArrayBuffer(O, len).
         let buf = Self::allocate_buffer::<T>(len, context)?;
         let obj = JsObject::from_proto_and_data_with_shared_shape(context.root_shape(), proto, buf);
@@ -2774,7 +2785,7 @@ impl BuiltinTypedArray {
     /// [spec]: https://tc39.es/ecma262/#sec-allocatetypedarray
     pub(super) fn allocate<T: TypedArrayMarker>(
         new_target: &JsValue,
-        length: u64,
+        length: usize,
         context: &mut Context,
     ) -> JsResult<JsObject> {
         // 1. Let proto be ? GetPrototypeFromConstructor(newTarget, defaultProto).
@@ -2850,8 +2861,8 @@ impl BuiltinTypedArray {
         // 11. If elementType is srcType, then
 
         let new_buffer = if element_type == src_type {
-            let start = src_byte_offset as usize;
-            let count = byte_length as usize;
+            let start = src_byte_offset;
+            let count = byte_length;
             // a. Let data be ? CloneArrayBuffer(srcData, srcByteOffset, byteLength).
             src_data.subslice(start..start + count).clone(context)?
         } else {
@@ -2884,11 +2895,11 @@ impl BuiltinTypedArray {
                         .into());
                 }
 
-                let src_element_size = src_element_size as usize;
-                let target_element_size = element_size as usize;
+                let src_element_size = src_element_size;
+                let target_element_size = element_size;
 
                 // c. Let srcByteIndex be srcByteOffset.
-                let mut src_byte_index = src_byte_offset as usize;
+                let mut src_byte_index = src_byte_offset;
 
                 // d. Let targetByteIndex be 0.
                 let mut target_byte_index = 0;
@@ -3001,7 +3012,7 @@ impl BuiltinTypedArray {
             };
 
             // 7. Let bufferByteLength be ArrayBufferByteLength(buffer, seq-cst).
-            data.len() as u64
+            data.len()
         };
 
         let (byte_length, array_length) = if let Some(new_length) = new_length {
@@ -3100,8 +3111,8 @@ impl BuiltinTypedArray {
 }
 
 #[derive(Debug)]
-enum U64OrPositiveInfinity {
-    U64(u64),
+enum UsizeOrPositiveInfinity {
+    Usize(usize),
     PositiveInfinity,
 }
 
diff --git a/core/engine/src/builtins/typed_array/mod.rs b/core/engine/src/builtins/typed_array/mod.rs
index f834dbff38e..40de6540de7 100644
--- a/core/engine/src/builtins/typed_array/mod.rs
+++ b/core/engine/src/builtins/typed_array/mod.rs
@@ -433,17 +433,17 @@ impl TypedArrayKind {
     }
 
     /// Gets the size of the type of element of this `TypedArrayKind`.
-    pub(crate) const fn element_size(self) -> u64 {
+    pub(crate) const fn element_size(self) -> usize {
         match self {
             TypedArrayKind::Int8 | TypedArrayKind::Uint8 | TypedArrayKind::Uint8Clamped => {
-                size_of::<u8>() as u64
+                size_of::<u8>()
             }
-            TypedArrayKind::Int16 | TypedArrayKind::Uint16 => size_of::<u16>() as u64,
+            TypedArrayKind::Int16 | TypedArrayKind::Uint16 => size_of::<u16>(),
             TypedArrayKind::Int32 | TypedArrayKind::Uint32 | TypedArrayKind::Float32 => {
-                size_of::<u32>() as u64
+                size_of::<u32>()
             }
             TypedArrayKind::BigInt64 | TypedArrayKind::BigUint64 | TypedArrayKind::Float64 => {
-                size_of::<u64>() as u64
+                size_of::<u64>()
             }
         }
     }
diff --git a/core/engine/src/builtins/typed_array/object.rs b/core/engine/src/builtins/typed_array/object.rs
index 1e6bf2477de..958ce4d5569 100644
--- a/core/engine/src/builtins/typed_array/object.rs
+++ b/core/engine/src/builtins/typed_array/object.rs
@@ -31,9 +31,9 @@ use super::{is_valid_integer_index, TypedArrayKind};
 pub struct TypedArray {
     viewed_array_buffer: BufferObject,
     kind: TypedArrayKind,
-    byte_offset: u64,
-    byte_length: Option<u64>,
-    array_length: Option<u64>,
+    byte_offset: usize,
+    byte_length: Option<usize>,
+    array_length: Option<usize>,
 }
 
 impl JsData for TypedArray {
@@ -58,9 +58,9 @@ impl TypedArray {
     pub(crate) const fn new(
         viewed_array_buffer: BufferObject,
         kind: TypedArrayKind,
-        byte_offset: u64,
-        byte_length: Option<u64>,
-        array_length: Option<u64>,
+        byte_offset: usize,
+        byte_length: Option<usize>,
+        array_length: Option<usize>,
     ) -> Self {
         Self {
             viewed_array_buffer,
@@ -80,9 +80,6 @@ impl TypedArray {
     ///
     /// [spec]: https://tc39.es/ecma262/sec-istypedarrayoutofbounds
     pub(crate) fn is_out_of_bounds(&self, buf_byte_len: usize) -> bool {
-        // Checks when allocating the buffer ensure the length fits inside an `u64`.
-        let buf_byte_len = buf_byte_len as u64;
-
         // 1. Let O be taRecord.[[Object]].
         // 2. Let bufferByteLength be taRecord.[[CachedBufferByteLength]].
         // 3. Assert: IsDetachedBuffer(O.[[ViewedArrayBuffer]]) is true if and only if bufferByteLength is detached.
@@ -111,7 +108,7 @@ impl TypedArray {
 
     /// Get the `TypedArray` object's byte offset.
     #[must_use]
-    pub const fn byte_offset(&self) -> u64 {
+    pub const fn byte_offset(&self) -> usize {
         self.byte_offset
     }
 
@@ -132,7 +129,7 @@ impl TypedArray {
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-typedarraybytelength
     #[must_use]
-    pub fn byte_length(&self, buf_byte_len: usize) -> u64 {
+    pub fn byte_length(&self, buf_byte_len: usize) -> usize {
         // 1. If IsTypedArrayOutOfBounds(taRecord) is true, return 0.
         if self.is_out_of_bounds(buf_byte_len) {
             return 0;
@@ -166,10 +163,9 @@ impl TypedArray {
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-typedarraylength
     #[must_use]
-    pub fn array_length(&self, buf_byte_len: usize) -> u64 {
+    pub fn array_length(&self, buf_byte_len: usize) -> usize {
         // 1. Assert: IsTypedArrayOutOfBounds(taRecord) is false.
         debug_assert!(!self.is_out_of_bounds(buf_byte_len));
-        let buf_byte_len = buf_byte_len as u64;
 
         // 2. Let O be taRecord.[[Object]].
 
@@ -227,7 +223,7 @@ impl TypedArray {
     ///
     /// Note: if this is only used for bounds checking, it is recommended to use
     /// the `Ordering::Relaxed` ordering to get the buffer slice.
-    pub(crate) fn validate_index(&self, index: f64, buf_len: usize) -> Option<u64> {
+    pub(crate) fn validate_index(&self, index: f64, buf_len: usize) -> Option<usize> {
         // 2. If IsIntegralNumber(index) is false, return false.
         if index.is_nan() || index.is_infinite() || index.fract() != 0.0 {
             return None;
@@ -252,7 +248,7 @@ impl TypedArray {
         }
 
         // 9. Return true.
-        Some(index as u64)
+        Some(index as usize)
     }
 }
 
@@ -627,7 +623,7 @@ fn typed_array_get_element(obj: &JsObject, index: f64) -> Option<JsValue> {
     let size = inner.kind.element_size();
 
     // 4. Let byteIndexInBuffer be (ℝ(index) × elementSize) + offset.
-    let byte_index = ((index * size) + offset) as usize;
+    let byte_index = (index * size) + offset;
 
     // 5. Let elementType be TypedArrayElementType(O).
     let elem_type = inner.kind();
@@ -686,7 +682,7 @@ pub(crate) fn typed_array_set_element(
     let size = elem_type.element_size();
 
     //     c. Let byteIndexInBuffer be (ℝ(index) × elementSize) + offset.
-    let byte_index = ((index * size) + offset) as usize;
+    let byte_index = (index * size) + offset;
 
     //     e. Perform SetValueInBuffer(O.[[ViewedArrayBuffer]], byteIndexInBuffer, elementType, numValue, true, unordered).
     // SAFETY: The TypedArray object guarantees that the buffer is aligned.
diff --git a/core/engine/src/context/hooks.rs b/core/engine/src/context/hooks.rs
index e30b8ea39ed..aac5b42cbda 100644
--- a/core/engine/src/context/hooks.rs
+++ b/core/engine/src/context/hooks.rs
@@ -209,7 +209,7 @@ pub trait HostHooks {
     ///
     ///
     /// [specification]: https://tc39.es/ecma262/#sec-resizable-arraybuffer-guidelines
-    fn max_buffer_size(&self, _context: &mut Context) -> u64 {
+    fn max_buffer_size(&self, _context: &mut Context) -> usize {
         1_610_612_736 // 1.5 GiB
     }
 }
diff --git a/core/engine/src/error.rs b/core/engine/src/error.rs
index c88ac2d6c20..6f4094914f9 100644
--- a/core/engine/src/error.rs
+++ b/core/engine/src/error.rs
@@ -239,7 +239,7 @@ pub enum TryNativeError {
     #[error("could not get element `{index}` of property `errors`")]
     InvalidErrorsIndex {
         /// The index of the error that could not be accessed.
-        index: u64,
+        index: usize,
 
         /// The source error.
         source: JsError,
diff --git a/core/engine/src/object/builtins/jsarray.rs b/core/engine/src/object/builtins/jsarray.rs
index 7b7aff8d0e7..32dcac66682 100644
--- a/core/engine/src/object/builtins/jsarray.rs
+++ b/core/engine/src/object/builtins/jsarray.rs
@@ -53,7 +53,7 @@ impl JsArray {
     ///
     /// Same as `array.length` in JavaScript.
     #[inline]
-    pub fn length(&self, context: &mut Context) -> JsResult<u64> {
+    pub fn length(&self, context: &mut Context) -> JsResult<usize> {
         self.inner.length_of_array_like(context)
     }
 
@@ -402,7 +402,7 @@ impl JsArray {
 
     /// Calls `Array.prototype.with`.
     #[inline]
-    pub fn with(&self, index: u64, value: JsValue, context: &mut Context) -> JsResult<Self> {
+    pub fn with(&self, index: usize, value: JsValue, context: &mut Context) -> JsResult<Self> {
         let array = Array::with(&self.inner.clone().into(), &[index.into(), value], context)?;
 
         Ok(Self {
diff --git a/core/engine/src/object/builtins/jsarraybuffer.rs b/core/engine/src/object/builtins/jsarraybuffer.rs
index 684e69f3307..808cd951241 100644
--- a/core/engine/src/object/builtins/jsarraybuffer.rs
+++ b/core/engine/src/object/builtins/jsarraybuffer.rs
@@ -60,7 +60,7 @@ impl JsArrayBuffer {
                 .array_buffer()
                 .constructor()
                 .into(),
-            byte_length as u64,
+            byte_length,
             None,
             context,
         )?;
diff --git a/core/engine/src/object/builtins/jsdataview.rs b/core/engine/src/object/builtins/jsdataview.rs
index b5157155b36..26d812ee189 100644
--- a/core/engine/src/object/builtins/jsdataview.rs
+++ b/core/engine/src/object/builtins/jsdataview.rs
@@ -52,8 +52,8 @@ impl JsDataView {
     /// Create a new `JsDataView` object from an existing `JsArrayBuffer`.
     pub fn from_js_array_buffer(
         buffer: JsArrayBuffer,
-        offset: Option<u64>,
-        byte_len: Option<u64>,
+        offset: Option<usize>,
+        byte_len: Option<usize>,
         context: &mut Context,
     ) -> JsResult<Self> {
         let offset = offset.unwrap_or_default();
@@ -70,7 +70,7 @@ impl JsDataView {
             };
 
             // 5. Let bufferByteLength be ArrayBufferByteLength(buffer, seq-cst).
-            let buf_len = slice.len() as u64;
+            let buf_len = slice.len();
 
             // 6. If offset > bufferByteLength, throw a RangeError exception.
             if offset > buf_len {
@@ -109,7 +109,7 @@ impl JsDataView {
 
         // 11. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
         // 12. Set bufferByteLength to ArrayBufferByteLength(buffer, seq-cst).
-        let Some(buf_byte_len) = buffer.borrow().data.bytes().map(|s| s.len() as u64) else {
+        let Some(buf_byte_len) = buffer.borrow().data.bytes().map(|s| s.len()) else {
             return Err(JsNativeError::typ()
                 .with_message("ArrayBuffer is detached")
                 .into());
@@ -168,18 +168,18 @@ impl JsDataView {
         DataView::get_buffer(&self.inner.clone().upcast().into(), &[], context)
     }
 
-    /// Returns the `byte_length` property of [`JsDataView`] as a u64 integer
+    /// Returns the `byte_length` property of [`JsDataView`] as a usize integer
     #[inline]
-    pub fn byte_length(&self, context: &mut Context) -> JsResult<u64> {
+    pub fn byte_length(&self, context: &mut Context) -> JsResult<usize> {
         DataView::get_byte_length(&self.inner.clone().upcast().into(), &[], context)
-            .map(|v| v.as_number().expect("value should be a number") as u64)
+            .map(|v| v.as_number().expect("value should be a number") as usize)
     }
 
-    /// Returns the `byte_offset` field property of [`JsDataView`] as a u64 integer
+    /// Returns the `byte_offset` field property of [`JsDataView`] as a usize integer
     #[inline]
-    pub fn byte_offset(&self, context: &mut Context) -> JsResult<u64> {
+    pub fn byte_offset(&self, context: &mut Context) -> JsResult<usize> {
         DataView::get_byte_offset(&self.inner.clone().upcast().into(), &[], context)
-            .map(|v| v.as_number().expect("byte_offset value must be a number") as u64)
+            .map(|v| v.as_number().expect("byte_offset value must be a number") as usize)
     }
 
     /// Returns a signed 64-bit integer at the specified offset from the start of the [`JsDataView`]
diff --git a/core/engine/src/object/builtins/jssharedarraybuffer.rs b/core/engine/src/object/builtins/jssharedarraybuffer.rs
index d5dc69f8b5a..6b447c36aae 100644
--- a/core/engine/src/object/builtins/jssharedarraybuffer.rs
+++ b/core/engine/src/object/builtins/jssharedarraybuffer.rs
@@ -38,7 +38,7 @@ impl JsSharedArrayBuffer {
                 .shared_array_buffer()
                 .constructor()
                 .into(),
-            byte_length as u64,
+            byte_length,
             None,
             context,
         )?;
diff --git a/core/engine/src/object/operations.rs b/core/engine/src/object/operations.rs
index 9a989b5cc28..fe67b8cde31 100644
--- a/core/engine/src/object/operations.rs
+++ b/core/engine/src/object/operations.rs
@@ -603,7 +603,7 @@ impl JsObject {
     /// Returns the value of the "length" property of an array-like object.
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-lengthofarraylike
-    pub(crate) fn length_of_array_like(&self, context: &mut Context) -> JsResult<u64> {
+    pub(crate) fn length_of_array_like(&self, context: &mut Context) -> JsResult<usize> {
         // 1. Assert: Type(obj) is Object.
 
         // NOTE: This is an optimization, most of the cases that `LengthOfArrayLike` will be called
@@ -614,7 +614,7 @@ impl JsObject {
             //       since arrays are limited to [0, 2^32 - 1] range.
             return borrowed_object.properties().storage[0]
                 .to_u32(context)
-                .map(u64::from);
+                .map(|l| l as usize);
         }
 
         // 2. Return ℝ(? ToLength(? Get(obj, "length"))).
@@ -1267,7 +1267,7 @@ impl JsValue {
         let len = obj.length_of_array_like(context)?;
 
         // 4. Let list be a new empty List.
-        let mut list = Vec::with_capacity(len as usize);
+        let mut list = Vec::with_capacity(len);
 
         // 5. Let index be 0.
         // 6. Repeat, while index < len,
diff --git a/core/engine/src/value/conversions/serde_json.rs b/core/engine/src/value/conversions/serde_json.rs
index 95bbd5e884f..c61badff47f 100644
--- a/core/engine/src/value/conversions/serde_json.rs
+++ b/core/engine/src/value/conversions/serde_json.rs
@@ -134,7 +134,7 @@ impl JsValue {
 
                 if obj.is_array() {
                     let len = obj.length_of_array_like(context)?;
-                    let mut arr = Vec::with_capacity(len as usize);
+                    let mut arr = Vec::with_capacity(len);
 
                     for k in 0..len as u32 {
                         let val = value_by_prop_key(k.into(), context)?;
diff --git a/core/engine/src/value/mod.rs b/core/engine/src/value/mod.rs
index c767c1b8463..42a59ebb0f2 100644
--- a/core/engine/src/value/mod.rs
+++ b/core/engine/src/value/mod.rs
@@ -865,7 +865,7 @@ impl JsValue {
     /// Converts a value to a non-negative integer if it is a valid integer index value.
     ///
     /// See: <https://tc39.es/ecma262/#sec-toindex>
-    pub fn to_index(&self, context: &mut Context) -> JsResult<u64> {
+    pub fn to_index(&self, context: &mut Context) -> JsResult<usize> {
         // 1. If value is undefined, then
         if self.is_undefined() {
             // a. Return 0.
@@ -890,19 +890,19 @@ impl JsValue {
         debug_assert!(0 <= clamped && clamped <= Number::MAX_SAFE_INTEGER as i64);
 
         // e. Return integer.
-        Ok(clamped as u64)
+        Ok(clamped as usize)
     }
 
     /// Converts argument to an integer suitable for use as the length of an array-like object.
     ///
     /// See: <https://tc39.es/ecma262/#sec-tolength>
-    pub fn to_length(&self, context: &mut Context) -> JsResult<u64> {
+    pub fn to_length(&self, context: &mut Context) -> JsResult<usize> {
         // 1. Let len be ? ToInteger(argument).
         // 2. If len ≤ +0, return +0.
         // 3. Return min(len, 2^53 - 1).
         Ok(self
             .to_integer_or_infinity(context)?
-            .clamp_finite(0, Number::MAX_SAFE_INTEGER as i64) as u64)
+            .clamp_finite(0, Number::MAX_SAFE_INTEGER as i64) as usize)
     }
 
     /// Abstract operation `ToIntegerOrInfinity ( argument )`
diff --git a/core/engine/src/value/tests.rs b/core/engine/src/value/tests.rs
index 7f00f68708b..06375deb620 100644
--- a/core/engine/src/value/tests.rs
+++ b/core/engine/src/value/tests.rs
@@ -553,7 +553,7 @@ fn to_length() {
         assert_eq!(JsValue::new(f64::NEG_INFINITY).to_length(ctx).unwrap(), 0);
         assert_eq!(
             JsValue::new(f64::INFINITY).to_length(ctx).unwrap(),
-            Number::MAX_SAFE_INTEGER as u64
+            Number::MAX_SAFE_INTEGER as usize
         );
         assert_eq!(JsValue::new(0.0).to_length(ctx).unwrap(), 0);
         assert_eq!(JsValue::new(-0.0).to_length(ctx).unwrap(), 0);
diff --git a/core/engine/src/vm/opcode/templates/mod.rs b/core/engine/src/vm/opcode/templates/mod.rs
index 7b8f7393501..96e5b62abe3 100644
--- a/core/engine/src/vm/opcode/templates/mod.rs
+++ b/core/engine/src/vm/opcode/templates/mod.rs
@@ -43,9 +43,9 @@ impl TemplateCreate {
     #[allow(clippy::unnecessary_wraps)]
     fn operation(context: &mut Context, count: u32, site: u64) -> JsResult<CompletionType> {
         let template =
-            Array::array_create(count.into(), None, context).expect("cannot fail per spec");
+            Array::array_create(count as usize, None, context).expect("cannot fail per spec");
         let raw_obj =
-            Array::array_create(count.into(), None, context).expect("cannot fail per spec");
+            Array::array_create(count as usize, None, context).expect("cannot fail per spec");
 
         for index in (0..count).rev() {
             let raw_value = context.vm.pop();
diff --git a/examples/src/bin/jsarraybuffer.rs b/examples/src/bin/jsarraybuffer.rs
index 5b321a50069..84888e79c5b 100644
--- a/examples/src/bin/jsarraybuffer.rs
+++ b/examples/src/bin/jsarraybuffer.rs
@@ -41,7 +41,7 @@ fn main() -> JsResult<()> {
 
     // We can create a Dataview from a JsArrayBuffer
     let dataview =
-        JsDataView::from_js_array_buffer(array_buffer.clone(), None, Some(100_u64), context)?;
+        JsDataView::from_js_array_buffer(array_buffer.clone(), None, Some(100), context)?;
 
     let dataview_length = dataview.byte_length(context)?;
 

From 3201f3794fff763f8e5c903e1363e5be88e7d2a9 Mon Sep 17 00:00:00 2001
From: Hans Larsen <hans@larsen.online>
Date: Wed, 11 Dec 2024 15:02:55 -0800
Subject: [PATCH 2/5] Perform clippy and remove a lot of little things

---
 core/engine/src/builtins/array_buffer/mod.rs     | 6 ------
 core/engine/src/builtins/array_buffer/shared.rs  | 7 -------
 core/engine/src/builtins/typed_array/builtin.rs  | 6 ------
 core/engine/src/object/builtins/jsdataview.rs    | 2 +-
 core/engine/src/value/conversions/try_from_js.rs | 8 --------
 5 files changed, 1 insertion(+), 28 deletions(-)

diff --git a/core/engine/src/builtins/array_buffer/mod.rs b/core/engine/src/builtins/array_buffer/mod.rs
index 0052be69156..022192f1403 100644
--- a/core/engine/src/builtins/array_buffer/mod.rs
+++ b/core/engine/src/builtins/array_buffer/mod.rs
@@ -712,8 +712,6 @@ impl ArrayBuffer {
             };
 
             // 26. Perform CopyDataBlockBytes(toBuf, 0, fromBuf, first, newLen).
-            let first = first;
-            let new_len = new_len;
             to_buf[..new_len].copy_from_slice(&from_buf[first..first + new_len]);
         }
 
@@ -933,10 +931,6 @@ pub(crate) fn create_byte_data_block(
 
     // 1. Let db be a new Data Block value consisting of size bytes. If it is impossible to
     //    create such a Data Block, throw a RangeError exception.
-    let alloc_size = alloc_size.try_into().map_err(|e| {
-        JsNativeError::range().with_message(format!("couldn't allocate the data block: {e}"))
-    })?;
-
     let mut data_block = Vec::new();
     data_block.try_reserve_exact(alloc_size).map_err(|e| {
         JsNativeError::range().with_message(format!("couldn't allocate the data block: {e}"))
diff --git a/core/engine/src/builtins/array_buffer/shared.rs b/core/engine/src/builtins/array_buffer/shared.rs
index 02aaf78d86a..573b82b8ef4 100644
--- a/core/engine/src/builtins/array_buffer/shared.rs
+++ b/core/engine/src/builtins/array_buffer/shared.rs
@@ -336,7 +336,6 @@ impl SharedArrayBuffer {
                 )
                 .into());
         }
-        let new_byte_len = new_byte_len;
 
         // If we used let-else above to avoid the expect, we would carry a borrow through the `to_index`
         // call, which could mutably borrow. Another alternative would be to clone the whole
@@ -448,8 +447,6 @@ impl SharedArrayBuffer {
                     .into());
             }
 
-            let new_len = new_len;
-
             // 20. Let fromBuf be O.[[ArrayBufferData]].
             let from_buf = &buf.bytes_with_len(len)[first..];
 
@@ -563,10 +560,6 @@ pub(crate) fn create_shared_byte_data_block(
 
     // 1. Let db be a new Shared Data Block value consisting of size bytes. If it is impossible to
     //    create such a Shared Data Block, throw a RangeError exception.
-    let size = size.try_into().map_err(|e| {
-        JsNativeError::range().with_message(format!("couldn't allocate the data block: {e}"))
-    })?;
-
     if size == 0 {
         // Must ensure we don't allocate a zero-sized buffer.
         return Ok(Box::default());
diff --git a/core/engine/src/builtins/typed_array/builtin.rs b/core/engine/src/builtins/typed_array/builtin.rs
index cbca6b61f2d..ade03771fa0 100644
--- a/core/engine/src/builtins/typed_array/builtin.rs
+++ b/core/engine/src/builtins/typed_array/builtin.rs
@@ -1816,9 +1816,6 @@ impl BuiltinTypedArray {
         // 19. If SameValue(srcBuffer, targetBuffer) is true or sameSharedArrayBuffer is true, then
         let src_byte_index = if BufferObject::equals(&src_buf_obj, &target_buf_obj) {
             // a. Let srcByteLength be source.[[ByteLength]].
-            let src_byte_offset = src_byte_offset;
-            let src_byte_length = src_byte_length;
-
             let s = {
                 let slice = src_buf_obj.as_buffer();
                 let slice = slice
@@ -1859,8 +1856,6 @@ impl BuiltinTypedArray {
 
         // 24. If srcType is the same as targetType, then
         if src_type == target_type {
-            let src_byte_index = src_byte_index;
-            let target_byte_index = target_byte_index;
             let byte_count = target_element_size * src_length;
 
             // a. NOTE: If srcType and targetType are the same, the transfer must be performed in a manner that preserves the bit-level encoding of the source data.
@@ -2895,7 +2890,6 @@ impl BuiltinTypedArray {
                         .into());
                 }
 
-                let src_element_size = src_element_size;
                 let target_element_size = element_size;
 
                 // c. Let srcByteIndex be srcByteOffset.
diff --git a/core/engine/src/object/builtins/jsdataview.rs b/core/engine/src/object/builtins/jsdataview.rs
index 26d812ee189..481b322cbc2 100644
--- a/core/engine/src/object/builtins/jsdataview.rs
+++ b/core/engine/src/object/builtins/jsdataview.rs
@@ -109,7 +109,7 @@ impl JsDataView {
 
         // 11. If IsDetachedBuffer(buffer) is true, throw a TypeError exception.
         // 12. Set bufferByteLength to ArrayBufferByteLength(buffer, seq-cst).
-        let Some(buf_byte_len) = buffer.borrow().data.bytes().map(|s| s.len()) else {
+        let Some(buf_byte_len) = buffer.borrow().data.bytes().map(<[u8]>::len) else {
             return Err(JsNativeError::typ()
                 .with_message("ArrayBuffer is detached")
                 .into());
diff --git a/core/engine/src/value/conversions/try_from_js.rs b/core/engine/src/value/conversions/try_from_js.rs
index 42068c6c9ab..1deb53a3a04 100644
--- a/core/engine/src/value/conversions/try_from_js.rs
+++ b/core/engine/src/value/conversions/try_from_js.rs
@@ -94,14 +94,6 @@ where
         let length = object
             .get(js_string!("length"), context)?
             .to_length(context)?;
-        let length = match usize::try_from(length) {
-            Ok(length) => length,
-            Err(e) => {
-                return Err(JsNativeError::typ()
-                    .with_message(format!("could not convert length to usize: {e}"))
-                    .into());
-            }
-        };
         let mut vec = Vec::with_capacity(length);
         for i in 0..length {
             let value = object.get(i, context)?;

From 3820f5f24f0f34a9bb1a3e9f204f222f0150bd4e Mon Sep 17 00:00:00 2001
From: Hans Larsen <hans@larsen.online>
Date: Thu, 12 Dec 2024 17:02:12 -0800
Subject: [PATCH 3/5] Fix some test262

---
 core/engine/src/builtins/array/tests.rs       | 92 +++++++++++++++++++
 .../src/builtins/typed_array/builtin.rs       | 11 +--
 2 files changed, 94 insertions(+), 9 deletions(-)

diff --git a/core/engine/src/builtins/array/tests.rs b/core/engine/src/builtins/array/tests.rs
index d6e8a27469a..5bccfab43d8 100644
--- a/core/engine/src/builtins/array/tests.rs
+++ b/core/engine/src/builtins/array/tests.rs
@@ -268,6 +268,13 @@ fn index_of() {
                 var one = ["a"];
                 var many = ["a", "b", "c"];
                 var duplicates = ["a", "b", "c", "a", "b"];
+                var typed_i32 = new Int32Array([42, 43]);
+
+                var obj = {
+                  valueOf: function() {
+                    return 1;
+                  }
+                };
             "#}),
         // Empty
         TestAction::assert_eq("[].indexOf('a')", -1),
@@ -299,6 +306,24 @@ fn index_of() {
         TestAction::assert_eq("many.indexOf('c', -1)", 2),
         // Negative fromIndex with duplicates
         TestAction::assert_eq("duplicates.indexOf('b', -2)", 4),
+        // Typed arrays
+        // Test cases from test262/test/built-ins/TypedArray/prototype/lastIndexOf/tointeger-fromindex.js
+        TestAction::assert_eq("typed_i32.lastIndexOf(42, '1')", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(43, '1')", 1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(42, true)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(43, true)", 1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(42, false)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(43, false)", -1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(42, NaN)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(43, NaN)", -1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(42, null)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(43, null)", -1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(42, undefined)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(43, undefined)", -1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(42, null)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(43, null)", -1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(42, obj)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(43, obj)", 1),
     ]);
 }
 
@@ -309,6 +334,12 @@ fn last_index_of() {
                 var one = ["a"];
                 var many = ["a", "b", "c"];
                 var duplicates = ["a", "b", "c", "a", "b"];
+                var typed_f32 = new Float32Array([2, 1, 2, 3]);
+                var typed_f64 = new Float64Array([2, 1, 2, 3]);
+                var typed_u32 = new Uint32Array([2, 1, 2, 3]);
+                var typed_u8 = new Uint8Array([2, 1, 2, 3]);
+                var typed_i32 = new Int32Array([2, 1, 2, 3]);
+                var typed_i8 = new Int8Array([2, 1, 2, 3]);
             "#}),
         // Empty
         TestAction::assert_eq("[].lastIndexOf('a')", -1),
@@ -340,6 +371,67 @@ fn last_index_of() {
         TestAction::assert_eq("many.lastIndexOf('c', -1)", 2),
         // Negative fromIndex with duplicates
         TestAction::assert_eq("duplicates.lastIndexOf('b', -2)", 1),
+        // Typed arrays
+        // F32
+        TestAction::assert_eq("typed_f32.lastIndexOf(2)", 2),
+        TestAction::assert_eq("typed_f32.lastIndexOf(2, 0)", 0),
+        TestAction::assert_eq("typed_f32.lastIndexOf(2, -1)", 2),
+        TestAction::assert_eq("typed_f32.lastIndexOf(2, -3)", 0),
+        TestAction::assert_eq("typed_f32.lastIndexOf(2, -4)", 0),
+        TestAction::assert_eq("typed_f32.lastIndexOf(2, -5)", -1),
+        TestAction::assert_eq("typed_f32.lastIndexOf(4)", -1),
+        TestAction::assert_eq("typed_f32.lastIndexOf(4, -4)", -1),
+        TestAction::assert_eq("typed_f32.lastIndexOf(4, -5)", -1),
+        // F64
+        TestAction::assert_eq("typed_f64.lastIndexOf(2)", 2),
+        TestAction::assert_eq("typed_f64.lastIndexOf(2, 0)", 0),
+        TestAction::assert_eq("typed_f64.lastIndexOf(2, -1)", 2),
+        TestAction::assert_eq("typed_f64.lastIndexOf(2, -3)", 0),
+        TestAction::assert_eq("typed_f64.lastIndexOf(2, -4)", 0),
+        TestAction::assert_eq("typed_f64.lastIndexOf(2, -5)", -1),
+        TestAction::assert_eq("typed_f64.lastIndexOf(4)", -1),
+        TestAction::assert_eq("typed_f64.lastIndexOf(4, -4)", -1),
+        TestAction::assert_eq("typed_f64.lastIndexOf(4, -5)", -1),
+        // U32
+        TestAction::assert_eq("typed_u32.lastIndexOf(2)", 2),
+        TestAction::assert_eq("typed_u32.lastIndexOf(2, 0)", 0),
+        TestAction::assert_eq("typed_u32.lastIndexOf(2, -1)", 2),
+        TestAction::assert_eq("typed_u32.lastIndexOf(2, -3)", 0),
+        TestAction::assert_eq("typed_u32.lastIndexOf(2, -4)", 0),
+        TestAction::assert_eq("typed_u32.lastIndexOf(2, -5)", -1),
+        TestAction::assert_eq("typed_u32.lastIndexOf(4)", -1),
+        TestAction::assert_eq("typed_u32.lastIndexOf(4, -4)", -1),
+        TestAction::assert_eq("typed_u32.lastIndexOf(4, -5)", -1),
+        // U8
+        TestAction::assert_eq("typed_u8.lastIndexOf(2)", 2),
+        TestAction::assert_eq("typed_u8.lastIndexOf(2, 0)", 0),
+        TestAction::assert_eq("typed_u8.lastIndexOf(2, -1)", 2),
+        TestAction::assert_eq("typed_u8.lastIndexOf(2, -3)", 0),
+        TestAction::assert_eq("typed_u8.lastIndexOf(2, -4)", 0),
+        TestAction::assert_eq("typed_u8.lastIndexOf(2, -5)", -1),
+        TestAction::assert_eq("typed_u8.lastIndexOf(4)", -1),
+        TestAction::assert_eq("typed_u8.lastIndexOf(4, -4)", -1),
+        TestAction::assert_eq("typed_u8.lastIndexOf(4, -5)", -1),
+        // I32
+        TestAction::assert_eq("typed_i32.lastIndexOf(2)", 2),
+        TestAction::assert_eq("typed_i32.lastIndexOf(2, 0)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(2, -1)", 2),
+        TestAction::assert_eq("typed_i32.lastIndexOf(2, -3)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(2, -4)", 0),
+        TestAction::assert_eq("typed_i32.lastIndexOf(2, -5)", -1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(4)", -1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(4, -4)", -1),
+        TestAction::assert_eq("typed_i32.lastIndexOf(4, -5)", -1),
+        // I8
+        TestAction::assert_eq("typed_i8.lastIndexOf(2)", 2),
+        TestAction::assert_eq("typed_i8.lastIndexOf(2, 0)", 0),
+        TestAction::assert_eq("typed_i8.lastIndexOf(2, -1)", 2),
+        TestAction::assert_eq("typed_i8.lastIndexOf(2, -3)", 0),
+        TestAction::assert_eq("typed_i8.lastIndexOf(2, -4)", 0),
+        TestAction::assert_eq("typed_i8.lastIndexOf(2, -5)", -1),
+        TestAction::assert_eq("typed_i8.lastIndexOf(4)", -1),
+        TestAction::assert_eq("typed_i8.lastIndexOf(4, -4)", -1),
+        TestAction::assert_eq("typed_i8.lastIndexOf(4, -5)", -1),
     ]);
 }
 
diff --git a/core/engine/src/builtins/typed_array/builtin.rs b/core/engine/src/builtins/typed_array/builtin.rs
index ade03771fa0..3de732db7e4 100644
--- a/core/engine/src/builtins/typed_array/builtin.rs
+++ b/core/engine/src/builtins/typed_array/builtin.rs
@@ -1284,18 +1284,11 @@ impl BuiltinTypedArray {
                     IntegerOrInfinity::NegativeInfinity => return Ok((-1).into()),
                     // 7. If n ≥ 0, then
                     // a. Let k be min(n, len - 1).
-                    IntegerOrInfinity::Integer(i) if i >= 0 => {
-                        if i < usize::MAX as i64 {
-                            min(i as usize + 1, len)
-                        } else {
-                            len
-                        }
-                    }
+                    IntegerOrInfinity::Integer(i) if i >= 0 => min((i + 1) as usize, len),
                     IntegerOrInfinity::PositiveInfinity => len,
                     // 8. Else,
                     // a. Let k be len + n.
-                    IntegerOrInfinity::Integer(i) if i < isize::MIN as i64 => 0,
-                    IntegerOrInfinity::Integer(i) => len.saturating_add_signed(i as isize + 1),
+                    IntegerOrInfinity::Integer(i) => len.saturating_add_signed((i + 1) as isize),
                 }
             }
         };

From 442bc606e253474d474afd388fcca2b085663301 Mon Sep 17 00:00:00 2001
From: Hans Larsen <hans@larsen.online>
Date: Mon, 16 Dec 2024 13:08:10 -0800
Subject: [PATCH 4/5] Fix tests and test262 on 32 and 64 bits platforms

---
 core/engine/src/builtins/array/mod.rs  |  4 ++++
 core/engine/src/builtins/regexp/mod.rs |  2 +-
 core/engine/src/builtins/string/mod.rs | 18 ++++++++++--------
 core/engine/src/value/integer.rs       |  8 +++++---
 core/engine/src/value/tests.rs         |  4 ++--
 5 files changed, 22 insertions(+), 14 deletions(-)

diff --git a/core/engine/src/builtins/array/mod.rs b/core/engine/src/builtins/array/mod.rs
index 4f0f109f12a..efc5d592e90 100644
--- a/core/engine/src/builtins/array/mod.rs
+++ b/core/engine/src/builtins/array/mod.rs
@@ -3199,10 +3199,12 @@ impl Array {
             // 2. If relativeStart is -∞, let k be 0.
             IntegerOrInfinity::NegativeInfinity => 0,
             // 3. Else if relativeStart < 0, let k be max(len + relativeStart, 0).
+            IntegerOrInfinity::Integer(i) if i <= (isize::MIN as i64) => 0,
             IntegerOrInfinity::Integer(i) if i < 0 => {
                 len.checked_add_signed(i as isize).unwrap_or(0)
             }
             // 4. Else, let k be min(relativeStart, len).
+            IntegerOrInfinity::Integer(i) if i as u64 > usize::MAX as u64 => len,
             IntegerOrInfinity::Integer(i) => min(i as usize, len),
 
             // Special case - positive infinity. `len` is always smaller than +inf, thus from (4)
@@ -3228,11 +3230,13 @@ impl Array {
                 // 2. If relativeEnd is -∞, let final be 0.
                 IntegerOrInfinity::NegativeInfinity => 0,
                 // 3. Else if relativeEnd < 0, let final be max(len + relativeEnd, 0).
+                IntegerOrInfinity::Integer(i) if i < 0 && i <= isize::MIN as i64 => 0,
                 IntegerOrInfinity::Integer(i) if i < 0 => {
                     len.checked_add_signed(i as isize).unwrap_or(0)
                 }
                 // 4. Else, let final be min(relativeEnd, len).
                 // Both `as` casts are safe as both variables are non-negative
+                IntegerOrInfinity::Integer(i) if i as u64 >= usize::MAX as u64 => len,
                 IntegerOrInfinity::Integer(i) => min(i as usize, len),
 
                 // Special case - positive infinity. `len` is always smaller than +inf, thus from (4)
diff --git a/core/engine/src/builtins/regexp/mod.rs b/core/engine/src/builtins/regexp/mod.rs
index ba1bd30fe85..a54ed6c784a 100644
--- a/core/engine/src/builtins/regexp/mod.rs
+++ b/core/engine/src/builtins/regexp/mod.rs
@@ -1537,7 +1537,7 @@ impl RegExp {
                 .to_integer_or_infinity(context)?;
 
             // f. Set position to the result of clamping position between 0 and lengthS.
-            let position = position.clamp_finite(0, length_s as i64) as usize;
+            let position = position.clamp_finite(0, length_s);
 
             // g. Let captures be a new empty List.
             let mut captures = Vec::new();
diff --git a/core/engine/src/builtins/string/mod.rs b/core/engine/src/builtins/string/mod.rs
index b09ebca9dd8..10c73ad70af 100644
--- a/core/engine/src/builtins/string/mod.rs
+++ b/core/engine/src/builtins/string/mod.rs
@@ -710,7 +710,9 @@ impl String {
         // 3. Let n be ? ToIntegerOrInfinity(count).
         match args.get_or_undefined(0).to_integer_or_infinity(context)? {
             IntegerOrInfinity::Integer(n)
-                if n > 0 && (n as usize) * len <= Self::MAX_STRING_LENGTH =>
+                if n > 0
+                    && usize::try_from(n).is_ok()
+                    && (n as usize) * len <= Self::MAX_STRING_LENGTH =>
             {
                 if string.is_empty() {
                     return Ok(js_string!().into());
@@ -837,7 +839,7 @@ impl String {
         let search_string = search_string.to_string(context)?;
 
         // 6. Let len be the length of S.
-        let len = string.len() as i64;
+        let len = string.len();
 
         // 7. If position is undefined, let pos be 0; else let pos be ? ToIntegerOrInfinity(position).
         let pos = match args.get_or_undefined(1) {
@@ -846,7 +848,7 @@ impl String {
         };
 
         // 8. Let start be the result of clamping pos between 0 and len.
-        let start = pos.clamp_finite(0, len) as usize;
+        let start = pos.clamp_finite(0, len);
 
         // 9. Let searchLength be the length of searchStr.
         let search_length = search_string.len();
@@ -857,10 +859,10 @@ impl String {
         }
 
         // 11. Let end be start + searchLength.
-        let end = start + search_length;
+        let end = start.saturating_add(search_length);
 
         // 12. If end > len, return false.
-        if end > len as usize {
+        if end > len {
             Ok(JsValue::new(false))
         } else {
             // 13. Let substring be the substring of S from start to end.
@@ -905,16 +907,16 @@ impl String {
         };
 
         // 6. Let len be the length of S.
-        let len = string.len() as i64;
+        let len = string.len();
 
         // 7. If endPosition is undefined, let pos be len; else let pos be ? ToIntegerOrInfinity(endPosition).
         let end = match args.get_or_undefined(1) {
-            end_position if end_position.is_undefined() => IntegerOrInfinity::Integer(len),
+            end_position if end_position.is_undefined() => IntegerOrInfinity::Integer(len as i64),
             end_position => end_position.to_integer_or_infinity(context)?,
         };
 
         // 8. Let end be the result of clamping pos between 0 and len.
-        let end = end.clamp_finite(0, len) as usize;
+        let end = end.clamp_finite(0, len);
 
         // 9. Let searchLength be the length of searchStr.
         let search_length = search_str.len();
diff --git a/core/engine/src/value/integer.rs b/core/engine/src/value/integer.rs
index 9c2d84e5bf5..6bbccfe2978 100644
--- a/core/engine/src/value/integer.rs
+++ b/core/engine/src/value/integer.rs
@@ -1,3 +1,4 @@
+use num_traits::{AsPrimitive, FromPrimitive};
 use std::cmp::Ordering;
 
 /// Represents the result of the `ToIntegerOrInfinity` operation
@@ -21,10 +22,11 @@ impl IntegerOrInfinity {
     ///
     /// Panics if `min > max`.
     #[must_use]
-    pub fn clamp_finite(self, min: i64, max: i64) -> i64 {
-        assert!(min <= max);
+    pub fn clamp_finite<T: Ord + AsPrimitive<i64> + FromPrimitive>(self, min: T, max: T) -> T {
         match self {
-            Self::Integer(i) => i.clamp(min, max),
+            Self::Integer(i) => {
+                T::from_i64(i.clamp(min.as_(), max.as_())).expect("`i` should already be clamped")
+            }
             Self::PositiveInfinity => max,
             Self::NegativeInfinity => min,
         }
diff --git a/core/engine/src/value/tests.rs b/core/engine/src/value/tests.rs
index 06375deb620..0a84f7cf00b 100644
--- a/core/engine/src/value/tests.rs
+++ b/core/engine/src/value/tests.rs
@@ -560,8 +560,8 @@ fn to_length() {
         assert_eq!(JsValue::new(20.9).to_length(ctx).unwrap(), 20);
         assert_eq!(JsValue::new(-20.9).to_length(ctx).unwrap(), 0);
         assert_eq!(
-            JsValue::new(100_000_000_000.0).to_length(ctx).unwrap(),
-            100_000_000_000
+            JsValue::new(100_000_000.0).to_length(ctx).unwrap(),
+            100_000_000
         );
         assert_eq!(
             JsValue::new(4_010_101_101.0).to_length(ctx).unwrap(),

From e3c73791890218ebe02b5d8ec0d70e383034c502 Mon Sep 17 00:00:00 2001
From: Hans Larsen <hans@larsen.online>
Date: Thu, 19 Dec 2024 10:33:36 -0800
Subject: [PATCH 5/5] bah

---
 core/engine/src/builtins/array/mod.rs         |  6 ++--
 core/engine/src/builtins/array/tests.rs       | 34 +++++++++++++++++++
 .../engine/src/builtins/typed_array/object.rs | 10 +++---
 core/engine/src/object/operations.rs          |  4 +--
 core/engine/src/value/mod.rs                  |  4 +--
 5 files changed, 46 insertions(+), 12 deletions(-)

diff --git a/core/engine/src/builtins/array/mod.rs b/core/engine/src/builtins/array/mod.rs
index efc5d592e90..4f142519676 100644
--- a/core/engine/src/builtins/array/mod.rs
+++ b/core/engine/src/builtins/array/mod.rs
@@ -781,7 +781,7 @@ impl Array {
         // 2. Let A be ? ArraySpeciesCreate(O, 0).
         let arr = Self::array_species_create(&obj, 0, context)?;
         // 3. Let n be 0.
-        let mut n: usize = 0;
+        let mut n: i64 = 0;
         // 4. Prepend O to items.
         // 5. For each element E of items, do
         for item in std::iter::once(&JsValue::new(obj)).chain(args.iter()) {
@@ -796,7 +796,7 @@ impl Array {
                 // ii. Let len be ? LengthOfArrayLike(E).
                 let len = item.length_of_array_like(context)?;
                 // iii. If n + len > 2^53 - 1, throw a TypeError exception.
-                if n.saturating_add(len) > Number::MAX_SAFE_INTEGER as usize {
+                if n.saturating_add(len) as f64 > Number::MAX_SAFE_INTEGER {
                     return Err(JsNativeError::typ()
                         .with_message(
                             "length + number of arguments exceeds the max safe integer limit",
@@ -822,7 +822,7 @@ impl Array {
             else {
                 // i. NOTE: E is added as a single item rather than spread.
                 // ii. If n ≥ 2^53 - 1, throw a TypeError exception.
-                if n >= Number::MAX_SAFE_INTEGER as usize {
+                if n >= Number::MAX_SAFE_INTEGER {
                     return Err(JsNativeError::typ()
                         .with_message("length exceeds the max safe integer limit")
                         .into());
diff --git a/core/engine/src/builtins/array/tests.rs b/core/engine/src/builtins/array/tests.rs
index 5bccfab43d8..880ab51baf0 100644
--- a/core/engine/src/builtins/array/tests.rs
+++ b/core/engine/src/builtins/array/tests.rs
@@ -1043,3 +1043,37 @@ fn array_sort() {
             "#}),
     ]);
 }
+
+#[test]
+fn arg_length_exceeding_integer_limit() {
+    run_test_actions([
+        TestAction::run(
+            r#"
+            var spreadableLengthOutOfRange = {};
+            spreadableLengthOutOfRange.length = Number.MAX_SAFE_INTEGER;
+            spreadableLengthOutOfRange[Symbol.isConcatSpreadable] = true;
+        "#,
+        ),
+        TestAction::assert_native_error(
+            "[1].concat(spreadableLengthOutOfRange);",
+            JsNativeErrorKind::Type,
+            "Invalid array length",
+        ),
+        TestAction::run(
+            r#"
+                var proxyForArrayWithLengthOutOfRange = new Proxy([], {
+                  get: function(_target, key) {
+                    if (key === "length") {
+                      return Number.MAX_SAFE_INTEGER;
+                    }
+                  },
+                });
+            "#,
+        ),
+        TestAction::assert_native_error(
+            "[].concat(1, proxyForArrayWithLengthOutOfRange);",
+            JsNativeErrorKind::Type,
+            "Invalid array length",
+        ),
+    ]);
+}
diff --git a/core/engine/src/builtins/typed_array/object.rs b/core/engine/src/builtins/typed_array/object.rs
index 958ce4d5569..1c63ebefd40 100644
--- a/core/engine/src/builtins/typed_array/object.rs
+++ b/core/engine/src/builtins/typed_array/object.rs
@@ -163,7 +163,7 @@ impl TypedArray {
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-typedarraylength
     #[must_use]
-    pub fn array_length(&self, buf_byte_len: usize) -> usize {
+    pub fn array_length(&self, buf_byte_len: usize) -> u64 {
         // 1. Assert: IsTypedArrayOutOfBounds(taRecord) is false.
         debug_assert!(!self.is_out_of_bounds(buf_byte_len));
 
@@ -171,19 +171,19 @@ impl TypedArray {
 
         // 3. If O.[[ArrayLength]] is not auto, return O.[[ArrayLength]].
         if let Some(array_length) = self.array_length {
-            return array_length;
+            return array_length as u64;
         }
         // 4. Assert: IsFixedLengthArrayBuffer(O.[[ViewedArrayBuffer]]) is false.
 
         // 5. Let byteOffset be O.[[ByteOffset]].
-        let byte_offset = self.byte_offset;
+        let byte_offset = self.byte_offset as u64;
         // 6. Let elementSize be TypedArrayElementSize(O).
-        let elem_size = self.kind.element_size();
+        let elem_size = self.kind.element_size() as u64;
 
         // 7. Let byteLength be taRecord.[[CachedBufferByteLength]].
         // 8. Assert: byteLength is not detached.
         // 9. Return floor((byteLength - byteOffset) / elementSize).
-        (buf_byte_len - byte_offset) / elem_size
+        (buf_byte_len as u64 - byte_offset) / elem_size
     }
 
     /// Abstract operation [`ValidateTypedArray ( O, order )`][spec].
diff --git a/core/engine/src/object/operations.rs b/core/engine/src/object/operations.rs
index fe67b8cde31..7cc7b9179bc 100644
--- a/core/engine/src/object/operations.rs
+++ b/core/engine/src/object/operations.rs
@@ -603,7 +603,7 @@ impl JsObject {
     /// Returns the value of the "length" property of an array-like object.
     ///
     /// [spec]: https://tc39.es/ecma262/#sec-lengthofarraylike
-    pub(crate) fn length_of_array_like(&self, context: &mut Context) -> JsResult<usize> {
+    pub(crate) fn length_of_array_like(&self, context: &mut Context) -> JsResult<u64> {
         // 1. Assert: Type(obj) is Object.
 
         // NOTE: This is an optimization, most of the cases that `LengthOfArrayLike` will be called
@@ -614,7 +614,7 @@ impl JsObject {
             //       since arrays are limited to [0, 2^32 - 1] range.
             return borrowed_object.properties().storage[0]
                 .to_u32(context)
-                .map(|l| l as usize);
+                .map(|l| l as u64);
         }
 
         // 2. Return ℝ(? ToLength(? Get(obj, "length"))).
diff --git a/core/engine/src/value/mod.rs b/core/engine/src/value/mod.rs
index 42a59ebb0f2..3d99ef9a54f 100644
--- a/core/engine/src/value/mod.rs
+++ b/core/engine/src/value/mod.rs
@@ -896,13 +896,13 @@ impl JsValue {
     /// Converts argument to an integer suitable for use as the length of an array-like object.
     ///
     /// See: <https://tc39.es/ecma262/#sec-tolength>
-    pub fn to_length(&self, context: &mut Context) -> JsResult<usize> {
+    pub fn to_length(&self, context: &mut Context) -> JsResult<u64> {
         // 1. Let len be ? ToInteger(argument).
         // 2. If len ≤ +0, return +0.
         // 3. Return min(len, 2^53 - 1).
         Ok(self
             .to_integer_or_infinity(context)?
-            .clamp_finite(0, Number::MAX_SAFE_INTEGER as i64) as usize)
+            .clamp_finite(0, Number::MAX_SAFE_INTEGER as u64))
     }
 
     /// Abstract operation `ToIntegerOrInfinity ( argument )`