mustardscript 0.1.0

package/crates/mustard/src/runtime/builtins/arrays.rs

@@ -0,0 +1,1205 @@
+use std::cmp::Ordering;
+
+use super::*;
+
+impl Runtime {
+    pub(crate) fn call_array_ctor(&mut self, args: &[Value]) -> MustardResult<Value> {
+        if args.len() == 1
+            && let Value::Number(length) = args[0]
+        {
+            if !length.is_finite()
+                || length < 0.0
+                || length.fract() != 0.0
+                || length > u32::MAX as f64
+            {
+                return Err(MustardError::runtime("RangeError: Invalid array length"));
+            }
+            let length = length as usize;
+            return Ok(Value::Array(
+                self.insert_sparse_array(vec![None; length], IndexMap::new())?,
+            ));
+        }
+        self.call_array_of(args)
+    }
+
+    fn array_slots(&self, array: ArrayKey) -> MustardResult<Vec<Option<Value>>> {
+        Ok(self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .clone())
+    }
+
+    fn array_receiver(&self, value: Value, method: &str) -> MustardResult<ArrayKey> {
+        match value {
+            Value::Array(key) => Ok(key),
+            _ => Err(MustardError::runtime(format!(
+                "TypeError: Array.prototype.{method} called on incompatible receiver",
+            ))),
+        }
+    }
+
+    pub(crate) fn set_array_length(&mut self, array: ArrayKey, value: Value) -> MustardResult<()> {
+        let requested = self.to_number(value)?;
+        if !requested.is_finite()
+            || requested < 0.0
+            || (requested.fract() != 0.0 && requested != 0.0)
+            || requested > u32::MAX as f64
+        {
+            return Err(MustardError::runtime("RangeError: Invalid array length"));
+        }
+
+        let new_length = if requested == 0.0 {
+            0
+        } else {
+            requested as usize
+        };
+
+        let array_ref = self
+            .arrays
+            .get_mut(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?;
+        array_ref.elements.resize(new_length, None);
+        array_ref.properties.shift_remove("length");
+        self.refresh_array_accounting(array)?;
+        Ok(())
+    }
+
+    pub(crate) fn call_array_of(&mut self, args: &[Value]) -> MustardResult<Value> {
+        Ok(Value::Array(
+            self.insert_array(args.to_vec(), IndexMap::new())?,
+        ))
+    }
+
+    pub(crate) fn call_array_from(&mut self, args: &[Value]) -> MustardResult<Value> {
+        let iterable = args.first().cloned().unwrap_or(Value::Undefined);
+        let map_fn = match args.get(1).cloned() {
+            Some(Value::Undefined) | None => None,
+            Some(value) if is_callable(&value) => Some(value),
+            Some(_) => {
+                return Err(MustardError::runtime(
+                    "TypeError: Array.from expects a callable map function",
+                ));
+            }
+        };
+        let this_arg = args.get(2).cloned().unwrap_or(Value::Undefined);
+        let iterator = self.create_iterator(iterable.clone())?;
+        let result = self.insert_array(Vec::new(), IndexMap::new())?;
+        let mut roots = vec![iterable, iterator.clone(), Value::Array(result)];
+        if let Some(map_fn) = &map_fn {
+            roots.push(map_fn.clone());
+            roots.push(this_arg.clone());
+        }
+        self.with_temporary_roots(&roots, |runtime| {
+            let mut index = 0usize;
+            loop {
+                runtime.charge_native_helper_work(1)?;
+                let (value, done) = runtime.iterator_next(iterator.clone())?;
+                if done {
+                    break;
+                }
+                let mapped = if let Some(map_fn) = &map_fn {
+                    runtime.with_temporary_roots(
+                        &[
+                            iterator.clone(),
+                            Value::Array(result),
+                            map_fn.clone(),
+                            this_arg.clone(),
+                            value.clone(),
+                        ],
+                        |runtime| {
+                            runtime.call_callback(
+                                map_fn.clone(),
+                                this_arg.clone(),
+                                &[value.clone(), Value::Number(index as f64)],
+                                CallbackCallOptions {
+                                    non_callable_message:
+                                        "TypeError: Array.from expects a callable map function",
+                                    host_suspension_message:
+                                        "TypeError: Array.from mapping does not support host suspensions",
+                                    unsettled_message:
+                                        "synchronous Array.from mapping did not settle",
+                                    allow_host_suspension: false,
+                                    allow_pending_promise_result: true,
+                                },
+                            )
+                        },
+                    )?
+                } else {
+                    value
+                };
+                runtime
+                    .arrays
+                    .get_mut(result)
+                    .ok_or_else(|| MustardError::runtime("array missing"))?
+                    .elements
+                    .push(Some(mapped));
+                runtime.refresh_array_accounting(result)?;
+                index += 1;
+            }
+            Ok(Value::Array(result))
+        })
+    }
+
+    pub(crate) fn call_array_push(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "push")?;
+        {
+            let elements = &mut self
+                .arrays
+                .get_mut(array)
+                .ok_or_else(|| MustardError::runtime("array missing"))?
+                .elements;
+            elements.extend(args.iter().cloned().map(Some));
+        }
+        self.refresh_array_accounting(array)?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        Ok(Value::Number(length as f64))
+    }
+
+    pub(crate) fn call_array_pop(&mut self, this_value: Value) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "pop")?;
+        let value = self
+            .arrays
+            .get_mut(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .pop()
+            .flatten()
+            .unwrap_or(Value::Undefined);
+        self.refresh_array_accounting(array)?;
+        Ok(value)
+    }
+
+    pub(crate) fn call_array_slice(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "slice")?;
+        let elements = self.array_slots(array)?;
+        let start = normalize_relative_bound(
+            self.to_integer(args.first().cloned().unwrap_or(Value::Number(0.0)))?,
+            elements.len(),
+        );
+        let end = normalize_relative_bound(
+            match args.get(1) {
+                Some(value) => self.to_integer(value.clone())?,
+                None => elements.len() as i64,
+            },
+            elements.len(),
+        );
+        let end = end.max(start);
+        Ok(Value::Array(self.insert_sparse_array(
+            elements[start..end].to_vec(),
+            IndexMap::new(),
+        )?))
+    }
+
+    pub(crate) fn call_array_splice(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "splice")?;
+        if args.is_empty() {
+            return Ok(Value::Array(
+                self.insert_array(Vec::new(), IndexMap::new())?,
+            ));
+        }
+
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        let start = normalize_relative_bound(
+            self.to_integer(args.first().cloned().unwrap_or(Value::Undefined))?,
+            length,
+        );
+        let delete_count = if args.len() == 1 {
+            length - start
+        } else {
+            clamp_index(self.to_integer(args[1].clone())?, length - start)
+        };
+        let removed = {
+            let array_ref = self
+                .arrays
+                .get_mut(array)
+                .ok_or_else(|| MustardError::runtime("array missing"))?;
+            array_ref
+                .elements
+                .splice(
+                    start..start + delete_count,
+                    args[2..].iter().cloned().map(Some),
+                )
+                .collect::<Vec<Option<Value>>>()
+        };
+        self.refresh_array_accounting(array)?;
+        Ok(Value::Array(
+            self.insert_sparse_array(removed, IndexMap::new())?,
+        ))
+    }
+
+    pub(crate) fn call_array_concat(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "concat")?;
+        let mut elements = self.array_slots(array)?;
+        for value in args {
+            match value {
+                Value::Array(other) => {
+                    let other = self
+                        .arrays
+                        .get(*other)
+                        .ok_or_else(|| MustardError::runtime("array missing"))?;
+                    elements.extend(other.elements.iter().cloned());
+                }
+                other => elements.push(Some(other.clone())),
+            }
+        }
+        Ok(Value::Array(
+            self.insert_sparse_array(elements, IndexMap::new())?,
+        ))
+    }
+
+    pub(crate) fn call_array_at(&self, this_value: Value, args: &[Value]) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "at")?;
+        let elements = &self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements;
+        let index = self.to_integer(args.first().cloned().unwrap_or(Value::Undefined))?;
+        let index = if index < 0 {
+            elements.len() as i64 + index
+        } else {
+            index
+        };
+        if index < 0 || index >= elements.len() as i64 {
+            Ok(Value::Undefined)
+        } else {
+            Ok(elements[index as usize].clone().unwrap_or(Value::Undefined))
+        }
+    }
+
+    fn normalized_flat_depth(&self, args: &[Value]) -> MustardResult<i64> {
+        match args.first() {
+            None | Some(Value::Undefined) => Ok(1),
+            Some(value) => Ok(self.to_integer(value.clone())?.max(0)),
+        }
+    }
+
+    fn collect_flattened_value(
+        &self,
+        flattened: &mut Vec<Value>,
+        value: Value,
+        depth: i64,
+    ) -> MustardResult<()> {
+        if depth > 0
+            && let Value::Array(array) = value
+        {
+            let elements = self.array_slots(array)?;
+            for element in elements.into_iter().flatten() {
+                self.collect_flattened_value(flattened, element, depth - 1)?;
+            }
+            return Ok(());
+        }
+        flattened.push(value);
+        Ok(())
+    }
+
+    pub(crate) fn call_array_flat(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "flat")?;
+        let depth = self.normalized_flat_depth(args)?;
+        let elements = self.array_slots(array)?;
+        let mut flattened = Vec::new();
+        for element in elements.into_iter().flatten() {
+            self.collect_flattened_value(&mut flattened, element, depth)?;
+        }
+        Ok(Value::Array(self.insert_array(flattened, IndexMap::new())?))
+    }
+
+    pub(crate) fn call_array_join(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "join")?;
+        let separator = match args.first() {
+            Some(value) => self.to_string(value.clone())?,
+            None => ",".to_string(),
+        };
+        let elements = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .clone();
+        let mut parts = Vec::with_capacity(elements.len());
+        for value in &elements {
+            self.charge_native_helper_work(1)?;
+            parts.push(match value {
+                None | Some(Value::Undefined) | Some(Value::Null) => String::new(),
+                Some(other) => self.to_string(other.clone())?,
+            });
+        }
+        Ok(Value::String(parts.join(&separator)))
+    }
+
+    pub(crate) fn call_array_includes(
+        &self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "includes")?;
+        let search = args.first().cloned().unwrap_or(Value::Undefined);
+        let elements = &self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements;
+        let start = normalize_search_index(
+            self.to_integer(args.get(1).cloned().unwrap_or(Value::Number(0.0)))?,
+            elements.len(),
+        );
+        Ok(Value::Bool(elements.iter().skip(start).any(|value| {
+            same_value_zero(&value.clone().unwrap_or(Value::Undefined), &search)
+        })))
+    }
+
+    pub(crate) fn call_array_index_of(
+        &self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "indexOf")?;
+        let search = args.first().cloned().unwrap_or(Value::Undefined);
+        let elements = &self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements;
+        let start = normalize_search_index(
+            self.to_integer(args.get(1).cloned().unwrap_or(Value::Number(0.0)))?,
+            elements.len(),
+        );
+        let index = elements
+            .iter()
+            .enumerate()
+            .skip(start)
+            .find(|(_, value)| {
+                value
+                    .as_ref()
+                    .is_some_and(|value| strict_equal(value, &search))
+            })
+            .map(|(index, _)| index as f64)
+            .unwrap_or(-1.0);
+        Ok(Value::Number(index))
+    }
+
+    pub(crate) fn call_array_last_index_of(
+        &self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "lastIndexOf")?;
+        let search = args.first().cloned().unwrap_or(Value::Undefined);
+        let elements = &self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements;
+        if elements.is_empty() {
+            return Ok(Value::Number(-1.0));
+        }
+        let start = match args.get(1) {
+            Some(value) => {
+                let index = self.to_integer(value.clone())?;
+                if index < 0 {
+                    let adjusted = elements.len() as i64 + index;
+                    if adjusted < 0 {
+                        return Ok(Value::Number(-1.0));
+                    }
+                    adjusted as usize
+                } else {
+                    (index as usize).min(elements.len() - 1)
+                }
+            }
+            None => elements.len() - 1,
+        };
+        let index = elements
+            .iter()
+            .enumerate()
+            .take(start + 1)
+            .rev()
+            .find(|(_, value)| {
+                value
+                    .as_ref()
+                    .is_some_and(|value| strict_equal(value, &search))
+            })
+            .map(|(index, _)| index as f64)
+            .unwrap_or(-1.0);
+        Ok(Value::Number(index))
+    }
+
+    pub(crate) fn call_array_reverse(&mut self, this_value: Value) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "reverse")?;
+        self.arrays
+            .get_mut(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .reverse();
+        self.refresh_array_accounting(array)?;
+        Ok(Value::Array(array))
+    }
+
+    pub(crate) fn call_array_fill(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "fill")?;
+        let value = args.first().cloned().unwrap_or(Value::Undefined);
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        let start = normalize_relative_bound(
+            self.to_integer(args.get(1).cloned().unwrap_or(Value::Number(0.0)))?,
+            length,
+        );
+        let end = normalize_relative_bound(
+            match args.get(2) {
+                Some(value) => self.to_integer(value.clone())?,
+                None => length as i64,
+            },
+            length,
+        );
+        {
+            let elements = &mut self
+                .arrays
+                .get_mut(array)
+                .ok_or_else(|| MustardError::runtime("array missing"))?
+                .elements;
+            for slot in elements.iter_mut().take(end).skip(start) {
+                *slot = Some(value.clone());
+            }
+        }
+        self.refresh_array_accounting(array)?;
+        Ok(Value::Array(array))
+    }
+
+    fn sort_compare(
+        &mut self,
+        comparator: Option<Value>,
+        left: Value,
+        right: Value,
+    ) -> MustardResult<Ordering> {
+        self.charge_native_helper_work(1)?;
+        match comparator {
+            Some(comparator) => {
+                let result = self.with_temporary_roots(
+                    &[comparator.clone(), left.clone(), right.clone()],
+                    |runtime| {
+                        runtime.call_callback(
+                            comparator.clone(),
+                            Value::Undefined,
+                            &[left.clone(), right.clone()],
+                            CallbackCallOptions {
+                                non_callable_message:
+                                    "TypeError: Array.prototype.sort expects a callable comparator",
+                                host_suspension_message:
+                                    "TypeError: Array.prototype.sort does not support host suspensions",
+                                unsettled_message:
+                                    "synchronous Array.prototype.sort comparator did not settle",
+                                allow_host_suspension: false,
+                                allow_pending_promise_result: false,
+                            },
+                        )
+                    },
+                )?;
+                let ordering = self.to_number(result)?;
+                Ok(if ordering.is_nan() || ordering == 0.0 {
+                    Ordering::Equal
+                } else if ordering < 0.0 {
+                    Ordering::Less
+                } else {
+                    Ordering::Greater
+                })
+            }
+            None => Ok(self.to_string(left)?.cmp(&self.to_string(right)?)),
+        }
+    }
+
+    pub(crate) fn call_array_sort(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "sort")?;
+        let comparator = match args.first().cloned() {
+            Some(Value::Undefined) | None => None,
+            Some(value) if is_callable(&value) => Some(value),
+            Some(_) => {
+                return Err(MustardError::runtime(
+                    "TypeError: Array.prototype.sort expects a callable comparator",
+                ));
+            }
+        };
+        let mut roots = vec![Value::Array(array)];
+        if let Some(comparator) = &comparator {
+            roots.push(comparator.clone());
+        }
+        self.with_temporary_roots(&roots, |runtime| {
+            let elements = runtime.array_slots(array)?;
+            let mut present = elements.into_iter().flatten().collect::<Vec<_>>();
+            for index in 1..present.len() {
+                runtime.charge_native_helper_work(1)?;
+                let current = present[index].clone();
+                let mut position = index;
+                while position > 0
+                    && runtime.sort_compare(
+                        comparator.clone(),
+                        current.clone(),
+                        present[position - 1].clone(),
+                    )? == Ordering::Less
+                {
+                    present[position] = present[position - 1].clone();
+                    position -= 1;
+                }
+                present[position] = current;
+            }
+            let holes = runtime.array_length(array)?.saturating_sub(present.len());
+            runtime
+                .arrays
+                .get_mut(array)
+                .ok_or_else(|| MustardError::runtime("array missing"))?
+                .elements = present
+                .into_iter()
+                .map(Some)
+                .chain(std::iter::repeat_with(|| None).take(holes))
+                .collect();
+            runtime.refresh_array_accounting(array)?;
+            Ok(Value::Array(array))
+        })
+    }
+
+    pub(crate) fn call_array_values(&mut self, this_value: Value) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "values")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::Array(ArrayIteratorState {
+                array,
+                next_index: 0,
+            }),
+        )?))
+    }
+
+    pub(crate) fn call_array_keys(&mut self, this_value: Value) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "keys")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::ArrayKeys(ArrayIteratorState {
+                array,
+                next_index: 0,
+            }),
+        )?))
+    }
+
+    pub(crate) fn call_array_entries(&mut self, this_value: Value) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "entries")?;
+        Ok(Value::Iterator(self.insert_iterator(
+            IteratorState::ArrayEntries(ArrayIteratorState {
+                array,
+                next_index: 0,
+            }),
+        )?))
+    }
+
+    fn array_callback(&self, args: &[Value], method: &str) -> MustardResult<(Value, Value)> {
+        let callback = args.first().cloned().unwrap_or(Value::Undefined);
+        if !is_callable(&callback) {
+            return Err(MustardError::runtime(format!(
+                "TypeError: Array.prototype.{method} expects a callable callback",
+            )));
+        }
+        let this_arg = args.get(1).cloned().unwrap_or(Value::Undefined);
+        Ok((callback, this_arg))
+    }
+
+    fn call_array_callback(
+        &mut self,
+        callback: Value,
+        this_arg: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        self.call_callback(
+            callback,
+            this_arg,
+            args,
+            CallbackCallOptions {
+                non_callable_message: "TypeError: array callback is not callable",
+                host_suspension_message:
+                    "TypeError: array callback helpers do not support synchronous host suspensions",
+                unsettled_message: "synchronous array callback did not settle",
+                allow_host_suspension: true,
+                allow_pending_promise_result: true,
+            },
+        )
+    }
+
+    fn array_callback_value(&self, array: ArrayKey, index: usize) -> MustardResult<Value> {
+        self.array_value_at(array, index)
+    }
+
+    fn append_flat_map_value(&mut self, result: ArrayKey, value: Value) -> MustardResult<()> {
+        match value {
+            Value::Array(array) => {
+                let elements = self.array_slots(array)?;
+                self.arrays
+                    .get_mut(result)
+                    .ok_or_else(|| MustardError::runtime("array missing"))?
+                    .elements
+                    .extend(elements.into_iter().flatten().map(Some));
+            }
+            other => {
+                self.arrays
+                    .get_mut(result)
+                    .ok_or_else(|| MustardError::runtime("array missing"))?
+                    .elements
+                    .push(Some(other));
+            }
+        }
+        self.refresh_array_accounting(result)?;
+        Ok(())
+    }
+
+    pub(crate) fn call_array_for_each(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "forEach")?;
+        let (callback, this_arg) = self.array_callback(args, "forEach")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        for index in 0..length {
+            self.charge_native_helper_work(1)?;
+            if !self.array_has_index(array, index)? {
+                continue;
+            }
+            let value = self.array_callback_value(array, index)?;
+            self.with_temporary_roots(
+                &[Value::Array(array), callback.clone(), this_arg.clone()],
+                |runtime| {
+                    runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[value, Value::Number(index as f64), Value::Array(array)],
+                    )?;
+                    Ok(())
+                },
+            )?;
+        }
+        Ok(Value::Undefined)
+    }
+
+    pub(crate) fn call_array_map(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "map")?;
+        let (callback, this_arg) = self.array_callback(args, "map")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        let result = self.insert_sparse_array(vec![None; length], IndexMap::new())?;
+        self.with_temporary_roots(
+            &[
+                Value::Array(array),
+                callback.clone(),
+                this_arg.clone(),
+                Value::Array(result),
+            ],
+            |runtime| {
+                for index in 0..length {
+                    runtime.charge_native_helper_work(1)?;
+                    if !runtime.array_has_index(array, index)? {
+                        continue;
+                    }
+                    let value = runtime.array_callback_value(array, index)?;
+                    let mapped = runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[value, Value::Number(index as f64), Value::Array(array)],
+                    )?;
+                    runtime
+                        .arrays
+                        .get_mut(result)
+                        .ok_or_else(|| MustardError::runtime("array missing"))?
+                        .elements[index] = Some(mapped);
+                    runtime.refresh_array_accounting(result)?;
+                }
+                Ok(Value::Array(result))
+            },
+        )
+    }
+
+    pub(crate) fn call_array_filter(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "filter")?;
+        let (callback, this_arg) = self.array_callback(args, "filter")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        let result = self.insert_array(Vec::new(), IndexMap::new())?;
+        self.with_temporary_roots(
+            &[
+                Value::Array(array),
+                callback.clone(),
+                this_arg.clone(),
+                Value::Array(result),
+            ],
+            |runtime| {
+                for index in 0..length {
+                    runtime.charge_native_helper_work(1)?;
+                    if !runtime.array_has_index(array, index)? {
+                        continue;
+                    }
+                    let value = runtime.array_callback_value(array, index)?;
+                    let keep = runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[
+                            value.clone(),
+                            Value::Number(index as f64),
+                            Value::Array(array),
+                        ],
+                    )?;
+                    if is_truthy(&keep) {
+                        runtime
+                            .arrays
+                            .get_mut(result)
+                            .ok_or_else(|| MustardError::runtime("array missing"))?
+                            .elements
+                            .push(Some(value));
+                        runtime.refresh_array_accounting(result)?;
+                    }
+                }
+                Ok(Value::Array(result))
+            },
+        )
+    }
+
+    pub(crate) fn call_array_find(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "find")?;
+        let (callback, this_arg) = self.array_callback(args, "find")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        for index in 0..length {
+            self.charge_native_helper_work(1)?;
+            let value = self.array_callback_value(array, index)?;
+            let found = self.with_temporary_roots(
+                &[Value::Array(array), callback.clone(), this_arg.clone()],
+                |runtime| {
+                    runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[
+                            value.clone(),
+                            Value::Number(index as f64),
+                            Value::Array(array),
+                        ],
+                    )
+                },
+            )?;
+            if is_truthy(&found) {
+                return Ok(value);
+            }
+        }
+        Ok(Value::Undefined)
+    }
+
+    pub(crate) fn call_array_find_index(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "findIndex")?;
+        let (callback, this_arg) = self.array_callback(args, "findIndex")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        for index in 0..length {
+            self.charge_native_helper_work(1)?;
+            let value = self.array_callback_value(array, index)?;
+            let found = self.with_temporary_roots(
+                &[Value::Array(array), callback.clone(), this_arg.clone()],
+                |runtime| {
+                    runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[value, Value::Number(index as f64), Value::Array(array)],
+                    )
+                },
+            )?;
+            if is_truthy(&found) {
+                return Ok(Value::Number(index as f64));
+            }
+        }
+        Ok(Value::Number(-1.0))
+    }
+
+    pub(crate) fn call_array_some(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "some")?;
+        let (callback, this_arg) = self.array_callback(args, "some")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        for index in 0..length {
+            self.charge_native_helper_work(1)?;
+            if !self.array_has_index(array, index)? {
+                continue;
+            }
+            let value = self.array_callback_value(array, index)?;
+            let found = self.with_temporary_roots(
+                &[Value::Array(array), callback.clone(), this_arg.clone()],
+                |runtime| {
+                    runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[value, Value::Number(index as f64), Value::Array(array)],
+                    )
+                },
+            )?;
+            if is_truthy(&found) {
+                return Ok(Value::Bool(true));
+            }
+        }
+        Ok(Value::Bool(false))
+    }
+
+    pub(crate) fn call_array_every(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "every")?;
+        let (callback, this_arg) = self.array_callback(args, "every")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        for index in 0..length {
+            self.charge_native_helper_work(1)?;
+            if !self.array_has_index(array, index)? {
+                continue;
+            }
+            let value = self.array_callback_value(array, index)?;
+            let found = self.with_temporary_roots(
+                &[Value::Array(array), callback.clone(), this_arg.clone()],
+                |runtime| {
+                    runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[value, Value::Number(index as f64), Value::Array(array)],
+                    )
+                },
+            )?;
+            if !is_truthy(&found) {
+                return Ok(Value::Bool(false));
+            }
+        }
+        Ok(Value::Bool(true))
+    }
+
+    pub(crate) fn call_array_flat_map(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "flatMap")?;
+        let (callback, this_arg) = self.array_callback(args, "flatMap")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        let result = self.insert_array(Vec::new(), IndexMap::new())?;
+        self.with_temporary_roots(
+            &[
+                Value::Array(array),
+                callback.clone(),
+                this_arg.clone(),
+                Value::Array(result),
+            ],
+            |runtime| {
+                for index in 0..length {
+                    if !runtime.array_has_index(array, index)? {
+                        continue;
+                    }
+                    let value = runtime.array_callback_value(array, index)?;
+                    let mapped = runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[value, Value::Number(index as f64), Value::Array(array)],
+                    )?;
+                    runtime.append_flat_map_value(result, mapped)?;
+                }
+                Ok(Value::Array(result))
+            },
+        )
+    }
+
+    pub(crate) fn call_array_reduce(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "reduce")?;
+        let callback = args.first().cloned().unwrap_or(Value::Undefined);
+        if !is_callable(&callback) {
+            return Err(MustardError::runtime(
+                "TypeError: Array.prototype.reduce expects a callable callback",
+            ));
+        }
+        let this_arg = Value::Undefined;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        let (mut accumulator, start_index) = match args.get(1).cloned() {
+            Some(initial) => (initial, 0),
+            None => {
+                let Some(index) = (0..length).find(|index| {
+                    self.array_has_index(array, *index)
+                        .expect("array existence should be stable during reduce")
+                }) else {
+                    return Err(MustardError::runtime(
+                        "TypeError: Array.prototype.reduce requires an initial value for empty arrays",
+                    ));
+                };
+                (self.array_callback_value(array, index)?, index + 1)
+            }
+        };
+        for index in start_index..length {
+            self.charge_native_helper_work(1)?;
+            if !self.array_has_index(array, index)? {
+                continue;
+            }
+            let value = self.array_callback_value(array, index)?;
+            accumulator = self.with_temporary_roots(
+                &[
+                    Value::Array(array),
+                    callback.clone(),
+                    this_arg.clone(),
+                    accumulator.clone(),
+                ],
+                |runtime| {
+                    runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[
+                            accumulator.clone(),
+                            value,
+                            Value::Number(index as f64),
+                            Value::Array(array),
+                        ],
+                    )
+                },
+            )?;
+        }
+        Ok(accumulator)
+    }
+
+    pub(crate) fn call_array_reduce_right(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "reduceRight")?;
+        let callback = args.first().cloned().unwrap_or(Value::Undefined);
+        if !is_callable(&callback) {
+            return Err(MustardError::runtime(
+                "TypeError: Array.prototype.reduceRight expects a callable callback",
+            ));
+        }
+        let this_arg = Value::Undefined;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        let (mut accumulator, mut index) = match args.get(1).cloned() {
+            Some(initial) => (initial, length as isize - 1),
+            None => {
+                let Some(found_index) = (0..length).rev().find(|index| {
+                    self.array_has_index(array, *index)
+                        .expect("array existence should be stable during reduceRight")
+                }) else {
+                    return Err(MustardError::runtime(
+                        "TypeError: Array.prototype.reduceRight requires an initial value for empty arrays",
+                    ));
+                };
+                (
+                    self.array_callback_value(array, found_index)?,
+                    found_index as isize - 1,
+                )
+            }
+        };
+        while index >= 0 {
+            let current_index = index as usize;
+            self.charge_native_helper_work(1)?;
+            if self.array_has_index(array, current_index)? {
+                let value = self.array_callback_value(array, current_index)?;
+                accumulator = self.with_temporary_roots(
+                    &[
+                        Value::Array(array),
+                        callback.clone(),
+                        this_arg.clone(),
+                        accumulator.clone(),
+                    ],
+                    |runtime| {
+                        runtime.call_array_callback(
+                            callback.clone(),
+                            this_arg.clone(),
+                            &[
+                                accumulator.clone(),
+                                value,
+                                Value::Number(current_index as f64),
+                                Value::Array(array),
+                            ],
+                        )
+                    },
+                )?;
+            }
+            index -= 1;
+        }
+        Ok(accumulator)
+    }
+
+    pub(crate) fn call_array_find_last(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "findLast")?;
+        let (callback, this_arg) = self.array_callback(args, "findLast")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        for index in (0..length).rev() {
+            self.charge_native_helper_work(1)?;
+            let value = self.array_callback_value(array, index)?;
+            let found = self.with_temporary_roots(
+                &[Value::Array(array), callback.clone(), this_arg.clone()],
+                |runtime| {
+                    runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[
+                            value.clone(),
+                            Value::Number(index as f64),
+                            Value::Array(array),
+                        ],
+                    )
+                },
+            )?;
+            if is_truthy(&found) {
+                return Ok(value);
+            }
+        }
+        Ok(Value::Undefined)
+    }
+
+    pub(crate) fn call_array_find_last_index(
+        &mut self,
+        this_value: Value,
+        args: &[Value],
+    ) -> MustardResult<Value> {
+        let array = self.array_receiver(this_value, "findLastIndex")?;
+        let (callback, this_arg) = self.array_callback(args, "findLastIndex")?;
+        let length = self
+            .arrays
+            .get(array)
+            .ok_or_else(|| MustardError::runtime("array missing"))?
+            .elements
+            .len();
+        for index in (0..length).rev() {
+            self.charge_native_helper_work(1)?;
+            let value = self.array_callback_value(array, index)?;
+            let found = self.with_temporary_roots(
+                &[Value::Array(array), callback.clone(), this_arg.clone()],
+                |runtime| {
+                    runtime.call_array_callback(
+                        callback.clone(),
+                        this_arg.clone(),
+                        &[value, Value::Number(index as f64), Value::Array(array)],
+                    )
+                },
+            )?;
+            if is_truthy(&found) {
+                return Ok(Value::Number(index as f64));
+            }
+        }
+        Ok(Value::Number(-1.0))
+    }
+}