mustardscript 0.1.0 → 0.1.1

package/crates/mustard/src/runtime/properties.rs

@@ -1,1762 +0,0 @@
-use super::*;
-
-impl Runtime {
-    fn function_helper_method(key: &str) -> Option<Value> {
-        match key {
-            "call" => Some(Value::BuiltinFunction(BuiltinFunction::FunctionCall)),
-            "apply" => Some(Value::BuiltinFunction(BuiltinFunction::FunctionApply)),
-            "bind" => Some(Value::BuiltinFunction(BuiltinFunction::FunctionBind)),
-            _ => None,
-        }
-    }
-
-    fn callable_constructor() -> Value {
-        Value::BuiltinFunction(BuiltinFunction::FunctionCtor)
-    }
-
-    pub(super) fn array_length(&self, array: ArrayKey) -> MustardResult<usize> {
-        Ok(self
-            .arrays
-            .get(array)
-            .ok_or_else(|| MustardError::runtime("array missing"))?
-            .elements
-            .len())
-    }
-
-    pub(super) fn array_has_index(&self, array: ArrayKey, index: usize) -> MustardResult<bool> {
-        Ok(self
-            .arrays
-            .get(array)
-            .ok_or_else(|| MustardError::runtime("array missing"))?
-            .elements
-            .get(index)
-            .is_some_and(Option::is_some))
-    }
-
-    pub(super) fn array_value_at(&self, array: ArrayKey, index: usize) -> MustardResult<Value> {
-        Ok(self
-            .arrays
-            .get(array)
-            .ok_or_else(|| MustardError::runtime("array missing"))?
-            .elements
-            .get(index)
-            .cloned()
-            .flatten()
-            .unwrap_or(Value::Undefined))
-    }
-
-    pub(super) fn closure_own_property(
-        &self,
-        closure: ClosureKey,
-        key: &str,
-    ) -> MustardResult<Option<Value>> {
-        let closure_ref = self
-            .closures
-            .get(closure)
-            .ok_or_else(|| MustardError::runtime("closure missing"))?;
-        let function = self
-            .program
-            .functions
-            .get(closure_ref.function_id)
-            .ok_or_else(|| MustardError::runtime("function not found"))?;
-        Ok(match key {
-            "name" => Some(Value::String(
-                closure_ref
-                    .name
-                    .clone()
-                    .or_else(|| function.name.clone())
-                    .unwrap_or_default(),
-            )),
-            "length" => Some(Value::Number(function.length as f64)),
-            "prototype" => closure_ref.prototype.map(Value::Object),
-            _ => closure_ref.properties.get(key).cloned(),
-        })
-    }
-
-    pub(super) fn closure_has_own_property(
-        &self,
-        closure: ClosureKey,
-        key: &str,
-    ) -> MustardResult<bool> {
-        Ok(self.closure_own_property(closure, key)?.is_some())
-    }
-
-    fn set_closure_property(
-        &mut self,
-        closure: ClosureKey,
-        key: String,
-        value: Value,
-    ) -> MustardResult<()> {
-        if matches!(key.as_str(), "name" | "length" | "prototype") {
-            return Err(MustardError::runtime(
-                "TypeError: cannot assign to read-only function metadata",
-            ));
-        }
-        self.closures
-            .get_mut(closure)
-            .ok_or_else(|| MustardError::runtime("closure missing"))?
-            .properties
-            .insert(key, value);
-        self.refresh_closure_accounting(closure)?;
-        Ok(())
-    }
-
-    pub(super) fn builtin_function_custom_property(
-        &self,
-        function: BuiltinFunction,
-        key: &str,
-    ) -> MustardResult<Option<Value>> {
-        let Some(object) = self.builtin_function_objects.get(&function).copied() else {
-            return Ok(None);
-        };
-        Ok(self
-            .objects
-            .get(object)
-            .ok_or_else(|| MustardError::runtime("object missing"))?
-            .properties
-            .get(key)
-            .cloned())
-    }
-
-    pub(super) fn host_function_custom_property(
-        &self,
-        capability: &str,
-        key: &str,
-    ) -> MustardResult<Option<Value>> {
-        let Some(object) = self.host_function_objects.get(capability).copied() else {
-            return Ok(None);
-        };
-        Ok(self
-            .objects
-            .get(object)
-            .ok_or_else(|| MustardError::runtime("object missing"))?
-            .properties
-            .get(key)
-            .cloned())
-    }
-
-    pub(super) fn builtin_function_custom_keys(
-        &self,
-        function: BuiltinFunction,
-    ) -> MustardResult<Vec<String>> {
-        let Some(object) = self.builtin_function_objects.get(&function).copied() else {
-            return Ok(Vec::new());
-        };
-        Ok(ordered_own_property_keys(
-            &self
-                .objects
-                .get(object)
-                .ok_or_else(|| MustardError::runtime("object missing"))?
-                .properties,
-        ))
-    }
-
-    pub(super) fn host_function_custom_keys(&self, capability: &str) -> MustardResult<Vec<String>> {
-        let Some(object) = self.host_function_objects.get(capability).copied() else {
-            return Ok(Vec::new());
-        };
-        Ok(ordered_own_property_keys(
-            &self
-                .objects
-                .get(object)
-                .ok_or_else(|| MustardError::runtime("object missing"))?
-                .properties,
-        ))
-    }
-
-    fn set_builtin_function_property(
-        &mut self,
-        function: BuiltinFunction,
-        key: String,
-        value: Value,
-    ) -> MustardResult<()> {
-        if matches!(key.as_str(), "name" | "length" | "prototype") {
-            return Err(MustardError::runtime(
-                "TypeError: cannot assign to read-only function metadata",
-            ));
-        }
-        let object = match self.builtin_function_objects.get(&function).copied() {
-            Some(object) => object,
-            None => {
-                let object = self.insert_object(IndexMap::new(), ObjectKind::Plain)?;
-                self.builtin_function_objects.insert(function, object);
-                object
-            }
-        };
-        self.objects
-            .get_mut(object)
-            .ok_or_else(|| MustardError::runtime("object missing"))?
-            .properties
-            .insert(key, value);
-        self.refresh_object_accounting(object)?;
-        Ok(())
-    }
-
-    fn set_host_function_property(
-        &mut self,
-        capability: String,
-        key: String,
-        value: Value,
-    ) -> MustardResult<()> {
-        if matches!(key.as_str(), "name" | "length") {
-            return Err(MustardError::runtime(
-                "TypeError: cannot assign to read-only function metadata",
-            ));
-        }
-        let object = match self.host_function_objects.get(&capability).copied() {
-            Some(object) => object,
-            None => {
-                let object = self.insert_object(IndexMap::new(), ObjectKind::Plain)?;
-                self.host_function_objects.insert(capability, object);
-                object
-            }
-        };
-        self.objects
-            .get_mut(object)
-            .ok_or_else(|| MustardError::runtime("object missing"))?
-            .properties
-            .insert(key, value);
-        self.refresh_object_accounting(object)?;
-        Ok(())
-    }
-
-    fn builtin_function_name(function: BuiltinFunction) -> &'static str {
-        match function {
-            BuiltinFunction::FunctionCtor => "Function",
-            BuiltinFunction::FunctionCall => "call",
-            BuiltinFunction::FunctionApply => "apply",
-            BuiltinFunction::FunctionBind => "bind",
-            BuiltinFunction::ArrayCtor => "Array",
-            BuiltinFunction::ArrayFrom => "from",
-            BuiltinFunction::ArrayOf => "of",
-            BuiltinFunction::ArrayIsArray => "isArray",
-            BuiltinFunction::ArrayPush => "push",
-            BuiltinFunction::ArrayPop => "pop",
-            BuiltinFunction::ArraySlice => "slice",
-            BuiltinFunction::ArraySplice => "splice",
-            BuiltinFunction::ArrayConcat => "concat",
-            BuiltinFunction::ArrayAt => "at",
-            BuiltinFunction::ArrayJoin => "join",
-            BuiltinFunction::ArrayIncludes => "includes",
-            BuiltinFunction::ArrayIndexOf => "indexOf",
-            BuiltinFunction::ArrayLastIndexOf => "lastIndexOf",
-            BuiltinFunction::ArrayReverse => "reverse",
-            BuiltinFunction::ArrayFill => "fill",
-            BuiltinFunction::ArraySort => "sort",
-            BuiltinFunction::ArrayValues => "values",
-            BuiltinFunction::ArrayKeys => "keys",
-            BuiltinFunction::ArrayEntries => "entries",
-            BuiltinFunction::ArrayForEach => "forEach",
-            BuiltinFunction::ArrayMap => "map",
-            BuiltinFunction::ArrayFilter => "filter",
-            BuiltinFunction::ArrayFind => "find",
-            BuiltinFunction::ArrayFindIndex => "findIndex",
-            BuiltinFunction::ArraySome => "some",
-            BuiltinFunction::ArrayEvery => "every",
-            BuiltinFunction::ArrayFlat => "flat",
-            BuiltinFunction::ArrayFlatMap => "flatMap",
-            BuiltinFunction::ArrayReduce => "reduce",
-            BuiltinFunction::ArrayReduceRight => "reduceRight",
-            BuiltinFunction::ArrayFindLast => "findLast",
-            BuiltinFunction::ArrayFindLastIndex => "findLastIndex",
-            BuiltinFunction::ObjectCtor => "Object",
-            BuiltinFunction::ObjectAssign => "assign",
-            BuiltinFunction::ObjectCreate => "create",
-            BuiltinFunction::ObjectFreeze => "freeze",
-            BuiltinFunction::ObjectSeal => "seal",
-            BuiltinFunction::ObjectFromEntries => "fromEntries",
-            BuiltinFunction::ObjectKeys => "keys",
-            BuiltinFunction::ObjectValues => "values",
-            BuiltinFunction::ObjectEntries => "entries",
-            BuiltinFunction::ObjectHasOwn => "hasOwn",
-            BuiltinFunction::MapCtor => "Map",
-            BuiltinFunction::MapGet => "get",
-            BuiltinFunction::MapSet => "set",
-            BuiltinFunction::MapHas => "has",
-            BuiltinFunction::MapDelete => "delete",
-            BuiltinFunction::MapClear => "clear",
-            BuiltinFunction::MapEntries => "entries",
-            BuiltinFunction::MapKeys => "keys",
-            BuiltinFunction::MapValues => "values",
-            BuiltinFunction::MapForEach => "forEach",
-            BuiltinFunction::SetCtor => "Set",
-            BuiltinFunction::SetAdd => "add",
-            BuiltinFunction::SetHas => "has",
-            BuiltinFunction::SetDelete => "delete",
-            BuiltinFunction::SetClear => "clear",
-            BuiltinFunction::SetEntries => "entries",
-            BuiltinFunction::SetKeys => "keys",
-            BuiltinFunction::SetValues => "values",
-            BuiltinFunction::SetForEach => "forEach",
-            BuiltinFunction::IteratorNext => "next",
-            BuiltinFunction::PromiseCtor => "Promise",
-            BuiltinFunction::PromiseResolve => "resolve",
-            BuiltinFunction::PromiseReject => "reject",
-            BuiltinFunction::PromiseResolveFunction(_) => "",
-            BuiltinFunction::PromiseRejectFunction(_) => "",
-            BuiltinFunction::PromiseThen => "then",
-            BuiltinFunction::PromiseCatch => "catch",
-            BuiltinFunction::PromiseFinally => "finally",
-            BuiltinFunction::PromiseAll => "all",
-            BuiltinFunction::PromiseRace => "race",
-            BuiltinFunction::PromiseAny => "any",
-            BuiltinFunction::PromiseAllSettled => "allSettled",
-            BuiltinFunction::RegExpCtor => "RegExp",
-            BuiltinFunction::RegExpExec => "exec",
-            BuiltinFunction::RegExpTest => "test",
-            BuiltinFunction::ErrorCtor => "Error",
-            BuiltinFunction::TypeErrorCtor => "TypeError",
-            BuiltinFunction::ReferenceErrorCtor => "ReferenceError",
-            BuiltinFunction::RangeErrorCtor => "RangeError",
-            BuiltinFunction::SyntaxErrorCtor => "SyntaxError",
-            BuiltinFunction::NumberCtor => "Number",
-            BuiltinFunction::NumberParseInt => "parseInt",
-            BuiltinFunction::NumberParseFloat => "parseFloat",
-            BuiltinFunction::NumberIsNaN => "isNaN",
-            BuiltinFunction::NumberIsFinite => "isFinite",
-            BuiltinFunction::NumberIsInteger => "isInteger",
-            BuiltinFunction::NumberIsSafeInteger => "isSafeInteger",
-            BuiltinFunction::DateCtor => "Date",
-            BuiltinFunction::DateNow => "now",
-            BuiltinFunction::DateGetTime => "getTime",
-            BuiltinFunction::DateValueOf => "valueOf",
-            BuiltinFunction::DateToISOString => "toISOString",
-            BuiltinFunction::DateToJSON => "toJSON",
-            BuiltinFunction::DateGetUTCFullYear => "getUTCFullYear",
-            BuiltinFunction::DateGetUTCMonth => "getUTCMonth",
-            BuiltinFunction::DateGetUTCDate => "getUTCDate",
-            BuiltinFunction::DateGetUTCHours => "getUTCHours",
-            BuiltinFunction::DateGetUTCMinutes => "getUTCMinutes",
-            BuiltinFunction::DateGetUTCSeconds => "getUTCSeconds",
-            BuiltinFunction::IntlDateTimeFormatCtor => "DateTimeFormat",
-            BuiltinFunction::IntlNumberFormatCtor => "NumberFormat",
-            BuiltinFunction::IntlDateTimeFormatFormat => "format",
-            BuiltinFunction::IntlDateTimeFormatResolvedOptions => "resolvedOptions",
-            BuiltinFunction::IntlNumberFormatFormat => "format",
-            BuiltinFunction::IntlNumberFormatResolvedOptions => "resolvedOptions",
-            BuiltinFunction::StringCtor => "String",
-            BuiltinFunction::StringTrim => "trim",
-            BuiltinFunction::StringTrimStart => "trimStart",
-            BuiltinFunction::StringTrimEnd => "trimEnd",
-            BuiltinFunction::StringIncludes => "includes",
-            BuiltinFunction::StringStartsWith => "startsWith",
-            BuiltinFunction::StringEndsWith => "endsWith",
-            BuiltinFunction::StringIndexOf => "indexOf",
-            BuiltinFunction::StringLastIndexOf => "lastIndexOf",
-            BuiltinFunction::StringCharAt => "charAt",
-            BuiltinFunction::StringAt => "at",
-            BuiltinFunction::StringSlice => "slice",
-            BuiltinFunction::StringSubstring => "substring",
-            BuiltinFunction::StringToLowerCase => "toLowerCase",
-            BuiltinFunction::StringToUpperCase => "toUpperCase",
-            BuiltinFunction::StringRepeat => "repeat",
-            BuiltinFunction::StringConcat => "concat",
-            BuiltinFunction::StringPadStart => "padStart",
-            BuiltinFunction::StringPadEnd => "padEnd",
-            BuiltinFunction::StringSplit => "split",
-            BuiltinFunction::StringReplace => "replace",
-            BuiltinFunction::StringReplaceAll => "replaceAll",
-            BuiltinFunction::StringSearch => "search",
-            BuiltinFunction::StringMatch => "match",
-            BuiltinFunction::StringMatchAll => "matchAll",
-            BuiltinFunction::StringToString => "toString",
-            BuiltinFunction::StringValueOf => "valueOf",
-            BuiltinFunction::BooleanCtor => "Boolean",
-            BuiltinFunction::BooleanToString => "toString",
-            BuiltinFunction::BooleanValueOf => "valueOf",
-            BuiltinFunction::NumberToString => "toString",
-            BuiltinFunction::NumberValueOf => "valueOf",
-            BuiltinFunction::MathAbs => "abs",
-            BuiltinFunction::MathMax => "max",
-            BuiltinFunction::MathMin => "min",
-            BuiltinFunction::MathFloor => "floor",
-            BuiltinFunction::MathCeil => "ceil",
-            BuiltinFunction::MathRound => "round",
-            BuiltinFunction::MathPow => "pow",
-            BuiltinFunction::MathSqrt => "sqrt",
-            BuiltinFunction::MathTrunc => "trunc",
-            BuiltinFunction::MathSign => "sign",
-            BuiltinFunction::MathLog => "log",
-            BuiltinFunction::MathExp => "exp",
-            BuiltinFunction::MathLog2 => "log2",
-            BuiltinFunction::MathLog10 => "log10",
-            BuiltinFunction::MathSin => "sin",
-            BuiltinFunction::MathCos => "cos",
-            BuiltinFunction::MathAtan2 => "atan2",
-            BuiltinFunction::MathHypot => "hypot",
-            BuiltinFunction::MathCbrt => "cbrt",
-            BuiltinFunction::MathRandom => "random",
-            BuiltinFunction::JsonStringify => "stringify",
-            BuiltinFunction::JsonParse => "parse",
-        }
-    }
-
-    fn builtin_function_length(function: BuiltinFunction) -> usize {
-        match function {
-            BuiltinFunction::FunctionCtor => 1,
-            BuiltinFunction::FunctionCall => 1,
-            BuiltinFunction::FunctionApply => 2,
-            BuiltinFunction::FunctionBind => 1,
-            BuiltinFunction::ArrayCtor => 1,
-            BuiltinFunction::ArrayFrom => 1,
-            BuiltinFunction::ArrayOf => 0,
-            BuiltinFunction::ArrayIsArray => 1,
-            BuiltinFunction::ArrayPush => 1,
-            BuiltinFunction::ArrayPop => 0,
-            BuiltinFunction::ArraySlice => 2,
-            BuiltinFunction::ArraySplice => 2,
-            BuiltinFunction::ArrayConcat => 1,
-            BuiltinFunction::ArrayAt => 1,
-            BuiltinFunction::ArrayJoin => 1,
-            BuiltinFunction::ArrayIncludes => 1,
-            BuiltinFunction::ArrayIndexOf => 1,
-            BuiltinFunction::ArrayLastIndexOf => 1,
-            BuiltinFunction::ArrayReverse => 0,
-            BuiltinFunction::ArrayFill => 1,
-            BuiltinFunction::ArraySort => 1,
-            BuiltinFunction::ArrayValues => 0,
-            BuiltinFunction::ArrayKeys => 0,
-            BuiltinFunction::ArrayEntries => 0,
-            BuiltinFunction::ArrayForEach => 1,
-            BuiltinFunction::ArrayMap => 1,
-            BuiltinFunction::ArrayFilter => 1,
-            BuiltinFunction::ArrayFind => 1,
-            BuiltinFunction::ArrayFindIndex => 1,
-            BuiltinFunction::ArraySome => 1,
-            BuiltinFunction::ArrayEvery => 1,
-            BuiltinFunction::ArrayFlat => 0,
-            BuiltinFunction::ArrayFlatMap => 1,
-            BuiltinFunction::ArrayReduce => 1,
-            BuiltinFunction::ArrayReduceRight => 1,
-            BuiltinFunction::ArrayFindLast => 1,
-            BuiltinFunction::ArrayFindLastIndex => 1,
-            BuiltinFunction::ObjectCtor => 1,
-            BuiltinFunction::ObjectAssign => 2,
-            BuiltinFunction::ObjectCreate => 2,
-            BuiltinFunction::ObjectFreeze => 1,
-            BuiltinFunction::ObjectSeal => 1,
-            BuiltinFunction::ObjectFromEntries => 1,
-            BuiltinFunction::ObjectKeys => 1,
-            BuiltinFunction::ObjectValues => 1,
-            BuiltinFunction::ObjectEntries => 1,
-            BuiltinFunction::ObjectHasOwn => 2,
-            BuiltinFunction::MapCtor => 0,
-            BuiltinFunction::MapGet => 1,
-            BuiltinFunction::MapSet => 2,
-            BuiltinFunction::MapHas => 1,
-            BuiltinFunction::MapDelete => 1,
-            BuiltinFunction::MapClear => 0,
-            BuiltinFunction::MapEntries => 0,
-            BuiltinFunction::MapKeys => 0,
-            BuiltinFunction::MapValues => 0,
-            BuiltinFunction::MapForEach => 1,
-            BuiltinFunction::SetCtor => 0,
-            BuiltinFunction::SetAdd => 1,
-            BuiltinFunction::SetHas => 1,
-            BuiltinFunction::SetDelete => 1,
-            BuiltinFunction::SetClear => 0,
-            BuiltinFunction::SetEntries => 0,
-            BuiltinFunction::SetKeys => 0,
-            BuiltinFunction::SetValues => 0,
-            BuiltinFunction::SetForEach => 1,
-            BuiltinFunction::IteratorNext => 0,
-            BuiltinFunction::PromiseCtor => 1,
-            BuiltinFunction::PromiseResolve => 1,
-            BuiltinFunction::PromiseReject => 1,
-            BuiltinFunction::PromiseResolveFunction(_) => 1,
-            BuiltinFunction::PromiseRejectFunction(_) => 1,
-            BuiltinFunction::PromiseThen => 2,
-            BuiltinFunction::PromiseCatch => 1,
-            BuiltinFunction::PromiseFinally => 1,
-            BuiltinFunction::PromiseAll => 1,
-            BuiltinFunction::PromiseRace => 1,
-            BuiltinFunction::PromiseAny => 1,
-            BuiltinFunction::PromiseAllSettled => 1,
-            BuiltinFunction::RegExpCtor => 2,
-            BuiltinFunction::RegExpExec => 1,
-            BuiltinFunction::RegExpTest => 1,
-            BuiltinFunction::ErrorCtor => 1,
-            BuiltinFunction::TypeErrorCtor => 1,
-            BuiltinFunction::ReferenceErrorCtor => 1,
-            BuiltinFunction::RangeErrorCtor => 1,
-            BuiltinFunction::SyntaxErrorCtor => 1,
-            BuiltinFunction::NumberCtor => 1,
-            BuiltinFunction::NumberParseInt => 2,
-            BuiltinFunction::NumberParseFloat => 1,
-            BuiltinFunction::NumberIsNaN => 1,
-            BuiltinFunction::NumberIsFinite => 1,
-            BuiltinFunction::NumberIsInteger => 1,
-            BuiltinFunction::NumberIsSafeInteger => 1,
-            BuiltinFunction::DateCtor => 7,
-            BuiltinFunction::DateNow => 0,
-            BuiltinFunction::DateGetTime => 0,
-            BuiltinFunction::DateValueOf => 0,
-            BuiltinFunction::DateToISOString => 0,
-            BuiltinFunction::DateToJSON => 0,
-            BuiltinFunction::DateGetUTCFullYear => 0,
-            BuiltinFunction::DateGetUTCMonth => 0,
-            BuiltinFunction::DateGetUTCDate => 0,
-            BuiltinFunction::DateGetUTCHours => 0,
-            BuiltinFunction::DateGetUTCMinutes => 0,
-            BuiltinFunction::DateGetUTCSeconds => 0,
-            BuiltinFunction::IntlDateTimeFormatCtor => 0,
-            BuiltinFunction::IntlNumberFormatCtor => 0,
-            BuiltinFunction::IntlDateTimeFormatFormat => 1,
-            BuiltinFunction::IntlDateTimeFormatResolvedOptions => 0,
-            BuiltinFunction::IntlNumberFormatFormat => 1,
-            BuiltinFunction::IntlNumberFormatResolvedOptions => 0,
-            BuiltinFunction::StringCtor => 1,
-            BuiltinFunction::StringTrim => 0,
-            BuiltinFunction::StringTrimStart => 0,
-            BuiltinFunction::StringTrimEnd => 0,
-            BuiltinFunction::StringIncludes => 1,
-            BuiltinFunction::StringStartsWith => 1,
-            BuiltinFunction::StringEndsWith => 1,
-            BuiltinFunction::StringIndexOf => 1,
-            BuiltinFunction::StringLastIndexOf => 1,
-            BuiltinFunction::StringCharAt => 1,
-            BuiltinFunction::StringAt => 1,
-            BuiltinFunction::StringSlice => 2,
-            BuiltinFunction::StringSubstring => 2,
-            BuiltinFunction::StringToLowerCase => 0,
-            BuiltinFunction::StringToUpperCase => 0,
-            BuiltinFunction::StringRepeat => 1,
-            BuiltinFunction::StringConcat => 1,
-            BuiltinFunction::StringPadStart => 1,
-            BuiltinFunction::StringPadEnd => 1,
-            BuiltinFunction::StringSplit => 2,
-            BuiltinFunction::StringReplace => 2,
-            BuiltinFunction::StringReplaceAll => 2,
-            BuiltinFunction::StringSearch => 1,
-            BuiltinFunction::StringMatch => 1,
-            BuiltinFunction::StringMatchAll => 1,
-            BuiltinFunction::StringToString => 0,
-            BuiltinFunction::StringValueOf => 0,
-            BuiltinFunction::BooleanCtor => 1,
-            BuiltinFunction::BooleanToString => 0,
-            BuiltinFunction::BooleanValueOf => 0,
-            BuiltinFunction::NumberToString => 0,
-            BuiltinFunction::NumberValueOf => 0,
-            BuiltinFunction::MathAbs => 1,
-            BuiltinFunction::MathMax => 2,
-            BuiltinFunction::MathMin => 2,
-            BuiltinFunction::MathFloor => 1,
-            BuiltinFunction::MathCeil => 1,
-            BuiltinFunction::MathRound => 1,
-            BuiltinFunction::MathPow => 2,
-            BuiltinFunction::MathSqrt => 1,
-            BuiltinFunction::MathTrunc => 1,
-            BuiltinFunction::MathSign => 1,
-            BuiltinFunction::MathLog => 1,
-            BuiltinFunction::MathExp => 1,
-            BuiltinFunction::MathLog2 => 1,
-            BuiltinFunction::MathLog10 => 1,
-            BuiltinFunction::MathSin => 1,
-            BuiltinFunction::MathCos => 1,
-            BuiltinFunction::MathAtan2 => 2,
-            BuiltinFunction::MathHypot => 2,
-            BuiltinFunction::MathCbrt => 1,
-            BuiltinFunction::MathRandom => 0,
-            BuiltinFunction::JsonStringify => 3,
-            BuiltinFunction::JsonParse => 2,
-        }
-    }
-
-    pub(super) fn builtin_function_own_property(
-        &self,
-        function: BuiltinFunction,
-        key: &str,
-    ) -> Option<Value> {
-        match key {
-            "name" => Some(Value::String(
-                Self::builtin_function_name(function).to_string(),
-            )),
-            "length" => Some(Value::Number(Self::builtin_function_length(function) as f64)),
-            "prototype" => self
-                .builtin_prototypes
-                .get(&function)
-                .copied()
-                .map(Value::Object),
-            _ => match function {
-                BuiltinFunction::ArrayCtor => match key {
-                    "isArray" => Some(Value::BuiltinFunction(BuiltinFunction::ArrayIsArray)),
-                    "from" => Some(Value::BuiltinFunction(BuiltinFunction::ArrayFrom)),
-                    "of" => Some(Value::BuiltinFunction(BuiltinFunction::ArrayOf)),
-                    _ => None,
-                },
-                BuiltinFunction::ObjectCtor => match key {
-                    "assign" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectAssign)),
-                    "create" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectCreate)),
-                    "freeze" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectFreeze)),
-                    "seal" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectSeal)),
-                    "fromEntries" => {
-                        Some(Value::BuiltinFunction(BuiltinFunction::ObjectFromEntries))
-                    }
-                    "keys" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectKeys)),
-                    "values" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectValues)),
-                    "entries" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectEntries)),
-                    "hasOwn" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectHasOwn)),
-                    _ => None,
-                },
-                BuiltinFunction::DateCtor if key == "now" => {
-                    Some(Value::BuiltinFunction(BuiltinFunction::DateNow))
-                }
-                BuiltinFunction::NumberCtor => match key {
-                    "parseInt" => Some(Value::BuiltinFunction(BuiltinFunction::NumberParseInt)),
-                    "parseFloat" => Some(Value::BuiltinFunction(BuiltinFunction::NumberParseFloat)),
-                    "isNaN" => Some(Value::BuiltinFunction(BuiltinFunction::NumberIsNaN)),
-                    "isFinite" => Some(Value::BuiltinFunction(BuiltinFunction::NumberIsFinite)),
-                    "isInteger" => Some(Value::BuiltinFunction(BuiltinFunction::NumberIsInteger)),
-                    "isSafeInteger" => {
-                        Some(Value::BuiltinFunction(BuiltinFunction::NumberIsSafeInteger))
-                    }
-                    "MAX_SAFE_INTEGER" => Some(Value::Number(9_007_199_254_740_991.0)),
-                    "MIN_SAFE_INTEGER" => Some(Value::Number(-9_007_199_254_740_991.0)),
-                    "EPSILON" => Some(Value::Number(f64::EPSILON)),
-                    "MAX_VALUE" => Some(Value::Number(f64::MAX)),
-                    "MIN_VALUE" => Some(Value::Number(f64::MIN_POSITIVE)),
-                    "POSITIVE_INFINITY" => Some(Value::Number(f64::INFINITY)),
-                    "NEGATIVE_INFINITY" => Some(Value::Number(f64::NEG_INFINITY)),
-                    "NaN" => Some(Value::Number(f64::NAN)),
-                    _ => None,
-                },
-                BuiltinFunction::PromiseCtor => match key {
-                    "resolve" => Some(Value::BuiltinFunction(BuiltinFunction::PromiseResolve)),
-                    "reject" => Some(Value::BuiltinFunction(BuiltinFunction::PromiseReject)),
-                    "all" => Some(Value::BuiltinFunction(BuiltinFunction::PromiseAll)),
-                    "race" => Some(Value::BuiltinFunction(BuiltinFunction::PromiseRace)),
-                    "any" => Some(Value::BuiltinFunction(BuiltinFunction::PromiseAny)),
-                    "allSettled" => {
-                        Some(Value::BuiltinFunction(BuiltinFunction::PromiseAllSettled))
-                    }
-                    _ => None,
-                },
-                BuiltinFunction::IntlDateTimeFormatCtor if key == "supportedLocalesOf" => None,
-                BuiltinFunction::IntlNumberFormatCtor if key == "supportedLocalesOf" => None,
-                _ => None,
-            },
-        }
-    }
-
-    pub(super) fn has_property_in_supported_surface(
-        &self,
-        object: Value,
-        property: Value,
-    ) -> MustardResult<bool> {
-        let key = self.to_property_key(property)?;
-        match object {
-            Value::Object(object) => {
-                let object = self
-                    .objects
-                    .get(object)
-                    .ok_or_else(|| MustardError::runtime("object missing"))?;
-                if object.properties.contains_key(&key) {
-                    return Ok(true);
-                }
-                Ok(match &object.kind {
-                    ObjectKind::FunctionPrototype(constructor) => {
-                        key == "constructor"
-                            || matches!(
-                                (constructor, key.as_str()),
-                                (
-                                    Value::BuiltinFunction(BuiltinFunction::DateCtor),
-                                    "getTime"
-                                        | "valueOf"
-                                        | "toISOString"
-                                        | "toJSON"
-                                        | "getUTCFullYear"
-                                        | "getUTCMonth"
-                                        | "getUTCDate"
-                                        | "getUTCHours"
-                                        | "getUTCMinutes"
-                                        | "getUTCSeconds"
-                                )
-                            )
-                    }
-                    ObjectKind::BoundFunction(_) => {
-                        key == "name"
-                            || key == "length"
-                            || key == "constructor"
-                            || matches!(key.as_str(), "call" | "apply" | "bind")
-                    }
-                    ObjectKind::Date(_) => matches!(
-                        key.as_str(),
-                        "getTime"
-                            | "valueOf"
-                            | "toISOString"
-                            | "toJSON"
-                            | "getUTCFullYear"
-                            | "getUTCMonth"
-                            | "getUTCDate"
-                            | "getUTCHours"
-                            | "getUTCMinutes"
-                            | "getUTCSeconds"
-                    ),
-                    ObjectKind::RegExp(_) => matches!(
-                        key.as_str(),
-                        "source"
-                            | "flags"
-                            | "global"
-                            | "ignoreCase"
-                            | "multiline"
-                            | "dotAll"
-                            | "unicode"
-                            | "sticky"
-                            | "lastIndex"
-                            | "exec"
-                            | "test"
-                    ),
-                    ObjectKind::Intl => matches!(key.as_str(), "DateTimeFormat" | "NumberFormat"),
-                    ObjectKind::IntlDateTimeFormat(_) => {
-                        matches!(key.as_str(), "constructor" | "format" | "resolvedOptions")
-                    }
-                    ObjectKind::IntlNumberFormat(_) => {
-                        matches!(key.as_str(), "constructor" | "format" | "resolvedOptions")
-                    }
-                    ObjectKind::StringObject(value) => {
-                        key == "constructor"
-                            || key == "length"
-                            || matches!(
-                                key.as_str(),
-                                "trim"
-                                    | "trimStart"
-                                    | "trimEnd"
-                                    | "includes"
-                                    | "startsWith"
-                                    | "endsWith"
-                                    | "indexOf"
-                                    | "lastIndexOf"
-                                    | "charAt"
-                                    | "at"
-                                    | "slice"
-                                    | "substring"
-                                    | "toLowerCase"
-                                    | "toUpperCase"
-                                    | "repeat"
-                                    | "concat"
-                                    | "padStart"
-                                    | "padEnd"
-                                    | "split"
-                                    | "replace"
-                                    | "replaceAll"
-                                    | "search"
-                                    | "match"
-                                    | "matchAll"
-                                    | "toString"
-                                    | "valueOf"
-                            )
-                            || array_index_from_property_key(&key)
-                                .is_some_and(|index| value.chars().nth(index).is_some())
-                    }
-                    ObjectKind::NumberObject(_) | ObjectKind::BooleanObject(_) => {
-                        matches!(key.as_str(), "constructor" | "toString" | "valueOf")
-                    }
-                    ObjectKind::Console => self.console_method(&key).is_some(),
-                    ObjectKind::Plain
-                    | ObjectKind::Global
-                    | ObjectKind::Math
-                    | ObjectKind::Json
-                    | ObjectKind::Error(_) => key == "constructor",
-                })
-            }
-            Value::Array(array) => {
-                let array = self
-                    .arrays
-                    .get(array)
-                    .ok_or_else(|| MustardError::runtime("array missing"))?;
-                Ok(key == "length"
-                    || key.parse::<usize>().ok().is_some_and(|index| {
-                        array.elements.get(index).is_some_and(Option::is_some)
-                    })
-                    || array.properties.contains_key(&key)
-                    || matches!(
-                        key.as_str(),
-                        "constructor"
-                            | "sort"
-                            | "push"
-                            | "pop"
-                            | "slice"
-                            | "splice"
-                            | "concat"
-                            | "at"
-                            | "join"
-                            | "includes"
-                            | "indexOf"
-                            | "lastIndexOf"
-                            | "reverse"
-                            | "fill"
-                            | "values"
-                            | "keys"
-                            | "entries"
-                            | "forEach"
-                            | "map"
-                            | "filter"
-                            | "find"
-                            | "findIndex"
-                            | "some"
-                            | "every"
-                            | "flat"
-                            | "flatMap"
-                            | "reduce"
-                            | "reduceRight"
-                            | "findLast"
-                            | "findLastIndex"
-                    ))
-            }
-            Value::Map(map) => {
-                self.maps
-                    .get(map)
-                    .ok_or_else(|| MustardError::runtime("map missing"))?;
-                Ok(matches!(
-                    key.as_str(),
-                    "constructor"
-                        | "size"
-                        | "get"
-                        | "set"
-                        | "has"
-                        | "delete"
-                        | "clear"
-                        | "entries"
-                        | "keys"
-                        | "values"
-                        | "forEach"
-                ))
-            }
-            Value::Set(set) => {
-                self.sets
-                    .get(set)
-                    .ok_or_else(|| MustardError::runtime("set missing"))?;
-                Ok(matches!(
-                    key.as_str(),
-                    "constructor"
-                        | "size"
-                        | "add"
-                        | "has"
-                        | "delete"
-                        | "clear"
-                        | "entries"
-                        | "keys"
-                        | "values"
-                        | "forEach"
-                ))
-            }
-            Value::Iterator(iterator) => {
-                self.iterators
-                    .get(iterator)
-                    .ok_or_else(|| MustardError::runtime("iterator missing"))?;
-                Ok(matches!(key.as_str(), "constructor" | "next"))
-            }
-            Value::Promise(promise) => {
-                self.promises
-                    .get(promise)
-                    .ok_or_else(|| MustardError::runtime("promise missing"))?;
-                Ok(matches!(
-                    key.as_str(),
-                    "constructor" | "then" | "catch" | "finally"
-                ))
-            }
-            Value::BuiltinFunction(function) => Ok(self
-                .builtin_function_custom_property(function, &key)?
-                .is_some()
-                || self.builtin_function_own_property(function, &key).is_some()
-                || key == "constructor"
-                || Self::function_helper_method(&key).is_some()),
-            Value::Closure(closure) => Ok(self.closure_has_own_property(closure, &key)?
-                || key == "constructor"
-                || Self::function_helper_method(&key).is_some()),
-            Value::HostFunction(capability) => Ok(self
-                .host_function_custom_property(&capability, &key)?
-                .is_some()
-                || matches!(key.as_str(), "name" | "length" | "constructor")
-                || Self::function_helper_method(&key).is_some()),
-            Value::Undefined
-            | Value::Null
-            | Value::Bool(_)
-            | Value::Number(_)
-            | Value::String(_)
-            | Value::BigInt(_) => Err(MustardError::runtime(
-                "TypeError: right-hand side of 'in' must be an object in the supported surface",
-            )),
-        }
-    }
-
-    pub(super) fn create_iterator(&mut self, iterable: Value) -> MustardResult<Value> {
-        let iterator = match iterable {
-            Value::Array(array) => {
-                self.insert_iterator(IteratorState::Array(ArrayIteratorState {
-                    array,
-                    next_index: 0,
-                }))?
-            }
-            Value::String(value) => {
-                self.insert_iterator(IteratorState::String(StringIteratorState {
-                    value,
-                    next_index: 0,
-                }))?
-            }
-            Value::Map(map) => {
-                self.insert_iterator(IteratorState::MapEntries(MapIteratorState {
-                    map,
-                    next_index: 0,
-                }))?
-            }
-            Value::Set(set) => {
-                self.insert_iterator(IteratorState::SetValues(SetIteratorState {
-                    set,
-                    next_index: 0,
-                }))?
-            }
-            Value::Iterator(iterator) => iterator,
-            _ => {
-                return Err(MustardError::runtime(
-                    "TypeError: value is not iterable in the supported surface",
-                ));
-            }
-        };
-        Ok(Value::Iterator(iterator))
-    }
-
-    pub(super) fn iterator_next(&mut self, iterator: Value) -> MustardResult<(Value, bool)> {
-        let key = match iterator {
-            Value::Iterator(key) => key,
-            _ => return Err(MustardError::runtime("value is not an iterator")),
-        };
-
-        let state = self
-            .iterators
-            .get(key)
-            .ok_or_else(|| MustardError::runtime("iterator missing"))?
-            .state
-            .clone();
-
-        let value = match state {
-            IteratorState::Array(state) => self
-                .arrays
-                .get(state.array)
-                .ok_or_else(|| MustardError::runtime("array missing"))?
-                .elements
-                .get(state.next_index)
-                .map(|value| value.clone().unwrap_or(Value::Undefined)),
-            IteratorState::ArrayKeys(state) => self
-                .arrays
-                .get(state.array)
-                .ok_or_else(|| MustardError::runtime("array missing"))?
-                .elements
-                .get(state.next_index)
-                .map(|_| Value::Number(state.next_index as f64)),
-            IteratorState::ArrayEntries(state) => {
-                let value = self
-                    .arrays
-                    .get(state.array)
-                    .ok_or_else(|| MustardError::runtime("array missing"))?
-                    .elements
-                    .get(state.next_index)
-                    .map(|value| value.clone().unwrap_or(Value::Undefined));
-                match value {
-                    Some(value) => Some(Value::Array(self.insert_array(
-                        vec![Value::Number(state.next_index as f64), value],
-                        IndexMap::new(),
-                    )?)),
-                    None => None,
-                }
-            }
-            IteratorState::String(state) => {
-                let chars = state.value.chars().collect::<Vec<_>>();
-                chars
-                    .get(state.next_index)
-                    .map(|ch| Value::String(ch.to_string()))
-            }
-            IteratorState::MapEntries(state) => {
-                let entry = self
-                    .maps
-                    .get(state.map)
-                    .ok_or_else(|| MustardError::runtime("map missing"))?
-                    .entries
-                    .get(state.next_index)
-                    .cloned();
-                match entry {
-                    Some(entry) => Some(Value::Array(
-                        self.insert_array(vec![entry.key, entry.value], IndexMap::new())?,
-                    )),
-                    None => None,
-                }
-            }
-            IteratorState::MapKeys(state) => self
-                .maps
-                .get(state.map)
-                .ok_or_else(|| MustardError::runtime("map missing"))?
-                .entries
-                .get(state.next_index)
-                .map(|entry| entry.key.clone()),
-            IteratorState::MapValues(state) => self
-                .maps
-                .get(state.map)
-                .ok_or_else(|| MustardError::runtime("map missing"))?
-                .entries
-                .get(state.next_index)
-                .map(|entry| entry.value.clone()),
-            IteratorState::SetEntries(state) => self
-                .sets
-                .get(state.set)
-                .ok_or_else(|| MustardError::runtime("set missing"))?
-                .entries
-                .get(state.next_index)
-                .cloned()
-                .map(|value| {
-                    self.insert_array(vec![value.clone(), value], IndexMap::new())
-                        .map(Value::Array)
-                })
-                .transpose()?,
-            IteratorState::SetValues(state) => self
-                .sets
-                .get(state.set)
-                .ok_or_else(|| MustardError::runtime("set missing"))?
-                .entries
-                .get(state.next_index)
-                .cloned(),
-        };
-
-        if value.is_some() {
-            if let Some(iterator) = self.iterators.get_mut(key) {
-                match &mut iterator.state {
-                    IteratorState::Array(state)
-                    | IteratorState::ArrayKeys(state)
-                    | IteratorState::ArrayEntries(state) => state.next_index += 1,
-                    IteratorState::String(state) => state.next_index += 1,
-                    IteratorState::MapEntries(state)
-                    | IteratorState::MapKeys(state)
-                    | IteratorState::MapValues(state) => state.next_index += 1,
-                    IteratorState::SetEntries(state) | IteratorState::SetValues(state) => {
-                        state.next_index += 1
-                    }
-                }
-            }
-            self.refresh_iterator_accounting(key)?;
-        }
-
-        Ok(match value {
-            Some(value) => (value, false),
-            None => (Value::Undefined, true),
-        })
-    }
-
-    pub(super) fn get_property(
-        &self,
-        object: Value,
-        property: Value,
-        optional: bool,
-    ) -> MustardResult<Value> {
-        if optional && matches!(object, Value::Null | Value::Undefined) {
-            return Ok(Value::Undefined);
-        }
-        let key = self.to_property_key(property)?;
-        match object {
-            Value::Object(object) => {
-                let object = self
-                    .objects
-                    .get(object)
-                    .ok_or_else(|| MustardError::runtime("object missing"))?;
-                if let ObjectKind::Date(_) = &object.kind {
-                    let built_in = match key.as_str() {
-                        "getTime" => Some(Value::BuiltinFunction(BuiltinFunction::DateGetTime)),
-                        "valueOf" => Some(Value::BuiltinFunction(BuiltinFunction::DateValueOf)),
-                        "toISOString" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::DateToISOString))
-                        }
-                        "toJSON" => Some(Value::BuiltinFunction(BuiltinFunction::DateToJSON)),
-                        "getUTCFullYear" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::DateGetUTCFullYear))
-                        }
-                        "getUTCMonth" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::DateGetUTCMonth))
-                        }
-                        "getUTCDate" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::DateGetUTCDate))
-                        }
-                        "getUTCHours" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::DateGetUTCHours))
-                        }
-                        "getUTCMinutes" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::DateGetUTCMinutes))
-                        }
-                        "getUTCSeconds" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::DateGetUTCSeconds))
-                        }
-                        "constructor" => Some(Value::BuiltinFunction(BuiltinFunction::DateCtor)),
-                        _ => None,
-                    };
-                    if let Some(value) = built_in {
-                        return Ok(value);
-                    }
-                }
-                if let ObjectKind::RegExp(regex) = &object.kind {
-                    let built_in = match key.as_str() {
-                        "source" => Some(Value::String(regex.pattern.clone())),
-                        "flags" => Some(Value::String(regex.flags.clone())),
-                        "global" => Some(Value::Bool(regex.flags.contains('g'))),
-                        "ignoreCase" => Some(Value::Bool(regex.flags.contains('i'))),
-                        "multiline" => Some(Value::Bool(regex.flags.contains('m'))),
-                        "dotAll" => Some(Value::Bool(regex.flags.contains('s'))),
-                        "unicode" => Some(Value::Bool(regex.flags.contains('u'))),
-                        "sticky" => Some(Value::Bool(regex.flags.contains('y'))),
-                        "lastIndex" => Some(Value::Number(regex.last_index as f64)),
-                        "exec" => Some(Value::BuiltinFunction(BuiltinFunction::RegExpExec)),
-                        "test" => Some(Value::BuiltinFunction(BuiltinFunction::RegExpTest)),
-                        "constructor" => Some(Value::BuiltinFunction(BuiltinFunction::RegExpCtor)),
-                        _ => None,
-                    };
-                    if let Some(value) = built_in {
-                        return Ok(value);
-                    }
-                }
-                if let ObjectKind::StringObject(value) = &object.kind {
-                    if key == "length" {
-                        return Ok(Value::Number(value.chars().count() as f64));
-                    }
-                    if let Some(index) = array_index_from_property_key(&key)
-                        && let Some(ch) = value.chars().nth(index)
-                    {
-                        return Ok(Value::String(ch.to_string()));
-                    }
-                    if let Some(method) = match key.as_str() {
-                        "trim" => Some(Value::BuiltinFunction(BuiltinFunction::StringTrim)),
-                        "trimStart" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::StringTrimStart))
-                        }
-                        "trimEnd" => Some(Value::BuiltinFunction(BuiltinFunction::StringTrimEnd)),
-                        "includes" => Some(Value::BuiltinFunction(BuiltinFunction::StringIncludes)),
-                        "startsWith" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::StringStartsWith))
-                        }
-                        "endsWith" => Some(Value::BuiltinFunction(BuiltinFunction::StringEndsWith)),
-                        "indexOf" => Some(Value::BuiltinFunction(BuiltinFunction::StringIndexOf)),
-                        "lastIndexOf" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::StringLastIndexOf))
-                        }
-                        "charAt" => Some(Value::BuiltinFunction(BuiltinFunction::StringCharAt)),
-                        "at" => Some(Value::BuiltinFunction(BuiltinFunction::StringAt)),
-                        "slice" => Some(Value::BuiltinFunction(BuiltinFunction::StringSlice)),
-                        "substring" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::StringSubstring))
-                        }
-                        "toLowerCase" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::StringToLowerCase))
-                        }
-                        "toUpperCase" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::StringToUpperCase))
-                        }
-                        "repeat" => Some(Value::BuiltinFunction(BuiltinFunction::StringRepeat)),
-                        "concat" => Some(Value::BuiltinFunction(BuiltinFunction::StringConcat)),
-                        "padStart" => Some(Value::BuiltinFunction(BuiltinFunction::StringPadStart)),
-                        "padEnd" => Some(Value::BuiltinFunction(BuiltinFunction::StringPadEnd)),
-                        "split" => Some(Value::BuiltinFunction(BuiltinFunction::StringSplit)),
-                        "replace" => Some(Value::BuiltinFunction(BuiltinFunction::StringReplace)),
-                        "replaceAll" => {
-                            Some(Value::BuiltinFunction(BuiltinFunction::StringReplaceAll))
-                        }
-                        "search" => Some(Value::BuiltinFunction(BuiltinFunction::StringSearch)),
-                        "match" => Some(Value::BuiltinFunction(BuiltinFunction::StringMatch)),
-                        "matchAll" => Some(Value::BuiltinFunction(BuiltinFunction::StringMatchAll)),
-                        "toString" => Some(Value::BuiltinFunction(BuiltinFunction::StringToString)),
-                        "valueOf" => Some(Value::BuiltinFunction(BuiltinFunction::StringValueOf)),
-                        _ => None,
-                    } {
-                        return Ok(method);
-                    }
-                }
-                if let ObjectKind::NumberObject(_) = &object.kind {
-                    match key.as_str() {
-                        "toString" => {
-                            return Ok(Value::BuiltinFunction(BuiltinFunction::NumberToString));
-                        }
-                        "valueOf" => {
-                            return Ok(Value::BuiltinFunction(BuiltinFunction::NumberValueOf));
-                        }
-                        _ => {}
-                    }
-                }
-                if let ObjectKind::BooleanObject(_) = &object.kind {
-                    match key.as_str() {
-                        "toString" => {
-                            return Ok(Value::BuiltinFunction(BuiltinFunction::BooleanToString));
-                        }
-                        "valueOf" => {
-                            return Ok(Value::BuiltinFunction(BuiltinFunction::BooleanValueOf));
-                        }
-                        _ => {}
-                    }
-                }
-                if matches!(object.kind, ObjectKind::Intl) {
-                    let built_in = match key.as_str() {
-                        "DateTimeFormat" => Some(Value::BuiltinFunction(
-                            BuiltinFunction::IntlDateTimeFormatCtor,
-                        )),
-                        "NumberFormat" => Some(Value::BuiltinFunction(
-                            BuiltinFunction::IntlNumberFormatCtor,
-                        )),
-                        "constructor" => Some(Value::BuiltinFunction(BuiltinFunction::ObjectCtor)),
-                        _ => None,
-                    };
-                    if let Some(value) = built_in {
-                        return Ok(value);
-                    }
-                }
-                if matches!(object.kind, ObjectKind::IntlDateTimeFormat(_)) {
-                    let built_in = match key.as_str() {
-                        "constructor" => Some(Value::BuiltinFunction(
-                            BuiltinFunction::IntlDateTimeFormatCtor,
-                        )),
-                        "format" => Some(Value::BuiltinFunction(
-                            BuiltinFunction::IntlDateTimeFormatFormat,
-                        )),
-                        "resolvedOptions" => Some(Value::BuiltinFunction(
-                            BuiltinFunction::IntlDateTimeFormatResolvedOptions,
-                        )),
-                        _ => None,
-                    };
-                    if let Some(value) = built_in {
-                        return Ok(value);
-                    }
-                }
-                if matches!(object.kind, ObjectKind::IntlNumberFormat(_)) {
-                    let built_in = match key.as_str() {
-                        "constructor" => Some(Value::BuiltinFunction(
-                            BuiltinFunction::IntlNumberFormatCtor,
-                        )),
-                        "format" => Some(Value::BuiltinFunction(
-                            BuiltinFunction::IntlNumberFormatFormat,
-                        )),
-                        "resolvedOptions" => Some(Value::BuiltinFunction(
-                            BuiltinFunction::IntlNumberFormatResolvedOptions,
-                        )),
-                        _ => None,
-                    };
-                    if let Some(value) = built_in {
-                        return Ok(value);
-                    }
-                }
-                if let Some(value) = object.properties.get(&key) {
-                    return Ok(value.clone());
-                }
-                if let ObjectKind::FunctionPrototype(constructor) = &object.kind {
-                    if key == "constructor" {
-                        return Ok(constructor.clone());
-                    }
-                    if matches!(
-                        constructor,
-                        Value::BuiltinFunction(BuiltinFunction::DateCtor)
-                    ) {
-                        match key.as_str() {
-                            "getTime" => {
-                                return Ok(Value::BuiltinFunction(BuiltinFunction::DateGetTime));
-                            }
-                            "valueOf" => {
-                                return Ok(Value::BuiltinFunction(BuiltinFunction::DateValueOf));
-                            }
-                            "toISOString" => {
-                                return Ok(Value::BuiltinFunction(
-                                    BuiltinFunction::DateToISOString,
-                                ));
-                            }
-                            "toJSON" => {
-                                return Ok(Value::BuiltinFunction(BuiltinFunction::DateToJSON));
-                            }
-                            "getUTCFullYear" => {
-                                return Ok(Value::BuiltinFunction(
-                                    BuiltinFunction::DateGetUTCFullYear,
-                                ));
-                            }
-                            "getUTCMonth" => {
-                                return Ok(Value::BuiltinFunction(
-                                    BuiltinFunction::DateGetUTCMonth,
-                                ));
-                            }
-                            "getUTCDate" => {
-                                return Ok(Value::BuiltinFunction(BuiltinFunction::DateGetUTCDate));
-                            }
-                            "getUTCHours" => {
-                                return Ok(Value::BuiltinFunction(
-                                    BuiltinFunction::DateGetUTCHours,
-                                ));
-                            }
-                            "getUTCMinutes" => {
-                                return Ok(Value::BuiltinFunction(
-                                    BuiltinFunction::DateGetUTCMinutes,
-                                ));
-                            }
-                            "getUTCSeconds" => {
-                                return Ok(Value::BuiltinFunction(
-                                    BuiltinFunction::DateGetUTCSeconds,
-                                ));
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-                if let ObjectKind::BoundFunction(bound) = &object.kind {
-                    match key.as_str() {
-                        "name" => {
-                            return Ok(Value::String(format!(
-                                "bound {}",
-                                self.callable_name(&bound.target)?
-                            )));
-                        }
-                        "length" => {
-                            let length = self
-                                .callable_length(&bound.target)?
-                                .saturating_sub(bound.args.len());
-                            return Ok(Value::Number(length as f64));
-                        }
-                        "constructor" => return Ok(Self::callable_constructor()),
-                        _ => {
-                            if let Some(method) = Self::function_helper_method(&key) {
-                                return Ok(method);
-                            }
-                        }
-                    }
-                }
-                if let ObjectKind::StringObject(_) = &object.kind
-                    && key == "constructor"
-                {
-                    return Ok(Value::BuiltinFunction(BuiltinFunction::StringCtor));
-                }
-                if let ObjectKind::NumberObject(_) = &object.kind
-                    && key == "constructor"
-                {
-                    return Ok(Value::BuiltinFunction(BuiltinFunction::NumberCtor));
-                }
-                if let ObjectKind::BooleanObject(_) = &object.kind
-                    && key == "constructor"
-                {
-                    return Ok(Value::BuiltinFunction(BuiltinFunction::BooleanCtor));
-                }
-                if matches!(object.kind, ObjectKind::Console)
-                    && let Some(value) = self.console_method(&key)
-                {
-                    return Ok(value);
-                }
-                if key == "constructor" {
-                    match &object.kind {
-                        ObjectKind::Plain
-                        | ObjectKind::Global
-                        | ObjectKind::Math
-                        | ObjectKind::Json
-                        | ObjectKind::Intl
-                        | ObjectKind::BoundFunction(_) => {
-                            return Ok(Value::BuiltinFunction(BuiltinFunction::ObjectCtor));
-                        }
-                        ObjectKind::Error(name) => {
-                            let ctor = match name.as_str() {
-                                "TypeError" => BuiltinFunction::TypeErrorCtor,
-                                "ReferenceError" => BuiltinFunction::ReferenceErrorCtor,
-                                "RangeError" => BuiltinFunction::RangeErrorCtor,
-                                "SyntaxError" => BuiltinFunction::SyntaxErrorCtor,
-                                _ => BuiltinFunction::ErrorCtor,
-                            };
-                            return Ok(Value::BuiltinFunction(ctor));
-                        }
-                        _ => {}
-                    }
-                }
-                Ok(Value::Undefined)
-            }
-            Value::Array(array) => {
-                let array = self
-                    .arrays
-                    .get(array)
-                    .ok_or_else(|| MustardError::runtime("array missing"))?;
-                if key == "length" {
-                    Ok(Value::Number(array.elements.len() as f64))
-                } else if key == "constructor" {
-                    Ok(Value::BuiltinFunction(BuiltinFunction::ArrayCtor))
-                } else if let Some(index) = array_index_from_property_key(&key) {
-                    Ok(array
-                        .elements
-                        .get(index)
-                        .cloned()
-                        .flatten()
-                        .unwrap_or(Value::Undefined))
-                } else if let Some(value) = array.properties.get(&key) {
-                    Ok(value.clone())
-                } else {
-                    match key.as_str() {
-                        "sort" => Ok(Value::BuiltinFunction(BuiltinFunction::ArraySort)),
-                        "push" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayPush)),
-                        "pop" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayPop)),
-                        "slice" => Ok(Value::BuiltinFunction(BuiltinFunction::ArraySlice)),
-                        "splice" => Ok(Value::BuiltinFunction(BuiltinFunction::ArraySplice)),
-                        "concat" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayConcat)),
-                        "at" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayAt)),
-                        "join" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayJoin)),
-                        "includes" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayIncludes)),
-                        "indexOf" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayIndexOf)),
-                        "lastIndexOf" => {
-                            Ok(Value::BuiltinFunction(BuiltinFunction::ArrayLastIndexOf))
-                        }
-                        "reverse" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayReverse)),
-                        "fill" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayFill)),
-                        "values" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayValues)),
-                        "keys" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayKeys)),
-                        "entries" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayEntries)),
-                        "forEach" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayForEach)),
-                        "map" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayMap)),
-                        "filter" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayFilter)),
-                        "find" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayFind)),
-                        "findIndex" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayFindIndex)),
-                        "some" => Ok(Value::BuiltinFunction(BuiltinFunction::ArraySome)),
-                        "every" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayEvery)),
-                        "flat" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayFlat)),
-                        "flatMap" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayFlatMap)),
-                        "reduce" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayReduce)),
-                        "reduceRight" => {
-                            Ok(Value::BuiltinFunction(BuiltinFunction::ArrayReduceRight))
-                        }
-                        "findLast" => Ok(Value::BuiltinFunction(BuiltinFunction::ArrayFindLast)),
-                        "findLastIndex" => {
-                            Ok(Value::BuiltinFunction(BuiltinFunction::ArrayFindLastIndex))
-                        }
-                        _ => Ok(Value::Undefined),
-                    }
-                }
-            }
-            Value::Map(map) => {
-                let map = self
-                    .maps
-                    .get(map)
-                    .ok_or_else(|| MustardError::runtime("map missing"))?;
-                match key.as_str() {
-                    "constructor" => Ok(Value::BuiltinFunction(BuiltinFunction::MapCtor)),
-                    "size" => Ok(Value::Number(map.entries.len() as f64)),
-                    "get" => Ok(Value::BuiltinFunction(BuiltinFunction::MapGet)),
-                    "set" => Ok(Value::BuiltinFunction(BuiltinFunction::MapSet)),
-                    "has" => Ok(Value::BuiltinFunction(BuiltinFunction::MapHas)),
-                    "delete" => Ok(Value::BuiltinFunction(BuiltinFunction::MapDelete)),
-                    "clear" => Ok(Value::BuiltinFunction(BuiltinFunction::MapClear)),
-                    "entries" => Ok(Value::BuiltinFunction(BuiltinFunction::MapEntries)),
-                    "keys" => Ok(Value::BuiltinFunction(BuiltinFunction::MapKeys)),
-                    "values" => Ok(Value::BuiltinFunction(BuiltinFunction::MapValues)),
-                    "forEach" => Ok(Value::BuiltinFunction(BuiltinFunction::MapForEach)),
-                    _ => Ok(Value::Undefined),
-                }
-            }
-            Value::Set(set) => {
-                let set = self
-                    .sets
-                    .get(set)
-                    .ok_or_else(|| MustardError::runtime("set missing"))?;
-                match key.as_str() {
-                    "constructor" => Ok(Value::BuiltinFunction(BuiltinFunction::SetCtor)),
-                    "size" => Ok(Value::Number(set.entries.len() as f64)),
-                    "add" => Ok(Value::BuiltinFunction(BuiltinFunction::SetAdd)),
-                    "has" => Ok(Value::BuiltinFunction(BuiltinFunction::SetHas)),
-                    "delete" => Ok(Value::BuiltinFunction(BuiltinFunction::SetDelete)),
-                    "clear" => Ok(Value::BuiltinFunction(BuiltinFunction::SetClear)),
-                    "entries" => Ok(Value::BuiltinFunction(BuiltinFunction::SetEntries)),
-                    "keys" => Ok(Value::BuiltinFunction(BuiltinFunction::SetKeys)),
-                    "values" => Ok(Value::BuiltinFunction(BuiltinFunction::SetValues)),
-                    "forEach" => Ok(Value::BuiltinFunction(BuiltinFunction::SetForEach)),
-                    _ => Ok(Value::Undefined),
-                }
-            }
-            Value::Iterator(_) if key == "next" => {
-                Ok(Value::BuiltinFunction(BuiltinFunction::IteratorNext))
-            }
-            Value::Iterator(_) if key == "constructor" => {
-                Ok(Value::BuiltinFunction(BuiltinFunction::ObjectCtor))
-            }
-            Value::Iterator(_) => Ok(Value::Undefined),
-            Value::Promise(_) => match key.as_str() {
-                "constructor" => Ok(Value::BuiltinFunction(BuiltinFunction::PromiseCtor)),
-                "then" => Ok(Value::BuiltinFunction(BuiltinFunction::PromiseThen)),
-                "catch" => Ok(Value::BuiltinFunction(BuiltinFunction::PromiseCatch)),
-                "finally" => Ok(Value::BuiltinFunction(BuiltinFunction::PromiseFinally)),
-                _ => Ok(Value::Undefined),
-            },
-            Value::BuiltinFunction(function) => {
-                if let Some(value) = self.builtin_function_custom_property(function, &key)? {
-                    return Ok(value);
-                }
-                if let Some(value) = self.builtin_function_own_property(function, &key) {
-                    return Ok(value);
-                }
-                if key == "constructor" {
-                    return Ok(Self::callable_constructor());
-                }
-                Ok(Self::function_helper_method(&key).unwrap_or(Value::Undefined))
-            }
-            Value::Closure(closure) => {
-                if let Some(value) = self.closure_own_property(closure, &key)? {
-                    return Ok(value);
-                }
-                if key == "constructor" {
-                    return Ok(Self::callable_constructor());
-                }
-                Ok(Self::function_helper_method(&key).unwrap_or(Value::Undefined))
-            }
-            Value::HostFunction(capability) => {
-                if let Some(value) = self.host_function_custom_property(&capability, &key)? {
-                    return Ok(value);
-                }
-                match key.as_str() {
-                    "name" => Ok(Value::String(capability)),
-                    "length" => Ok(Value::Number(0.0)),
-                    "constructor" => Ok(Self::callable_constructor()),
-                    _ => Ok(Self::function_helper_method(&key).unwrap_or(Value::Undefined)),
-                }
-            }
-            Value::String(value) => match key.as_str() {
-                "length" => Ok(Value::Number(value.chars().count() as f64)),
-                "constructor" => Ok(Value::BuiltinFunction(BuiltinFunction::StringCtor)),
-                "trim" => Ok(Value::BuiltinFunction(BuiltinFunction::StringTrim)),
-                "trimStart" => Ok(Value::BuiltinFunction(BuiltinFunction::StringTrimStart)),
-                "trimEnd" => Ok(Value::BuiltinFunction(BuiltinFunction::StringTrimEnd)),
-                "includes" => Ok(Value::BuiltinFunction(BuiltinFunction::StringIncludes)),
-                "startsWith" => Ok(Value::BuiltinFunction(BuiltinFunction::StringStartsWith)),
-                "endsWith" => Ok(Value::BuiltinFunction(BuiltinFunction::StringEndsWith)),
-                "indexOf" => Ok(Value::BuiltinFunction(BuiltinFunction::StringIndexOf)),
-                "lastIndexOf" => Ok(Value::BuiltinFunction(BuiltinFunction::StringLastIndexOf)),
-                "charAt" => Ok(Value::BuiltinFunction(BuiltinFunction::StringCharAt)),
-                "at" => Ok(Value::BuiltinFunction(BuiltinFunction::StringAt)),
-                "slice" => Ok(Value::BuiltinFunction(BuiltinFunction::StringSlice)),
-                "substring" => Ok(Value::BuiltinFunction(BuiltinFunction::StringSubstring)),
-                "toLowerCase" => Ok(Value::BuiltinFunction(BuiltinFunction::StringToLowerCase)),
-                "toUpperCase" => Ok(Value::BuiltinFunction(BuiltinFunction::StringToUpperCase)),
-                "repeat" => Ok(Value::BuiltinFunction(BuiltinFunction::StringRepeat)),
-                "concat" => Ok(Value::BuiltinFunction(BuiltinFunction::StringConcat)),
-                "padStart" => Ok(Value::BuiltinFunction(BuiltinFunction::StringPadStart)),
-                "padEnd" => Ok(Value::BuiltinFunction(BuiltinFunction::StringPadEnd)),
-                "split" => Ok(Value::BuiltinFunction(BuiltinFunction::StringSplit)),
-                "replace" => Ok(Value::BuiltinFunction(BuiltinFunction::StringReplace)),
-                "replaceAll" => Ok(Value::BuiltinFunction(BuiltinFunction::StringReplaceAll)),
-                "search" => Ok(Value::BuiltinFunction(BuiltinFunction::StringSearch)),
-                "match" => Ok(Value::BuiltinFunction(BuiltinFunction::StringMatch)),
-                "matchAll" => Ok(Value::BuiltinFunction(BuiltinFunction::StringMatchAll)),
-                "toString" => Ok(Value::BuiltinFunction(BuiltinFunction::StringToString)),
-                "valueOf" => Ok(Value::BuiltinFunction(BuiltinFunction::StringValueOf)),
-                _ if array_index_from_property_key(&key)
-                    .is_some_and(|index| value.chars().nth(index).is_some()) =>
-                {
-                    let index = array_index_from_property_key(&key).expect("index already checked");
-                    Ok(Value::String(
-                        value
-                            .chars()
-                            .nth(index)
-                            .expect("index already checked")
-                            .to_string(),
-                    ))
-                }
-                _ => Ok(Value::Undefined),
-            },
-            Value::Number(_) => match key.as_str() {
-                "constructor" => Ok(Value::BuiltinFunction(BuiltinFunction::NumberCtor)),
-                "toString" => Ok(Value::BuiltinFunction(BuiltinFunction::NumberToString)),
-                "valueOf" => Ok(Value::BuiltinFunction(BuiltinFunction::NumberValueOf)),
-                _ => Ok(Value::Undefined),
-            },
-            Value::Bool(_) => match key.as_str() {
-                "constructor" => Ok(Value::BuiltinFunction(BuiltinFunction::BooleanCtor)),
-                "toString" => Ok(Value::BuiltinFunction(BuiltinFunction::BooleanToString)),
-                "valueOf" => Ok(Value::BuiltinFunction(BuiltinFunction::BooleanValueOf)),
-                _ => Ok(Value::Undefined),
-            },
-            Value::Null | Value::Undefined => Err(MustardError::runtime(
-                "TypeError: cannot read properties of nullish value",
-            )),
-            _ => Ok(Value::Undefined),
-        }
-    }
-
-    pub(super) fn callable_name(&self, value: &Value) -> MustardResult<String> {
-        Ok(match value {
-            Value::Closure(closure) => match self.closure_own_property(*closure, "name")? {
-                Some(Value::String(name)) => name,
-                _ => String::new(),
-            },
-            Value::BuiltinFunction(function) => Self::builtin_function_name(*function).to_string(),
-            Value::HostFunction(capability) => capability.clone(),
-            Value::Object(object) => match &self
-                .objects
-                .get(*object)
-                .ok_or_else(|| MustardError::runtime("object missing"))?
-                .kind
-            {
-                ObjectKind::BoundFunction(bound) => {
-                    format!("bound {}", self.callable_name(&bound.target)?)
-                }
-                _ => String::new(),
-            },
-            _ => String::new(),
-        })
-    }
-
-    fn callable_length(&self, value: &Value) -> MustardResult<usize> {
-        Ok(match value {
-            Value::Closure(closure) => match self.closure_own_property(*closure, "length")? {
-                Some(Value::Number(length)) => length.max(0.0) as usize,
-                _ => 0,
-            },
-            Value::BuiltinFunction(function) => Self::builtin_function_length(*function),
-            Value::HostFunction(_) => 0,
-            Value::Object(object) => match &self
-                .objects
-                .get(*object)
-                .ok_or_else(|| MustardError::runtime("object missing"))?
-                .kind
-            {
-                ObjectKind::BoundFunction(bound) => self
-                    .callable_length(&bound.target)?
-                    .saturating_sub(bound.args.len()),
-                _ => 0,
-            },
-            _ => 0,
-        })
-    }
-
-    pub(super) fn set_property(
-        &mut self,
-        object: Value,
-        property: Value,
-        value: Value,
-    ) -> MustardResult<()> {
-        let key = self.to_property_key(property)?;
-        self.infer_closure_name(&value, &key)?;
-        match object {
-            Value::Object(object) => {
-                if self.is_regexp_object(object) && key == "lastIndex" {
-                    let index = self.to_integer(value.clone())?.max(0) as usize;
-                    self.regexp_object_mut(object)?.last_index = index;
-                    self.refresh_object_accounting(object)?;
-                    return Ok(());
-                }
-                self.objects
-                    .get_mut(object)
-                    .ok_or_else(|| MustardError::runtime("object missing"))?
-                    .properties
-                    .insert(key, value);
-                self.refresh_object_accounting(object)?;
-                Ok(())
-            }
-            Value::Array(array) => {
-                if key == "length" {
-                    self.set_array_length(array, value)?;
-                    return Ok(());
-                }
-                {
-                    let array_ref = self
-                        .arrays
-                        .get_mut(array)
-                        .ok_or_else(|| MustardError::runtime("array missing"))?;
-                    if let Some(index) = array_index_from_property_key(&key) {
-                        if index >= array_ref.elements.len() {
-                            array_ref.elements.resize(index + 1, None);
-                        }
-                        array_ref.elements[index] = Some(value);
-                    } else {
-                        array_ref.properties.insert(key, value);
-                    }
-                }
-                self.refresh_array_accounting(array)?;
-                Ok(())
-            }
-            Value::Map(_) => Err(MustardError::runtime(
-                "TypeError: custom properties on Map values are not supported",
-            )),
-            Value::Set(_) => Err(MustardError::runtime(
-                "TypeError: custom properties on Set values are not supported",
-            )),
-            Value::Closure(closure) => self.set_closure_property(closure, key, value),
-            Value::BuiltinFunction(function) => {
-                self.set_builtin_function_property(function, key, value)
-            }
-            Value::HostFunction(capability) => {
-                self.set_host_function_property(capability, key, value)
-            }
-            _ => Err(MustardError::runtime("TypeError: value is not an object")),
-        }
-    }
-
-    pub(super) fn console_method(&self, key: &str) -> Option<Value> {
-        let capability = match key {
-            "log" => "console.log",
-            "warn" => "console.warn",
-            "error" => "console.error",
-            _ => return None,
-        };
-        self.capability_value(capability)
-    }
-}
-
-pub(super) fn canonicalize_collection_key(value: Value) -> Value {
-    match value {
-        Value::Number(number) if number == 0.0 && number.is_sign_negative() => Value::Number(0.0),
-        other => other,
-    }
-}
-
-pub(super) fn property_name_to_key(name: &PropertyName) -> String {
-    match name {
-        PropertyName::Identifier(name) | PropertyName::String(name) => name.clone(),
-        PropertyName::Number(number) => format_number_key(*number),
-    }
-}
-
-pub(super) fn format_number_key(value: f64) -> String {
-    if value.fract() == 0.0 {
-        format!("{}", value as i64)
-    } else {
-        value.to_string()
-    }
-}
-
-pub(super) fn array_index_from_property_key(key: &str) -> Option<usize> {
-    if key == "0" {
-        return Some(0);
-    }
-
-    if key.is_empty() || key.starts_with('0') {
-        return None;
-    }
-
-    let index = key.parse::<u32>().ok()?;
-    if index == u32::MAX {
-        return None;
-    }
-
-    if key == index.to_string() {
-        Some(index as usize)
-    } else {
-        None
-    }
-}
-
-pub(super) fn ordered_own_property_keys(properties: &IndexMap<String, Value>) -> Vec<String> {
-    ordered_own_property_keys_filtered(properties, |_, _| true)
-}
-
-pub(super) fn ordered_own_property_keys_filtered<F>(
-    properties: &IndexMap<String, Value>,
-    mut include: F,
-) -> Vec<String>
-where
-    F: FnMut(&str, &Value) -> bool,
-{
-    let mut keys = Vec::with_capacity(properties.len());
-    let mut index_keys = properties
-        .iter()
-        .filter(|(key, value)| include(key, value))
-        .filter_map(|(key, _)| array_index_from_property_key(key).map(|index| (index, key.clone())))
-        .collect::<Vec<_>>();
-    index_keys.sort_unstable_by_key(|(index, _)| *index);
-    keys.extend(index_keys.into_iter().map(|(_, key)| key));
-
-    keys.extend(
-        properties
-            .iter()
-            .filter(|(key, value)| {
-                include(key, value) && array_index_from_property_key(key).is_none()
-            })
-            .map(|(key, _)| key.clone()),
-    );
-
-    keys
-}