typedarray: use locale-sensitive separator in %TypedArray%.prototype.toLocaleString (#5089)

## Summary

Update `%TypedArray%.prototype.toLocaleString` to use a locale-sensitive
separator when the `intl` feature is enabled, aligning its behavior with
`Array.prototype.toLocaleString`.

### ref - #5081 

Previously, the TypedArray implementation always used the hardcoded
separator `", "`. When the `intl` feature is enabled,
`Array.prototype.toLocaleString` already derives the separator using
ICU's `ListFormatter`. This PR updates the TypedArray implementation to
use the same locale-aware separator logic.

When the `intl` feature is disabled, the implementation correctly falls
back to `", "`.

## Changes

- Use ICU `ListFormatter` via the `intl_provider` to compute a
locale-sensitive separator when the `intl` feature is enabled.
- Fall back to the default separator `", "` when `intl` is disabled.
- Hoist extraction of `locales` and `options` arguments outside the
iteration loop to avoid repeated lookups.
- Remove the unused `utf16` import from the module.

## Specification

This aligns the implementation with:

- **ECMAScript §23.2.3.31**  
  `%TypedArray%.prototype.toLocaleString`

which specifies that the algorithm should behave the same as:

- **ECMAScript §23.1.3.32**  
  `Array.prototype.toLocaleString`

except that `TypedArrayLength` is used instead of `LengthOfArrayLike`.

## Verification

The following checks were performed:

- `cargo fmt`
- `cargo clippy`
- `cargo test`
- Test262 tests for TypedArray locale string conversion:
<img width="760" height="184" alt="Screenshot 2026-03-15 at 8 27 06 AM"
src="https://github.com/user-attachments/assets/e75a497e-3fab-44ce-85ae-3c3c33e01149"
/>

All existing tests pass and no regressions were introduced.

## Notes

The behavior now matches the locale-sensitive list separator behavior
used by `Array.prototype.toLocaleString` when `intl` support is enabled.

---------

Signed-off-by: mrhapile <allinonegaming3456@gmail.com>

Author: mrhapile

core/engine/src/builtins/intl/number_format/mod.rs

@@ -761,7 +761,10 @@ fn unwrap_number_format(nf: &JsValue, context: &mut Context) -> JsResult<JsObjec
 /// Abstract operation [`ToIntlMathematicalValue ( value )`][spec].
 ///
 /// [spec]: https://tc39.es/ecma402/#sec-tointlmathematicalvalue
-fn to_intl_mathematical_value(value: &JsValue, context: &mut Context) -> JsResult<Decimal> {
+pub(crate) fn to_intl_mathematical_value(
+    value: &JsValue,
+    context: &mut Context,
+) -> JsResult<Decimal> {
     // 1. Let primValue be ? ToPrimitive(value, number).
     let prim_value = value.to_primitive(context, PreferredType::Number)?;
 

core/engine/src/builtins/typed_array/builtin.rs

@@ -3,7 +3,6 @@ use std::{
     sync::atomic::Ordering,
 };
 
-use boa_macros::utf16;
 use num_traits::Zero;
 
 use super::{
@@ -1211,7 +1210,7 @@ impl BuiltinTypedArray {
         };
 
         // 6. Let R be the empty String.
-        let mut r = Vec::new();
+        let mut r = Vec::with_capacity(len as usize);
 
         // 7. Let k be 0.
         // 8. Repeat, while k < len,
@@ -2503,24 +2502,44 @@ impl BuiltinTypedArray {
             (o.array_length(buf_len), is_fixed_len)
         };
 
+        let locales = args.get_or_undefined(0);
+        let options = args.get_or_undefined(1);
+
         let separator = {
             #[cfg(feature = "intl")]
             {
-                // TODO: this should eventually return a locale-sensitive separator.
-                utf16!(", ")
+                use crate::builtins::intl::locale::default_locale;
+                use icu_list::{
+                    ListFormatter, ListFormatterPreferences, options::ListFormatterOptions,
+                };
+
+                let locale = default_locale(context.intl_provider().locale_canonicalizer()?);
+                let preferences = ListFormatterPreferences::from(&locale);
+                let formatter = ListFormatter::try_new_unit_with_buffer_provider(
+                    context.intl_provider().erased_provider(),
+                    preferences,
+                    ListFormatterOptions::default(),
+                )
+                .map_err(|e| JsNativeError::typ().with_message(e.to_string()))?;
+
+                // Ask ICU for the list pattern literal by formatting two empty elements.
+                // For many locales this yields ", ", but it may differ.
+                js_string!(
+                    formatter.format_to_string(std::iter::once("").chain(std::iter::once("")))
+                )
             }
 
             #[cfg(not(feature = "intl"))]
             {
-                utf16!(", ")
+                js_string!(", ")
             }
         };
 
-        let mut r = Vec::new();
+        let mut r = Vec::with_capacity((len + len.saturating_sub(1)) as usize);
 
         for k in 0..len {
             if k > 0 {
-                r.extend_from_slice(separator);
+                r.extend(separator.iter());
             }
 
             let next_element = array.get(k, context)?;
@@ -2531,10 +2550,7 @@ impl BuiltinTypedArray {
                 let s = next_element
                     .invoke(
                         js_string!("toLocaleString"),
-                        &[
-                            args.get_or_undefined(0).clone(),
-                            args.get_or_undefined(1).clone(),
-                        ],
+                        &[locales.clone(), options.clone()],
                         context,
                     )?
                     .to_string(context)?;