atmos/os_lib/js/builtins/

props_methods.rs

// 分割: builtins.rs より機械的に移動（2026-07-16 リファクタ フェーズ2）。
// ロジック不変。可視性のみ pub(crate) へ昇格し、親が pub(crate) use で再エクスポート。
use super::*;

// ============ グローバル関数 ============

/// `parseInt(string, radix)`。以前は `radix` 省略時に常に10進として扱い、また
/// `radix` を明示していても `"0x"`/`"0X"` 接頭辞を読み飛ばさなかった。仕様上は
/// `radix` 省略（または `0`）かつ文字列が（符号の後）`0x`/`0X` で始まる場合は自動的に
/// 16進として解釈し、明示的に `radix=16` の場合も同接頭辞を読み飛ばす必要がある。
/// 例: `parseInt("0xFF")` は仕様どおりなら `255` だが、以前は `0`（"0" の直後の "x" が
/// 数字でないため即座に打ち切られていた）になっていた。
pub(crate) fn global_parse_int(_: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = arg(a, 0).to_js_string();
    let radix_arg = arg(a, 1).to_number();
    let mut radix = if radix_arg.is_finite() && (2.0..=36.0).contains(&radix_arg) {
        radix_arg as u32
    } else {
        0 // 未指定/0: 後段で "0x" 接頭辞の有無を見て 16 か 10 かを決める。
    };
    let t = s.trim();
    let (neg, t) = if let Some(rest) = t.strip_prefix('-') {
        (true, rest)
    } else if let Some(rest) = t.strip_prefix('+') {
        (false, rest)
    } else {
        (false, t)
    };
    let has_hex_prefix = t.len() > 2 && (t.starts_with("0x") || t.starts_with("0X"));
    let t = if has_hex_prefix && (radix == 0 || radix == 16) {
        radix = 16;
        t.get(2..).unwrap_or("")
    } else {
        t
    };
    if radix == 0 {
        radix = 10;
    }
    let mut digits = String::new();
    for c in t.chars() {
        if c.is_digit(radix) {
            digits.push(c);
        } else {
            break;
        }
    }
    match i64::from_str_radix(&digits, radix) {
        Ok(n) => Ok(Value::Number(if neg { -n as f64 } else { n as f64 })),
        Err(_) => Ok(Value::Number(f64::NAN)),
    }
}
pub(crate) fn global_parse_float(_: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = arg(a, 0).to_js_string();
    let t = s.trim();
    // 先頭から数値として読める最長部分。
    let mut end = 0;
    let bytes = t.as_bytes();
    let mut seen_dot = false;
    let mut seen_e = false;
    while end < bytes.len() {
        let c = bytes[end] as char;
        if c.is_ascii_digit() {
            end += 1;
        } else if c == '.' && !seen_dot && !seen_e {
            seen_dot = true;
            end += 1;
        } else if (c == 'e' || c == 'E') && !seen_e && end > 0 {
            seen_e = true;
            end += 1;
        } else if (c == '+' || c == '-')
            && end > 0
            && (bytes[end - 1] == b'e' || bytes[end - 1] == b'E')
        {
            end += 1;
        } else {
            break;
        }
    }
    match t.get(..end).unwrap_or("").parse::<f64>() {
        Ok(n) => Ok(Value::Number(n)),
        Err(_) => Ok(Value::Number(f64::NAN)),
    }
}
pub(crate) fn global_is_nan(_: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(arg(a, 0).to_number().is_nan()))
}
pub(crate) fn global_is_finite(_: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(arg(a, 0).to_number().is_finite()))
}

/// `eval(source)`（ES1）。文字列以外の引数は仕様どおり無変換でそのまま返す。
pub(crate) fn global_eval(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let first = arg(a, 0);
    match &first {
        Value::Str(s) => it.eval_source(s),
        _ => Ok(first),
    }
}

/// `new Function(arg1, ..., argN, body)`（ES1）。動的にソースからコードを生成する定番
/// イディオム。`(function anonymous(arg1,...,argN){ body })` という即時式へ組み立て直し、
/// 既存の `eval_source`（常にグローバルスコープで実行する簡略実装）へ委譲する。
pub(crate) fn function_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let (params, body): (String, String) = match a.len() {
        0 => (String::new(), String::new()),
        1 => (String::new(), a[0].to_js_string()),
        n => {
            let params = a[..n - 1]
                .iter()
                .map(|v| v.to_js_string())
                .collect::<Vec<_>>()
                .join(",");
            (params, a[n - 1].to_js_string())
        }
    };
    let source = format!("(function anonymous({}) {{\n{}\n}})", params, body);
    it.eval_source(&source)
}

// ============ プロパティ取得（プリミティブ/組込みメソッド） ============

/// 文字列レシーバのプロパティ/メソッド。
pub fn string_get(s: &str, key: &str) -> Value {
    if key == "length" {
        return Value::Number(s.chars().count() as f64);
    }
    if let Ok(idx) = key.parse::<usize>() {
        return match s.chars().nth(idx) {
            Some(c) => Value::str(c.to_string()),
            None => Value::Undefined,
        };
    }
    match key {
        "charAt" => nv("charAt", str_char_at),
        "charCodeAt" => nv("charCodeAt", str_char_code_at),
        "codePointAt" => nv("codePointAt", str_code_point_at),
        "localeCompare" => nv("localeCompare", str_locale_compare),
        "indexOf" => nv("indexOf", str_index_of),
        "lastIndexOf" => nv("lastIndexOf", str_last_index_of),
        "includes" => nv("includes", str_includes),
        "startsWith" => nv("startsWith", str_starts_with),
        "endsWith" => nv("endsWith", str_ends_with),
        "slice" => nv("slice", str_slice),
        "substring" => nv("substring", str_substring),
        "substr" => nv("substr", str_substr),
        "toUpperCase" => nv("toUpperCase", str_to_upper),
        "toLowerCase" => nv("toLowerCase", str_to_lower),
        "trim" => nv("trim", str_trim),
        "split" => nv("split", str_split),
        "replace" => nv("replace", str_replace),
        "replaceAll" => nv("replaceAll", str_replace_all),
        "match" => nv("match", str_match),
        "matchAll" => nv("matchAll", str_match_all),
        "search" => nv("search", str_search),
        "repeat" => nv("repeat", str_repeat),
        "concat" => nv("concat", str_concat),
        "padStart" => nv("padStart", str_pad_start),
        "padEnd" => nv("padEnd", str_pad_end),
        "at" => nv("at", str_at),
        "toString" => nv("toString", str_identity),
        "trimStart" => nv("trimStart", str_trim_start),
        "trimEnd" => nv("trimEnd", str_trim_end),
        // `trimLeft`/`trimRight`（Annex B.2.2。`trimStart`/`trimEnd` の別名だが
        // 古いコードで今も見かける）が丸ごと未対応だった。
        "trimLeft" => nv("trimLeft", str_trim_start),
        "trimRight" => nv("trimRight", str_trim_end),
        "Symbol(Symbol.iterator)" => nv("[Symbol.iterator]", str_iterator),
        "isWellFormed" => nv("isWellFormed", str_is_well_formed),
        "toWellFormed" => nv("toWellFormed", str_to_well_formed),
        "normalize" => nv("normalize", str_normalize),
        // Annex B.2.3 の HTML ラッパーメソッド群（`"x".bold()`/`.link(url)` 等、
        // 古いコードで今も見かける）が丸ごと未対応だった。
        "anchor" => nv("anchor", str_anchor),
        "big" => nv("big", str_big),
        "blink" => nv("blink", str_blink),
        "bold" => nv("bold", str_bold),
        "fixed" => nv("fixed", str_fixed),
        "fontcolor" => nv("fontcolor", str_fontcolor),
        "fontsize" => nv("fontsize", str_fontsize),
        "italics" => nv("italics", str_italics),
        "link" => nv("link", str_link),
        "small" => nv("small", str_small),
        "strike" => nv("strike", str_strike),
        "sub" => nv("sub", str_sub),
        "sup" => nv("sup", str_sup),
        _ => Value::Undefined,
    }
}
/// Annex B.2.3 `CreateHTML` の属性なし版（`<tag>this</tag>`）。
pub(crate) fn html_wrap_tag(s: &str, tag: &str) -> String {
    alloc::format!("<{0}>{1}</{0}>", tag, s)
}
/// Annex B.2.3 `CreateHTML`。属性値の `"` は `&quot;` へエスケープする（仕様どおり）。
pub(crate) fn html_wrap_attr(s: &str, tag: &str, attr: &str, value: &str) -> String {
    let escaped = value.replace('"', "&quot;");
    alloc::format!("<{0} {1}=\"{2}\">{3}</{0}>", tag, attr, escaped, s)
}
pub(crate) fn str_anchor(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_attr(&this_str(&t), "a", "name", &arg(a, 0).to_js_string())))
}
pub(crate) fn str_big(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "big")))
}
pub(crate) fn str_blink(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "blink")))
}
pub(crate) fn str_bold(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "b")))
}
pub(crate) fn str_fixed(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "tt")))
}
pub(crate) fn str_fontcolor(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_attr(&this_str(&t), "font", "color", &arg(a, 0).to_js_string())))
}
pub(crate) fn str_fontsize(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_attr(&this_str(&t), "font", "size", &arg(a, 0).to_js_string())))
}
pub(crate) fn str_italics(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "i")))
}
pub(crate) fn str_link(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_attr(&this_str(&t), "a", "href", &arg(a, 0).to_js_string())))
}
pub(crate) fn str_small(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "small")))
}
pub(crate) fn str_strike(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "strike")))
}
pub(crate) fn str_sub(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "sub")))
}
pub(crate) fn str_sup(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(html_wrap_tag(&this_str(&t), "sup")))
}

pub(crate) fn this_str(this: &Value) -> String {
    this.to_js_string()
}

pub(crate) fn str_char_at(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let i = arg(a, 0).to_number() as usize;
    Ok(Value::str(
        s.chars().nth(i).map(|c| c.to_string()).unwrap_or_default(),
    ))
}
pub(crate) fn str_char_code_at(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let i = arg(a, 0).to_number() as usize;
    match s.chars().nth(i) {
        Some(c) => Ok(Value::Number(c as u32 as f64)),
        None => Ok(Value::Number(f64::NAN)),
    }
}
/// `String.prototype.codePointAt()`（ES2015）が丸ごと未実装だった（`charCodeAt` はあった）。
/// この処理系の文字列は Rust の `String`（既に UTF-8 のコードポイント単位）で保持されており
/// サロゲートペアの概念自体が無いため、`charCodeAt` と等価な実装で足りる
/// （範囲外は `NaN` ではなく仕様どおり `undefined` を返す点だけが異なる）。
pub(crate) fn str_code_point_at(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let i = arg(a, 0).to_number() as usize;
    match s.chars().nth(i) {
        Some(c) => Ok(Value::Number(c as u32 as f64)),
        None => Ok(Value::Undefined),
    }
}
/// `String.prototype.localeCompare()`（ES3）も未実装だった。この環境には Intl/ロケール
/// データが無いため、ロケール依存の照合順序ではなく通常の（コードポイント順）比較で近似する。
pub(crate) fn str_locale_compare(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let other = arg(a, 0).to_js_string();
    use core::cmp::Ordering;
    Ok(Value::Number(match s.as_str().cmp(other.as_str()) {
        Ordering::Less => -1.0,
        Ordering::Equal => 0.0,
        Ordering::Greater => 1.0,
    }))
}
/// 文字位置 `n`（文字単位）に対応するバイト位置（範囲外は末尾）。
fn char_to_byte(s: &str, n: usize) -> usize {
    s.char_indices().nth(n).map_or(s.len(), |(b, _)| b)
}

/// 位置の引数（文字単位。NaN は `default`、負は 0、範囲外は末尾）。
fn pos_arg(v: &Value, default: usize, len: usize) -> usize {
    if matches!(v, Value::Undefined) {
        return default;
    }
    let p = v.to_number();
    if p.is_nan() {
        default
    } else if p <= 0.0 {
        0
    } else if p.is_finite() {
        (p as usize).min(len)
    } else {
        len
    }
}

/// `str.indexOf(search, position)`（位置は文字単位）。
/// 【2026-10-17】従来は第 2 引数（開始位置）を無視していた。探索は `str::find`（バイト列）。
pub(crate) fn str_index_of(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let needle = arg(a, 0).to_js_string();
    let len = s.chars().count();
    let start_char = pos_arg(&arg(a, 1), 0, len);
    let start = char_to_byte(&s, start_char);
    match s.get(start..).and_then(|rest| rest.find(&needle)) {
        Some(off) => Ok(Value::Number((start_char + s.get(start..start + off).map_or(0, |t| t.chars().count())) as f64)),
        None => Ok(Value::Number(-1.0)),
    }
}

/// `str.lastIndexOf(search, position)`（位置は文字単位。省略・NaN は末尾から）。
/// 【2026-10-17】丸ごと未実装で、YouTube の cookie 読み出し（`f.lastIndexOf(c, 0) == 0`）が
/// 例外を投げ、そのエラー記録がまたエラーになる無限再帰を起こしていた。
pub(crate) fn str_last_index_of(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let needle = arg(a, 0).to_js_string();
    let len = s.chars().count();
    let nlen = needle.chars().count();
    if nlen > len {
        return Ok(Value::Number(-1.0));
    }
    // 一致の開始位置は `start_char` 以下。探索範囲は先頭から「開始位置 + 検索語の長さ」まで。
    let start_char = pos_arg(&arg(a, 1), len - nlen, len).min(len - nlen);
    let end = char_to_byte(&s, start_char + nlen);
    match s.get(..end).and_then(|head| head.rfind(&needle)) {
        Some(b) => Ok(Value::Number(s.get(..b).map_or(0, |t| t.chars().count()) as f64)),
        None => Ok(Value::Number(-1.0)),
    }
}
/// `includes`/`startsWith`/`endsWith` は仕様上、第1引数に `RegExp` を渡すと
/// `TypeError` を投げる必要がある（`str.includes(/x/)` のような「うっかり正規表現を
/// 渡した」誤用に対する意図的なガード。`match`/`replace` 等と違いこれらのメソッドは
/// 正規表現マッチングを一切サポートしないため、無警告でリテラル文字列
/// `"/x/"` として検索してしまうと気づきにくいバグの温床になる）。以前はこの
/// チェックが丸ごと欠落しており、常に無言でリテラル文字列比較にフォールバックして
/// いた。
pub(crate) fn reject_regexp_arg(it: &Interp, v: &Value, method: &str) -> Result<(), Value> {
    if as_regexp(v).is_some() {
        return Err(it.error(alloc::format!(
            "First argument to String.prototype.{} must not be a regular expression",
            method
        )));
    }
    Ok(())
}
pub(crate) fn str_includes(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    reject_regexp_arg(it, &arg(a, 0), "includes")?;
    Ok(Value::Bool(
        this_str(&t).contains(&arg(a, 0).to_js_string()),
    ))
}
pub(crate) fn str_starts_with(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    reject_regexp_arg(it, &arg(a, 0), "startsWith")?;
    Ok(Value::Bool(
        this_str(&t).starts_with(&arg(a, 0).to_js_string()),
    ))
}
pub(crate) fn str_ends_with(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    reject_regexp_arg(it, &arg(a, 0), "endsWith")?;
    Ok(Value::Bool(
        this_str(&t).ends_with(&arg(a, 0).to_js_string()),
    ))
}
pub(crate) fn str_slice(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let chars: Vec<char> = this_str(&t).chars().collect();
    let len = chars.len() as i64;
    let start = norm_index(arg(a, 0).to_number(), len, 0);
    let end = if matches!(arg(a, 1), Value::Undefined) {
        len
    } else {
        norm_index(arg(a, 1).to_number(), len, len)
    };
    let (s, e) = (start.max(0) as usize, end.max(0) as usize);
    Ok(Value::str(if s < e && s < chars.len() {
        chars[s..e.min(chars.len())].iter().collect::<String>()
    } else {
        String::new()
    }))
}
pub(crate) fn str_substring(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let chars: Vec<char> = this_str(&t).chars().collect();
    let len = chars.len();
    let mut s = clamp_idx(arg(a, 0).to_number(), len);
    let mut e = if matches!(arg(a, 1), Value::Undefined) {
        len
    } else {
        clamp_idx(arg(a, 1).to_number(), len)
    };
    if s > e {
        core::mem::swap(&mut s, &mut e);
    }
    Ok(Value::str(chars[s..e].iter().collect::<String>()))
}
/// `String.prototype.substr(start, length)`。ES3 由来の非推奨（Annex B）メソッドだが、
/// 古いコードで依然として広く使われるため実装する。`slice`/`substring` はあったが
/// `substr` だけが欠落していた。
pub(crate) fn str_substr(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let chars: Vec<char> = this_str(&t).chars().collect();
    let len = chars.len() as i64;
    let raw_start = arg(a, 0).to_number();
    let start = if raw_start < 0.0 {
        (len + raw_start as i64).max(0)
    } else {
        (raw_start as i64).min(len)
    };
    let length = if matches!(arg(a, 1), Value::Undefined) {
        len - start
    } else {
        (arg(a, 1).to_number() as i64).max(0)
    };
    let end = (start + length).min(len);
    let s = start as usize;
    let e = (end.max(start)) as usize;
    Ok(Value::str(if s < e {
        chars[s..e].iter().collect::<String>()
    } else {
        String::new()
    }))
}
pub(crate) fn str_to_upper(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(this_str(&t).to_uppercase()))
}
pub(crate) fn str_to_lower(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(this_str(&t).to_lowercase()))
}
pub(crate) fn str_trim(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(this_str(&t).trim().to_string()))
}
pub(crate) fn str_trim_start(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(this_str(&t).trim_start().to_string()))
}
pub(crate) fn str_trim_end(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(this_str(&t).trim_end().to_string()))
}
pub(crate) fn str_identity(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(this_str(&t)))
}
/// `String.prototype[Symbol.iterator]()`（ES2015）が丸ごと欠落していた。呼び出すと
/// 「メソッドが存在しない」`TypeError` になっていた（`for...of` 自体は文字列を直接
/// 走査する内部高速経路で動くため気づかれなかった）。コードポイント単位（サロゲート
/// ペアを1文字として扱う。Rust の `char` が既にスカラー値単位のため自然に対応できる）で
/// 走査する Iterator オブジェクトを、`Array.prototype[Symbol.iterator]` 等と同じ
/// `make_iterator()` を再利用して返す。
pub(crate) fn str_iterator(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let items: Vec<Value> = s.chars().map(|c| Value::str(c.to_string())).collect();
    Ok(Value::Object(make_iterator(items)))
}
/// `String.prototype.isWellFormed()`（ES2024）。内部表現が Rust の `String`（常に有効な UTF-8）
/// であるため、単独サロゲート（lone surrogate）は構造上存在し得ず常に true を返す簡略実装。
pub(crate) fn str_is_well_formed(_: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(true))
}
/// `String.prototype.toWellFormed()`（ES2024）。上記と同じ理由により常に元の文字列をそのまま返す。
pub(crate) fn str_to_well_formed(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(this_str(&t)))
}
/// `String.prototype.normalize(form)`（ES2015）。丸ごと欠落しており、呼び出すと
/// 「メソッドが存在しない」`TypeError` になっていた。本来は Unicode 正規化（NFC/NFD/NFKC/NFKD）
/// を行うが、この no_std 環境には正規化用の Unicode 分解/合成テーブルが無いため、`form` 引数の
/// 妥当性検証（無効な値は仕様どおり `RangeError`）だけ行い、内容は元の文字列をそのまま返す
/// 簡略実装（合成済み文字のみで構成された通常の文字列であれば実質的に無害）。
/// 西欧言語の合成済みラテン文字 ⇔ (基底文字, 結合分音符) の対応表。
/// フル Unicode Character Database（分解表・結合クラス・正規順序付け・合成除外
/// リスト）を持たない no_std 環境では完全な NFC/NFD/NFKC/NFKD 実装は非現実的な
/// ため、実用頻度の高いラテン語圏の分音符付き文字（フランス語・スペイン語・
/// ドイツ語・ポルトガル語等）に限定した部分実装とする。
pub(crate) const NFD_TABLE: &[(char, char, char)] = &[
    ('À', 'A', '\u{0300}'), ('Á', 'A', '\u{0301}'), ('Â', 'A', '\u{0302}'),
    ('Ã', 'A', '\u{0303}'), ('Ä', 'A', '\u{0308}'), ('Å', 'A', '\u{030A}'),
    ('Ç', 'C', '\u{0327}'),
    ('È', 'E', '\u{0300}'), ('É', 'E', '\u{0301}'), ('Ê', 'E', '\u{0302}'), ('Ë', 'E', '\u{0308}'),
    ('Ì', 'I', '\u{0300}'), ('Í', 'I', '\u{0301}'), ('Î', 'I', '\u{0302}'), ('Ï', 'I', '\u{0308}'),
    ('Ñ', 'N', '\u{0303}'),
    ('Ò', 'O', '\u{0300}'), ('Ó', 'O', '\u{0301}'), ('Ô', 'O', '\u{0302}'),
    ('Õ', 'O', '\u{0303}'), ('Ö', 'O', '\u{0308}'),
    ('Ù', 'U', '\u{0300}'), ('Ú', 'U', '\u{0301}'), ('Û', 'U', '\u{0302}'), ('Ü', 'U', '\u{0308}'),
    ('Ý', 'Y', '\u{0301}'),
    ('à', 'a', '\u{0300}'), ('á', 'a', '\u{0301}'), ('â', 'a', '\u{0302}'),
    ('ã', 'a', '\u{0303}'), ('ä', 'a', '\u{0308}'), ('å', 'a', '\u{030A}'),
    ('ç', 'c', '\u{0327}'),
    ('è', 'e', '\u{0300}'), ('é', 'e', '\u{0301}'), ('ê', 'e', '\u{0302}'), ('ë', 'e', '\u{0308}'),
    ('ì', 'i', '\u{0300}'), ('í', 'i', '\u{0301}'), ('î', 'i', '\u{0302}'), ('ï', 'i', '\u{0308}'),
    ('ñ', 'n', '\u{0303}'),
    ('ò', 'o', '\u{0300}'), ('ó', 'o', '\u{0301}'), ('ô', 'o', '\u{0302}'),
    ('õ', 'o', '\u{0303}'), ('ö', 'o', '\u{0308}'),
    ('ù', 'u', '\u{0300}'), ('ú', 'u', '\u{0301}'), ('û', 'u', '\u{0302}'), ('ü', 'u', '\u{0308}'),
    ('ý', 'y', '\u{0301}'), ('ÿ', 'y', '\u{0308}'),
];
pub(crate) fn japanese_voiced_sound_decompose(c: char) -> Option<(char, char)> {
    let cp = c as u32;
    match cp {
        0x304C | 0x304E | 0x3050 | 0x3052 | 0x3054 |
        0x3056 | 0x3058 | 0x305A | 0x305C | 0x305E |
        0x3060 | 0x3062 | 0x3065 | 0x3067 | 0x3069 |
        0x3070 | 0x3073 | 0x3076 | 0x3079 | 0x307C |
        0x30AC | 0x30AE | 0x30B0 | 0x30B2 | 0x30B4 |
        0x30B6 | 0x30B8 | 0x30BA | 0x30BC | 0x30BE |
        0x30C0 | 0x30C2 | 0x30C5 | 0x30C7 | 0x30C9 |
        0x30D0 | 0x30D3 | 0x30D6 | 0x30D9 | 0x30DC => {
            char::from_u32(cp - 1).map(|b| (b, '\u{3099}'))
        }
        0x3071 | 0x3074 | 0x3077 | 0x307A | 0x307D |
        0x30D1 | 0x30D4 | 0x30D7 | 0x30DA | 0x30DD => {
            char::from_u32(cp - 2).map(|b| (b, '\u{309A}'))
        }
        0x30F4 => Some(('ウ', '\u{3099}')),
        _ => None,
    }
}

pub(crate) fn japanese_voiced_sound_compose(base: char, mark: char) -> Option<char> {
    if mark != '\u{3099}' && mark != '\u{309A}' && mark != '\u{309B}' && mark != '\u{309C}' {
        return None;
    }
    let b = base as u32;
    let is_dakuten = mark == '\u{3099}' || mark == '\u{309B}';
    let is_handakuten = mark == '\u{309A}' || mark == '\u{309C}';

    match b {
        0x304B | 0x304D | 0x304F | 0x3051 | 0x3053 |
        0x3055 | 0x3057 | 0x3059 | 0x305B | 0x305D |
        0x305F | 0x3061 | 0x3064 | 0x3066 | 0x3068 |
        0x306F | 0x3072 | 0x3075 | 0x3078 | 0x307B |
        0x30AB | 0x30AD | 0x30AF | 0x30B1 | 0x30B3 |
        0x30B5 | 0x30B7 | 0x30B9 | 0x30BB | 0x30BD |
        0x30BF | 0x30C1 | 0x30C4 | 0x30C6 | 0x30C8 |
        0x30CF | 0x30D2 | 0x30D5 | 0x30D8 | 0x30DB if is_dakuten => {
            char::from_u32(b + 1)
        }
        0x306F | 0x3072 | 0x3075 | 0x3078 | 0x307B |
        0x30CF | 0x30D2 | 0x30D5 | 0x30D8 | 0x30DB if is_handakuten => {
            char::from_u32(b + 2)
        }
        0x30A6 if is_dakuten => Some('ヴ'),
        _ => None,
    }
}

pub(crate) fn nfd_decompose(s: &str) -> String {
    const HANGUL_S_BASE: u32 = 0xAC00;
    const HANGUL_L_BASE: u32 = 0x1100;
    const HANGUL_V_BASE: u32 = 0x1161;
    const HANGUL_T_BASE: u32 = 0x11A7;
    const HANGUL_N_COUNT: u32 = 588;
    const HANGUL_T_COUNT: u32 = 28;
    const HANGUL_S_COUNT: u32 = 11172;

    let mut out = String::with_capacity(s.len());
    for c in s.chars() {
        let cp = c as u32;
        if (HANGUL_S_BASE..HANGUL_S_BASE + HANGUL_S_COUNT).contains(&cp) {
            let s_index = cp - HANGUL_S_BASE;
            let l_index = s_index / HANGUL_N_COUNT;
            let v_index = (s_index % HANGUL_N_COUNT) / HANGUL_T_COUNT;
            let t_index = s_index % HANGUL_T_COUNT;
            if let Some(l) = char::from_u32(HANGUL_L_BASE + l_index) {
                out.push(l);
            }
            if let Some(v) = char::from_u32(HANGUL_V_BASE + v_index) {
                out.push(v);
            }
            if t_index > 0 {
                if let Some(t) = char::from_u32(HANGUL_T_BASE + t_index) {
                    out.push(t);
                }
            }
            continue;
        }
        if let Some((base, mark)) = japanese_voiced_sound_decompose(c) {
            out.push(base);
            out.push(mark);
            continue;
        }
        match NFD_TABLE.iter().find(|(pre, _, _)| *pre == c) {
            Some((_, base, mark)) => {
                out.push(*base);
                out.push(*mark);
            }
            None => out.push(c),
        }
    }
    out
}
pub(crate) fn nfc_compose(s: &str) -> String {
    const HANGUL_S_BASE: u32 = 0xAC00;
    const HANGUL_L_BASE: u32 = 0x1100;
    const HANGUL_V_BASE: u32 = 0x1161;
    const HANGUL_T_BASE: u32 = 0x11A7;
    const HANGUL_L_COUNT: u32 = 19;
    const HANGUL_V_COUNT: u32 = 21;
    const HANGUL_T_COUNT: u32 = 28;
    const HANGUL_N_COUNT: u32 = 588;

    let decomposed = nfd_decompose(s);
    let mut out = String::with_capacity(decomposed.len());
    let mut chars = decomposed.chars().peekable();
    while let Some(c) = chars.next() {
        let cp = c as u32;
        if (HANGUL_L_BASE..HANGUL_L_BASE + HANGUL_L_COUNT).contains(&cp) {
            if let Some(&next) = chars.peek() {
                let np = next as u32;
                if (HANGUL_V_BASE..HANGUL_V_BASE + HANGUL_V_COUNT).contains(&np) {
                    chars.next();
                    let l_index = cp - HANGUL_L_BASE;
                    let v_index = np - HANGUL_V_BASE;
                    let mut s_index = l_index * HANGUL_N_COUNT + v_index * HANGUL_T_COUNT;
                    if let Some(&t_next) = chars.peek() {
                        let tp = t_next as u32;
                        if tp > HANGUL_T_BASE && tp < HANGUL_T_BASE + HANGUL_T_COUNT {
                            chars.next();
                            let t_index = tp - HANGUL_T_BASE;
                            s_index += t_index;
                        }
                    }
                    if let Some(hangul) = char::from_u32(HANGUL_S_BASE + s_index) {
                        out.push(hangul);
                        continue;
                    }
                }
            }
        }
        if let Some(&next) = chars.peek() {
            if let Some(composed) = japanese_voiced_sound_compose(c, next) {
                out.push(composed);
                chars.next();
                continue;
            }
            if let Some((pre, _, _)) = NFD_TABLE.iter().find(|(_, base, mark)| *base == c && *mark == next) {
                out.push(*pre);
                chars.next();
                continue;
            }
        }
        out.push(c);
    }
    out
}
pub(crate) fn str_normalize(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let form = if matches!(arg(a, 0), Value::Undefined) {
        String::from("NFC")
    } else {
        arg(a, 0).to_js_string()
    };
    let s = this_str(&t);
    match form.as_str() {
        "NFC" | "NFKC" => Ok(Value::str(nfc_compose(&s))),
        "NFD" | "NFKD" => Ok(Value::str(nfd_decompose(&s))),
        _ => Err(it.error("The normalization form should be one of NFC, NFD, NFKC, NFKD.")),
    }
}
/// `String.prototype.split(separator, limit)`。以前は `limit`（第2引数。結果配列の
/// 最大要素数）を完全に無視しており、`"a,b,c".split(",", 2)` が仕様の `["a","b"]` ではなく
/// 全要素 `["a","b","c"]` を返していた。
pub(crate) fn str_split(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let rx = arg(a, 0);
    if let Value::Object(_) = &rx {
        let matcher = it.get_property(&rx, "Symbol(Symbol.split)")?;
        if !matches!(matcher, Value::Undefined) {
            return it.call_value(&matcher, rx.clone(), &[t, arg(a, 1)]);
        }
    }
    let s = this_str(&t);
    let limit = match arg(a, 1) {
        Value::Undefined => usize::MAX,
        v => {
            let n = v.to_number();
            if n.is_nan() || n < 0.0 {
                usize::MAX
            } else {
                n as usize
            }
        }
    };
    // RegExp 区切り。
    if let Some(r) = as_regexp(&arg(a, 0)) {
        let chars: Vec<char> = s.chars().collect();
        let mut items = Vec::new();
        let mut last = 0usize;
        let mut pos = 0usize;
        'outer: while pos <= chars.len() && items.len() < limit {
            match r.borrow().re.find_at(&chars, pos) {
                Some(m) if m.end > m.start => {
                    items.push(Value::str(chars[last..m.start].iter().collect::<String>()));
                    // 区切りに使った正規表現のキャプチャグループは、仕様上その位置に
                    // 挿入されて結果へ含まれる（未参加のグループは undefined）。以前は
                    // 区切り文字列を単に読み捨てるだけで、キャプチャ内容が結果から
                    // 丸ごと欠落していた（`"a1b".split(/(\d)/)` が
                    // `["a","1","b"]` ではなく `["a","b"]` になっていた）。
                    for cap in m.captures.iter().skip(1) {
                        if items.len() >= limit {
                            break 'outer;
                        }
                        let v = match cap {
                            Some((cs, ce)) => {
                                Value::str(chars[*cs..*ce].iter().collect::<String>())
                            }
                            None => Value::Undefined,
                        };
                        items.push(v);
                    }
                    last = m.end;
                    pos = m.end;
                }
                _ => break,
            }
        }
        if items.len() < limit {
            items.push(Value::str(chars[last..].iter().collect::<String>()));
        }
        items.truncate(limit);
        return Ok(Value::Object(Obj::array(items)));
    }
    let mut items: Vec<Value> = match arg(a, 0) {
        Value::Undefined => vec![Value::str(s)],
        sep => {
            let sep = sep.to_js_string();
            if sep.is_empty() {
                s.chars().map(|c| Value::str(c.to_string())).collect()
            } else {
                s.split(&sep as &str)
                    .map(|p| Value::str(p.to_string()))
                    .collect()
            }
        }
    };
    items.truncate(limit);
    Ok(Value::Object(Obj::array(items)))
}
pub(crate) fn str_replace(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let rx = arg(a, 0);
    if let Value::Object(_) = &rx {
        let matcher = it.get_property(&rx, "Symbol(Symbol.replace)")?;
        if !matches!(matcher, Value::Undefined) {
            return it.call_value(&matcher, rx.clone(), &[t, arg(a, 1)]);
        }
    }
    let s = this_str(&t);
    // RegExp パターン（g フラグで全置換）。
    if let Some(r) = as_regexp(&arg(a, 0)) {
        let global = r.borrow().re.global;
        return Ok(Value::str(regex_replace(it, &s, &r, arg(a, 1), global)?));
    }
    let repl = arg(a, 1);
    let from = arg(a, 0).to_js_string();
    // 関数リプレーサ（文字列パターン、最初の一致）。
    if let Some(f) = callable_or_none(repl.clone()) {
        if let Some(idx) = s.find(&from) {
            let before = s.get(..idx).unwrap_or("");
            let after = s.get(idx + from.len()..).unwrap_or("");
            let rep = it
                .call_value(
                    &f,
                    Value::Undefined,
                    &[
                        Value::str(from.clone()),
                        Value::Number(s.get(..idx).unwrap_or("").chars().count() as f64),
                        Value::str(s.clone()),
                    ],
                )?
                .to_js_string();
            return Ok(Value::str(format!("{}{}{}", before, rep, after)));
        }
        return Ok(Value::str(s));
    }
    let to = repl.to_js_string();
    Ok(Value::str(s.replacen(&from, &to, 1)))
}
/// `String.prototype.replaceAll(pattern, replacement)`。以前は `pattern` が `RegExp`
/// でも常に `to_js_string()`（`"/pat/flags"` という文字列表現）として扱われ、
/// 正規表現として機能していなかった（`"aaa".replaceAll(/a/g, 'b')` が無変換になっていた）。
/// また関数リプレーサ（`str_replace` は対応済み）も未対応だった。
pub(crate) fn str_replace_all(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    // 【順序が重要】仕様では `g` フラグの検査が**先**で、
    // `[Symbol.replace]` への委譲はその後。逆にすると、非 g の RegExp が
    // 委譲側へ流れて TypeError が出なくなる。
    let rx = arg(a, 0);
    if let Some(r) = as_regexp(&rx) {
        if !r.borrow().re.global {
            return Err(it.error(
                "String.prototype.replaceAll called with a non-global RegExp argument",
            ));
        }
    }
    // 独自の `[Symbol.replace]` を持つ相手なら、そちらへ委譲する（仕様）。
    // `replace` は既にこの形で委譲していたが、ここだけ漏れていた。
    if let Value::Object(_) = &rx {
        let matcher = it.get_property(&rx, "Symbol(Symbol.replace)")?;
        if !matches!(matcher, Value::Undefined) {
            return it.call_value(&matcher, rx.clone(), &[t, arg(a, 1)]);
        }
    }
    let s = this_str(&t);
    // RegExp パターン: 仕様上 `g` フラグ必須（無いと TypeError）。
    if let Some(r) = as_regexp(&arg(a, 0)) {
        if !r.borrow().re.global {
            return Err(it.error(
                "String.prototype.replaceAll called with a non-global RegExp argument",
            ));
        }
        return Ok(Value::str(regex_replace(it, &s, &r, arg(a, 1), true)?));
    }
    let from = arg(a, 0).to_js_string();
    let repl = arg(a, 1);
    // 関数リプレーサ（全ての一致箇所に適用）。
    if let Some(f) = callable_or_none(repl.clone()) {
        if from.is_empty() {
            // 空パターンは各文字境界（文字数+1箇所）に挿入される仕様。
            let chars: Vec<char> = s.chars().collect();
            let mut out = String::new();
            for (i, c) in chars.iter().enumerate() {
                let rep = it
                    .call_value(
                        &f,
                        Value::Undefined,
                        &[Value::str(""), Value::Number(i as f64), Value::str(s.clone())],
                    )?
                    .to_js_string();
                out.push_str(&rep);
                out.push(*c);
            }
            let rep = it
                .call_value(
                    &f,
                    Value::Undefined,
                    &[
                        Value::str(""),
                        Value::Number(chars.len() as f64),
                        Value::str(s.clone()),
                    ],
                )?
                .to_js_string();
            out.push_str(&rep);
            return Ok(Value::str(out));
        }
        let mut out = String::new();
        let mut rest = s.as_str();
        let mut consumed = 0usize;
        while let Some(idx) = rest.find(&from) {
            out.push_str(rest.get(..idx).unwrap_or(""));
            let char_pos = s.get(..consumed + idx).unwrap_or("").chars().count();
            let rep = it
                .call_value(
                    &f,
                    Value::Undefined,
                    &[
                        Value::str(from.clone()),
                        Value::Number(char_pos as f64),
                        Value::str(s.clone()),
                    ],
                )?
                .to_js_string();
            out.push_str(&rep);
            consumed += idx + from.len();
            rest = rest.get(idx + from.len()..).unwrap_or("");
        }
        out.push_str(rest);
        return Ok(Value::str(out));
    }
    let to = repl.to_js_string();
    Ok(Value::str(if from.is_empty() {
        s
    } else {
        s.replace(&from, &to)
    }))
}
/// `String.prototype.repeat(count)`（ES2015）。仕様上 `count` が負値または `+Infinity` の
/// 場合は `RangeError` を投げる必要があるが、以前は範囲外を空文字列へ黙って丸めていた
/// （`"x".repeat(-1)` が例外にならず `""` を返す、呼び出し側が引数ミスに気づけないバグ。
/// `Array.prototype.with` の範囲外 `index` と同種の「RangeError 相当箇所で `it.error()` の
/// 汎用 Error を投げる」という既存の簡略方針に合わせる）。
pub(crate) fn str_repeat(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let n = arg(a, 0).to_number();
    if n.is_nan() {
        return Ok(Value::str(String::new()));
    }
    if n < 0.0 || n == f64::INFINITY {
        return Err(it.error("Invalid count value"));
    }
    Ok(Value::str(this_str(&t).repeat(n as usize)))
}
pub(crate) fn str_concat(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let mut s = this_str(&t);
    for v in a {
        s.push_str(&v.to_js_string());
    }
    Ok(Value::str(s))
}
pub(crate) fn str_pad_start(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let target = arg(a, 0).to_number() as usize;
    let pad = if matches!(arg(a, 1), Value::Undefined) {
        String::from(" ")
    } else {
        arg(a, 1).to_js_string()
    };
    Ok(Value::str(pad_str(&s, target, &pad, true)))
}
pub(crate) fn str_pad_end(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let s = this_str(&t);
    let target = arg(a, 0).to_number() as usize;
    let pad = if matches!(arg(a, 1), Value::Undefined) {
        String::from(" ")
    } else {
        arg(a, 1).to_js_string()
    };
    Ok(Value::str(pad_str(&s, target, &pad, false)))
}

/// 数値レシーバのメソッド。
pub fn number_get(n: f64, key: &str) -> Value {
    match key {
        "toFixed" => nv("toFixed", num_to_fixed),
        "toString" => nv("toString", num_to_string),
        "toExponential" => nv("toExponential", num_to_exponential),
        "toPrecision" => nv("toPrecision", num_to_precision),
        "valueOf" => nv("valueOf", num_value_of),
        "toLocaleString" => nv("toLocaleString", num_to_locale_string),
        _ => {
            let _ = n;
            Value::Undefined
        }
    }
}
pub(crate) fn num_value_of(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Number(t.to_number()))
}
/// `Boolean.prototype.toString`/`valueOf`。以前は `Value::Bool` へのプロパティアクセスが
/// `get_property()` で一律 `Value::Undefined` を返しており、`true.toString()`/
/// `false.valueOf()` のような基本的な呼出しが「関数ではない」`TypeError` になっていた
/// （プリミティブ中 `Boolean` だけがメソッドを一切持たない状態だった）。`NativeFn` は環境を
/// 捕獲できない生の関数ポインタのため、値は（他のプリミティブ同様）呼出時の `this` から
/// 読み取る。
pub fn boolean_get(_b: bool, key: &str) -> Value {
    match key {
        "toString" => nv("toString", bool_to_string),
        "valueOf" => nv("valueOf", bool_value_of),
        _ => Value::Undefined,
    }
}
pub(crate) fn bool_to_string(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(t.to_js_string()))
}
pub(crate) fn bool_value_of(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(t)
}
/// 仮数部を `[1,10)` の範囲に正規化した `(仮数, 指数)` を返す（`0` は `(0, 0)`）。
/// 浮動小数点誤差で `log10`/`pow` の往復が範囲をわずかに外れることがあるので補正する。
pub(crate) fn normalize_mantissa(abs_n: f64) -> (f64, i32) {
    if abs_n == 0.0 {
        return (0.0, 0);
    }
    let mut exp = libm::floor(libm::log10(abs_n)) as i32;
    let mut mantissa = abs_n / libm::pow(10.0, exp as f64);
    if mantissa >= 10.0 {
        mantissa /= 10.0;
        exp += 1;
    } else if mantissa < 1.0 {
        mantissa *= 10.0;
        exp -= 1;
    }
    (mantissa, exp)
}
/// `Number.prototype.toExponential(fractionDigits)`（ES3）。丸ごと欠落しており、
/// `n.toExponential(2)`（`"1.50e+2"` 等）を呼ぶと「メソッドが存在しない」`TypeError` に
/// なっていた。
pub(crate) fn num_to_exponential(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let n = t.to_number();
    if n.is_nan() {
        return Ok(Value::str("NaN"));
    }
    if n.is_infinite() {
        return Ok(Value::str(if n > 0.0 { "Infinity" } else { "-Infinity" }));
    }
    let neg = n < 0.0;
    let (mantissa, mut exp) = normalize_mantissa(libm::fabs(n));
    let d = if matches!(arg(a, 0), Value::Undefined) {
        6
    } else {
        let dv = arg(a, 0).to_number();
        if !dv.is_finite() || !(0.0..=100.0).contains(&dv) {
            return Err(it.error("toExponential() argument must be between 0 and 100"));
        }
        dv as usize
    };
    let scale = libm::pow(10.0, d as f64);
    let mut rounded = libm::trunc(mantissa * scale + 0.5) / scale;
    if rounded >= 10.0 {
        rounded /= 10.0;
        exp += 1;
    }
    let mantissa_str = if d == 0 {
        format!("{}", rounded as i64)
    } else {
        format_fixed(rounded, d)
    };
    let sign = if exp >= 0 { "+" } else { "-" };
    Ok(Value::str(format!(
        "{}{}e{}{}",
        if neg { "-" } else { "" },
        mantissa_str,
        sign,
        if exp >= 0 { exp } else { -exp }
    )))
}
/// `Number.prototype.toPrecision(precision)`（ES3）。丸ごと欠落していた。`precision`
/// 省略時は `toString()` と同じ、指定時は有効桁数がその値になるよう固定小数/指数表記を
/// 自動選択する（仕様どおり、指数が `-6` 未満または `precision` 以上なら指数表記）。
pub(crate) fn num_to_precision(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let n = t.to_number();
    if matches!(arg(a, 0), Value::Undefined) {
        return Ok(Value::str(t.to_js_string()));
    }
    if n.is_nan() {
        return Ok(Value::str("NaN"));
    }
    if n.is_infinite() {
        return Ok(Value::str(if n > 0.0 { "Infinity" } else { "-Infinity" }));
    }
    let p = arg(a, 0).to_number();
    if !p.is_finite() || !(1.0..=100.0).contains(&p) {
        return Err(it.error("toPrecision() argument must be between 1 and 100"));
    }
    let p = p as usize;
    if n == 0.0 {
        return Ok(Value::str(if p == 1 {
            String::from("0")
        } else {
            format!("0.{}", "0".repeat(p - 1))
        }));
    }
    let neg = n < 0.0;
    let (_, exp) = normalize_mantissa(libm::fabs(n));
    if (exp as i64) < -6 || (exp as i64) >= p as i64 {
        // 指数表記（有効桁数 p は仮数部の桁数として渡す）。
        return num_to_exponential(it, t, &[Value::Number((p - 1) as f64)]);
    }
    // 固定小数表記: 小数点以下の桁数 = p - 1 - exp。
    let frac_digits = (p as i32 - 1 - exp).max(0) as usize;
    let scale = libm::pow(10.0, frac_digits as f64);
    let rounded = libm::trunc(libm::fabs(n) * scale + 0.5) / scale;
    let s = if frac_digits == 0 {
        format!("{}", rounded as i64)
    } else {
        format_fixed(rounded, frac_digits)
    };
    Ok(Value::str(if neg { format!("-{}", s) } else { s }))
}
/// `Number.prototype.toFixed(fractionDigits)`。仕様上 `fractionDigits` が `0`〜`100`
/// の範囲外（負値や `101` 以上）なら `RangeError` を投げる必要があるが、以前は範囲外/
/// 非有限値を黙って `0` にクランプするだけで上限チェックが無く、`(1).toFixed(500)` の
/// ような呼び出しが `10^500`（`Infinity`）を経由して壊れた出力になり得た
/// （`toPrecision` には同種のチェックが既にあったが `toFixed` だけ欠けていた）。
pub(crate) fn num_to_fixed(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let n = t.to_number();
    if n.is_nan() {
        return Ok(Value::str("NaN"));
    }
    let digits = arg(a, 0).to_number();
    let d = if matches!(arg(a, 0), Value::Undefined) {
        0
    } else if !digits.is_finite() || !(0.0..=100.0).contains(&digits) {
        return Err(it.error("toFixed() digits argument must be between 0 and 100"));
    } else {
        digits as usize
    };
    if n.is_infinite() {
        return Ok(Value::str(if n > 0.0 { "Infinity" } else { "-Infinity" }));
    }
    // 簡易固定小数: 10^d でスケールして丸め。
    let scale = libm::pow(10.0, d as f64);
    let rounded = libm::trunc(n * scale + if n >= 0.0 { 0.5 } else { -0.5 }) / scale;
    if d == 0 {
        Ok(Value::str(format!("{}", rounded as i64)))
    } else {
        Ok(Value::str(format_fixed(rounded, d)))
    }
}
/// `Number.prototype.toString(radix)`。以前は `radix`（第1引数。2進/16進表示等の定番
/// イディオム `n.toString(16)`）を完全に無視し常に10進表示だった。
pub(crate) fn num_to_string(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let radix = match arg(a, 0) {
        Value::Undefined => 10u32,
        v => v.to_number() as u32,
    };
    if radix == 10 {
        return Ok(Value::str(t.to_js_string()));
    }
    if !(2..=36).contains(&radix) {
        return Err(it.error("toString() radix must be between 2 and 36"));
    }
    Ok(Value::str(format_radix(t.to_number(), radix)))
}
/// `Number.prototype.toLocaleString()` が `toString()` の別名に過ぎず、実際のブラウザなら
/// `Intl` 非搭載でも必ず入る3桁区切りのカンマ（`(1234567).toLocaleString()` → `"1,234,567"`）
/// が丸ごと欠落していた（常に `"1234567"` になっていた）バグ。`Intl`/ロケール引数自体は
/// 非対応（`Array.prototype.toLocaleString`/`normalize`/`localeCompare` と同種の割り切り）
/// だが、既定のグループ区切り（整数部のみ、小数部・NaN・Infinity・負号は対象外）だけは行う。
pub(crate) fn num_to_locale_string(_it: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    let n = t.to_number();
    if !n.is_finite() {
        return Ok(Value::str(t.to_js_string()));
    }
    let s = t.to_js_string();
    let (neg, s) = match s.strip_prefix('-') {
        Some(rest) => (true, rest),
        None => (false, s.as_str()),
    };
    let (int_part, frac_part) = match s.split_once('.') {
        Some((i, f)) => (i, Some(f)),
        None => (s, None),
    };
    let mut grouped = String::new();
    let len = int_part.len();
    for (i, c) in int_part.chars().enumerate() {
        if i > 0 && (len - i) % 3 == 0 {
            grouped.push(',');
        }
        grouped.push(c);
    }
    let mut out = String::new();
    if neg {
        out.push('-');
    }
    out.push_str(&grouped);
    if let Some(f) = frac_part {
        out.push('.');
        out.push_str(f);
    }
    Ok(Value::str(out))
}
/// `new Intl.NumberFormat(locale?, options?)`。ロケール/オプション引数は無視し、
/// `.format(n)` は `Number.prototype.toLocaleString` と同じ既定グループ区切りに
/// 委譲する最小実装（`Intl` 節参照）。
pub(crate) fn intl_number_format_ctor(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let obj = Obj::plain();
    obj.borrow_mut()
        .props
        .insert("format".into(), nv("format", intl_number_format_format));
    Ok(Value::Object(obj))
}
pub(crate) fn intl_number_format_format(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    num_to_locale_string(it, arg(a, 0), &[])
}
pub(crate) const RADIX_DIGITS: &[u8] = b"0123456789abcdefghijklmnopqrstuvwxyz";
pub(crate) fn format_radix(num: f64, radix: u32) -> String {
    if num.is_nan() {
        return String::from("NaN");
    }
    if num.is_infinite() {
        return String::from(if num > 0.0 { "Infinity" } else { "-Infinity" });
    }
    let neg = num < 0.0;
    let n = libm::fabs(num);
    let int_n = libm::floor(n);
    let mut frac = n - int_n;
    let mut int_digits = Vec::new();
    let mut i = int_n;
    if i == 0.0 {
        int_digits.push(b'0');
    }
    while i >= 1.0 {
        let rem = libm::fmod(i, radix as f64) as usize;
        int_digits.push(RADIX_DIGITS[rem.min(35)]);
        i = libm::floor(i / radix as f64);
    }
    int_digits.reverse();
    let mut s = String::from_utf8(int_digits).unwrap_or_default();
    if frac > 0.0 {
        s.push('.');
        let mut count = 0;
        while frac > 0.0 && count < 20 {
            frac *= radix as f64;
            let d = libm::floor(frac) as usize;
            s.push(RADIX_DIGITS[d.min(35)] as char);
            frac -= libm::floor(frac);
            count += 1;
        }
    }
    if neg {
        format!("-{}", s)
    } else {
        s
    }
}

/// BigInt レシーバのメソッド（toString / valueOf）。
pub fn bigint_get(b: &alloc::rc::Rc<super::super::bigint::BigInt>, key: &str) -> Value {
    match key {
        "toString" => nv("toString", bigint_to_string),
        "valueOf" => nv("valueOf", bigint_value_of),
        _ => {
            let _ = b;
            Value::Undefined
        }
    }
}
pub(crate) fn bigint_to_string(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(t.to_js_string()))
}
pub(crate) fn bigint_value_of(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(t)
}

/// BigInt(value): Number / String / Boolean / BigInt から BigInt を生成する。
/// `new BigInt()` は不可だが、ここでは関数呼び出しのみ対応。
pub(crate) fn bigint_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    use super::super::bigint::BigInt;
    let arg = a.first().cloned().unwrap_or(Value::Undefined);
    let bi = match &arg {
        Value::BigInt(b) => (**b).clone(),
        Value::Number(n) => match BigInt::from_f64(*n) {
            Some(v) => v,
            None => {
                return Err(it.error("The number is not a safe integer / cannot convert to BigInt"));
            }
        },
        Value::Bool(b) => BigInt::from_i64(if *b { 1 } else { 0 }),
        Value::Str(s) => match BigInt::parse_str(s) {
            Some(v) => v,
            None => return Err(it.error("Cannot convert string to a BigInt")),
        },
        _ => return Err(it.error("Cannot convert value to a BigInt")),
    };
    Ok(Value::bigint(bi))
}

/// 引数から「ビット幅」を取り出す（非負整数へ丸め）。
pub(crate) fn bits_arg(it: &mut Interp, a: &[Value]) -> Result<u64, Value> {
    let n = a.first().map(|v| v.to_number()).unwrap_or(f64::NAN);
    if !n.is_finite() || n < 0.0 {
        return Err(it.error("Invalid bits value for BigInt.asIntN/asUintN"));
    }
    Ok(libm::trunc(n) as u64)
}

/// 引数2を BigInt として取り出す。
pub(crate) fn bigint_arg(it: &mut Interp, a: &[Value]) -> Result<super::super::bigint::BigInt, Value> {
    match a.get(1) {
        Some(Value::BigInt(b)) => Ok((**b).clone()),
        _ => Err(it.error("BigInt.asIntN/asUintN requires a BigInt as the second argument")),
    }
}

/// BigInt.asIntN(bits, bigint)
pub(crate) fn bigint_as_int_n(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let bits = bits_arg(it, a)?;
    let v = bigint_arg(it, a)?;
    Ok(Value::bigint(v.as_int_n(bits)))
}

/// BigInt.asUintN(bits, bigint)
pub(crate) fn bigint_as_uint_n(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let bits = bits_arg(it, a)?;
    let v = bigint_arg(it, a)?;
    Ok(Value::bigint(v.as_uint_n(bits)))
}

// ============ オブジェクト/配列メソッド ============

/// オブジェクトレシーバのメソッド（配列メソッド含む）。
pub fn object_get(o: &ObjRef, key: &str) -> Value {
    let is_array = matches!(o.borrow().kind, ObjKind::Array(_) | ObjKind::Bytes(_));
    if is_array {
        match key {
            "push" => return nv("push", arr_push),
            "pop" => return nv("pop", arr_pop),
            "shift" => return nv("shift", arr_shift),
            "unshift" => return nv("unshift", arr_unshift),
            "slice" => return nv("slice", arr_slice),
            "indexOf" => return nv("indexOf", arr_index_of),
            "includes" => return nv("includes", arr_includes),
            "join" => return nv("join", arr_join),
            "concat" => return nv("concat", arr_concat),
            "reverse" => return nv("reverse", arr_reverse),
            "map" => return nv("map", arr_map),
            "filter" => return nv("filter", arr_filter),
            "forEach" => return nv("forEach", arr_for_each),
            "reduce" => return nv("reduce", arr_reduce),
            "find" => return nv("find", arr_find),
            "findIndex" => return nv("findIndex", arr_find_index),
            "some" => return nv("some", arr_some),
            "every" => return nv("every", arr_every),
            "sort" => return nv("sort", arr_sort),
            "fill" => return nv("fill", arr_fill),
            "flat" => return nv("flat", arr_flat),
            "flatMap" => return nv("flatMap", arr_flat_map),
            "at" => return nv("at", arr_at),
            "findLast" => return nv("findLast", arr_find_last),
            "findLastIndex" => return nv("findLastIndex", arr_find_last_index),
            "entries" => return nv("entries", arr_entries),
            "keys" => return nv("keys", arr_keys),
            "values" => return nv("values", arr_values),
            // `Array.prototype[Symbol.iterator]` は仕様上 `values` の別名。`for...of` は
            // 内部の高速経路（`iterate_values()`）で配列を直接回すため気づかれなかったが、
            // `arr[Symbol.iterator]()` を明示的に呼ぶ（手動イテレータ駆動、
            // `yield* arr[Symbol.iterator]()` 等）パターンは未登録のため
            // `undefined is not a function` になっていた。
            "Symbol(Symbol.iterator)" => return nv("[Symbol.iterator]", arr_values),
            "reduceRight" => return nv("reduceRight", arr_reduce_right),
            "toString" => return nv("toString", arr_to_string),
            "toLocaleString" => return nv("toLocaleString", arr_to_locale_string),
            "splice" => return nv("splice", arr_splice),
            "lastIndexOf" => return nv("lastIndexOf", arr_last_index_of),
            "copyWithin" => return nv("copyWithin", arr_copy_within),
            "toSorted" => return nv("toSorted", arr_to_sorted),
            "toReversed" => return nv("toReversed", arr_to_reversed),
            "toSpliced" => return nv("toSpliced", arr_to_spliced),
            "with" => return nv("with", arr_with),
            _ => {}
        }
    }
    // 共通オブジェクトメソッド。仕様上 `Object.prototype` は5個の own メソッド
    // （`hasOwnProperty`/`isPrototypeOf`/`propertyIsEnumerable`/`toString`/
    // `toLocaleString`）を持つが、`toLocaleString` だけ丸ごと欠けていた
    // （既定の `Object.prototype.toLocaleString` は単に `this.toString()` を
    // 呼ぶだけなので `obj_to_string` を再利用する）。`Array.prototype.toLocaleString`
    // は各要素の `toLocaleString` を呼ぼうとするため、この欠落は素のオブジェクトを
    // 要素に持つ配列の `toLocaleString()` にも波及していた。
    match key {
        "hasOwnProperty" => nv("hasOwnProperty", obj_has_own),
        "toString" | "toLocaleString" => nv("toString", obj_to_string),
        "isPrototypeOf" => nv("isPrototypeOf", obj_is_prototype_of),
        "propertyIsEnumerable" => nv("propertyIsEnumerable", obj_property_is_enumerable),
        // `__defineGetter__`/`__defineSetter__`/`__lookupGetter__`/
        // `__lookupSetter__`（Annex B.3.1。`Object.defineProperty`/
        // `getOwnPropertyDescriptor` 登場以前からの遺産だが、古いコードや
        // ポリフィルで今も使われる）が丸ごと未対応だった。
        "__defineGetter__" => nv("__defineGetter__", obj_define_getter),
        "__defineSetter__" => nv("__defineSetter__", obj_define_setter),
        "__lookupGetter__" => nv("__lookupGetter__", obj_lookup_getter),
        "__lookupSetter__" => nv("__lookupSetter__", obj_lookup_setter),
        _ => Value::Undefined,
    }
}
pub(crate) fn obj_define_getter(_: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        use super::super::value::Accessor;
        let key = arg(a, 0).to_js_string();
        let mut b = o.borrow_mut();
        let entry = b.accessors.entry(key).or_insert(Accessor { get: None, set: None });
        entry.get = Some(arg(a, 1));
    }
    Ok(Value::Undefined)
}
pub(crate) fn obj_define_setter(_: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        use super::super::value::Accessor;
        let key = arg(a, 0).to_js_string();
        let mut b = o.borrow_mut();
        let entry = b.accessors.entry(key).or_insert(Accessor { get: None, set: None });
        entry.set = Some(arg(a, 1));
    }
    Ok(Value::Undefined)
}
pub(crate) fn obj_lookup_getter(_: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let key = arg(a, 0).to_js_string();
        if let Some(g) = o.borrow().accessors.get(&key).and_then(|acc| acc.get.clone()) {
            return Ok(g);
        }
    }
    Ok(Value::Undefined)
}
pub(crate) fn obj_lookup_setter(_: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let key = arg(a, 0).to_js_string();
        if let Some(s) = o.borrow().accessors.get(&key).and_then(|acc| acc.set.clone()) {
            return Ok(s);
        }
    }
    Ok(Value::Undefined)
}

/// 配列プロトタイプメソッドのほぼ全てがこのヘルパ経由で `this` の要素を読む。以前は
/// `Proxy` を素通しできず（`ObjKind::Array` に一致しない）、`Array.prototype.map.call(
/// new Proxy([1,2,3],{}), f)` のように Proxy をラップした配列へ直接メソッド呼出しすると
/// 常に空配列扱いになるバグだった（`for...of`/スプレッドは別経路で既に対応済みだったが、
/// メソッド呼出し経由はこのヘルパ止まりで漏れていた）。
pub(crate) fn this_items(this: &Value) -> Vec<Value> {
    if let Value::Object(o) = this {
        let o = unwrap_proxy_target(o);
        let b = o.borrow();
        if let ObjKind::Array(items) = &b.kind {
            return items.clone();
        }
        if let ObjKind::Bytes(st) = &b.kind {
            return st.values();
        }
    }
    Vec::new()
}
/// `this_items` と同じ Proxy 透過性が必要（配列を直接変更するメソッド
/// push/pop/sort/splice 等が内部で使う実オブジェクト参照）。
pub(crate) fn this_objref(this: &Value) -> Option<ObjRef> {
    if let Value::Object(o) = this {
        Some(unwrap_proxy_target(o))
    } else {
        None
    }
}

/// `this` の `length` を読む（array-like 汎用経路用。`array_like_items` と同じ丸め）。
pub(crate) fn array_like_length(it: &mut Interp, t: &Value) -> usize {
    let len = it
        .get_property(t, "length")
        .map(|l| l.to_number())
        .unwrap_or(0.0);
    if len.is_finite() && len > 0.0 {
        len as usize
    } else {
        0
    }
}

/// `push`/`pop`/`shift`/`unshift` は仕様上ジェネリックメソッドで、`length` +
/// 添字プロパティを持つだけの非配列 array-like オブジェクトへの `.call()` でも
/// 機能すべきだが、以前は `this_objref` で得た `ObjRef` が `ObjKind::Array` で
/// なければ何もせず `0`/`undefined` を返す静かな破壊バグだった（`slice`/`join`
/// 等の読み取り専用メソッドで修正済みの同型バグの、書き込み系での見落とし）。
/// 実配列は高速パス（`Vec` 直接操作）、それ以外は `length`+添字プロパティの
/// 読み書きにフォールバックする。
pub(crate) fn arr_push(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(o) = this_objref(&t) {
        if let ObjKind::Array(items) = &mut o.borrow_mut().kind {
            for v in a {
                items.push(v.clone());
            }
            return Ok(Value::Number(items.len() as f64));
        }
    }
    let mut len = array_like_length(it, &t);
    for v in a {
        it.set_property(&t, &len.to_string(), v.clone());
        len += 1;
    }
    it.set_property(&t, "length", Value::Number(len as f64));
    Ok(Value::Number(len as f64))
}
pub(crate) fn arr_pop(it: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(o) = this_objref(&t) {
        if let ObjKind::Array(items) = &mut o.borrow_mut().kind {
            return Ok(items.pop().unwrap_or(Value::Undefined));
        }
    }
    let len = array_like_length(it, &t);
    if len == 0 {
        it.set_property(&t, "length", Value::Number(0.0));
        return Ok(Value::Undefined);
    }
    let new_len = len - 1;
    let val = it
        .get_property(&t, &new_len.to_string())
        .unwrap_or(Value::Undefined);
    it.set_property(&t, "length", Value::Number(new_len as f64));
    Ok(val)
}
pub(crate) fn arr_shift(it: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(o) = this_objref(&t) {
        drop_holes(&o);
        if let ObjKind::Array(items) = &mut o.borrow_mut().kind {
            if items.is_empty() {
                return Ok(Value::Undefined);
            }
            return Ok(items.remove(0));
        }
    }
    let len = array_like_length(it, &t);
    if len == 0 {
        it.set_property(&t, "length", Value::Number(0.0));
        return Ok(Value::Undefined);
    }
    let first = it.get_property(&t, "0").unwrap_or(Value::Undefined);
    for i in 1..len {
        let v = it.get_property(&t, &i.to_string()).unwrap_or(Value::Undefined);
        it.set_property(&t, &(i - 1).to_string(), v);
    }
    it.set_property(&t, "length", Value::Number((len - 1) as f64));
    Ok(first)
}
pub(crate) fn arr_unshift(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(o) = this_objref(&t) {
        drop_holes(&o);
        if let ObjKind::Array(items) = &mut o.borrow_mut().kind {
            for (i, v) in a.iter().enumerate() {
                items.insert(i, v.clone());
            }
            return Ok(Value::Number(items.len() as f64));
        }
    }
    let len = array_like_length(it, &t);
    let shift = a.len();
    // 既存要素を後ろへ retreat させてから新規要素を先頭に書き込む（末尾から
    // 埋めることで、まだ読んでいない添字を上書きしてしまう事故を避ける）。
    for i in (0..len).rev() {
        let v = it.get_property(&t, &i.to_string()).unwrap_or(Value::Undefined);
        it.set_property(&t, &(i + shift).to_string(), v);
    }
    for (i, v) in a.iter().enumerate() {
        it.set_property(&t, &i.to_string(), v.clone());
    }
    let new_len = len + shift;
    it.set_property(&t, "length", Value::Number(new_len as f64));
    Ok(Value::Number(new_len as f64))
}
/// `Array.prototype.slice` は仕様上ジェネリックメソッドだが、以前は `this_items`
/// （`ObjKind::Array` 以外は無条件で空 `Vec`）を直接使っていたため、
/// `[].slice.call(arrayLikeObj, ...)` のような array-like への適用が常に `[]` を
/// 返す静かな破壊バグだった（`join`/`concat` で修正済みの同型バグ）。
pub(crate) fn arr_slice(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let is_array = matches!(&t, Value::Object(o) if matches!(o.borrow().kind, ObjKind::Array(_)));
    let items = if is_array {
        this_items(&t)
    } else {
        array_like_items(it, &t)
    };
    let len = items.len() as i64;
    let start = norm_index(arg(a, 0).to_number(), len, 0).max(0) as usize;
    let end = if matches!(arg(a, 1), Value::Undefined) {
        len
    } else {
        norm_index(arg(a, 1).to_number(), len, len)
    }
    .max(0) as usize;
    let out = if start < end && start < items.len() {
        items[start..end.min(items.len())].to_vec()
    } else {
        Vec::new()
    };
    if is_typed_array(&t) {
        return Ok(same_kind_as(it, &t, out));
    }
    let a_obj = array_species_create(it, &t, out.len())?;
    populate_array_species(it, &a_obj, out)
}
/// `fromIndex`（第2引数）を正規化する。負の値は末尾からのオフセット、範囲外は
/// `len`（＝以降の探索が即座に空になる）に丸める（`indexOf`/`includes` 共通）。
pub(crate) fn arr_from_index(a: &[Value], len: usize) -> usize {
    if matches!(arg(a, 1), Value::Undefined) {
        return 0;
    }
    let n = arg(a, 1).to_number();
    if n.is_nan() {
        return 0;
    }
    let len = len as i64;
    let idx = if n < 0.0 { (len + n as i64).max(0) } else { n as i64 };
    idx.min(len) as usize
}
/// `Array.prototype.indexOf(searchElement, fromIndex)`。以前は `fromIndex`
/// （第2引数）を完全に無視し、常に先頭から探索していた。
/// `indexOf`/`includes`/`forEach`/`map`/`filter` 等は仕様上ジェネリックメソッドだが、
/// 以前は `this_items` を直接使っていたため array-like への `.call()` が常に
/// 「何も見つからない/反復しない」結果になる同型のバグが複数箇所にあった
/// （`join`/`slice`/`concat`/`forEach` で修正済みの続き）。
pub(crate) fn arr_index_of(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let target = arg(a, 0);
    let from = arr_from_index(a, items.len());
    let holes = holes_of(&t);
    for (i, v) in items.iter().enumerate().skip(from) {
        if !is_hole_at(&holes, i) && v.strict_eq(&target) {
            return Ok(Value::Number(i as f64));
        }
    }
    Ok(Value::Number(-1.0))
}
/// `Array.prototype.includes` は仕様上 SameValueZero で比較する必要がある
/// （`===` と違って `NaN` 同士は等しいと判定される）。以前は `strict_eq`（`===`）を
/// 使っており、`[NaN].includes(NaN)` が `false` になるバグだった（`indexOf` が `===` を
/// 使うのは仕様どおり正しいので、そちらは変更していない）。
pub(crate) fn arr_includes(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let target = arg(a, 0);
    let from = arr_from_index(a, items.len());
    Ok(Value::Bool(
        items.iter().skip(from).any(|v| same_value_zero(v, &target)),
    ))
}
/// `Array.prototype.join` は仕様上ジェネリックメソッド（`this` の内部 `[[Class]]` を
/// 見ず `length` + 添字プロパティだけを見る）だが、以前は `this_items`（`ObjKind::Array`
/// 以外は無条件で空 `Vec`）を直接使っていたため、
/// `Array.prototype.join.call({0:'a',1:'b',length:2}, '-')` のような array-like への
/// 適用が常に `""` を返す静かな破壊バグだった。
pub(crate) fn arr_join(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let is_array = matches!(&t, Value::Object(o) if matches!(o.borrow().kind, ObjKind::Array(_)));
    let items = if is_array {
        this_items(&t)
    } else {
        array_like_items(it, &t)
    };
    let sep = if matches!(arg(a, 0), Value::Undefined) {
        String::from(",")
    } else {
        arg(a, 0).to_js_string()
    };
    let parts: Vec<String> = items
        .iter()
        .map(|v| match v {
            Value::Undefined | Value::Null => String::new(),
            _ => v.to_js_string(),
        })
        .collect();
    Ok(Value::str(parts.join(&sep)))
}
/// `this` が実配列（`ObjKind::Array`）かどうか。`join`/`slice`/`concat` に続き、
/// `forEach`/`map`/`filter`/`indexOf`/`includes` 等の仕様上ジェネリックなメソッドで
/// `this_items`（非配列は無条件で空 `Vec`）から `array_like_items`
/// （`length`+添字プロパティを読む汎用フォールバック）への切り替え判定に使う共通ヘルパ。
pub(crate) fn is_real_array(t: &Value) -> bool {
    matches!(t, Value::Object(o) if matches!(o.borrow().kind, ObjKind::Array(_)))
}
/// `this_items` と `array_like_items` を上記の判定で使い分ける便宜関数。
/// `t` が配列なら穴の一覧（穴が無ければ空）。反復系のメソッドは穴を飛ばす。
pub(crate) fn holes_of(t: &Value) -> Vec<bool> {
    match t {
        Value::Object(o) => o.borrow().hole_mask(),
        _ => Vec::new(),
    }
}
fn is_hole_at(holes: &[bool], i: usize) -> bool {
    holes.get(i).copied().unwrap_or(false)
}
/// 配列 `v` に穴の印を付ける（穴が 1 つも無ければ付けない）。
pub(crate) fn set_holes(v: &Value, mask: Vec<bool>) {
    if let Value::Object(o) = v {
        let mut b = o.borrow_mut();
        if matches!(b.kind, ObjKind::Array(_)) {
            b.holes = if mask.iter().any(|&h| h) { Some(alloc::boxed::Box::new(mask)) } else { None };
        }
    }
}
/// 添字がずれる操作の前に穴の印を捨てる。
fn drop_holes(o: &ObjRef) {
    o.borrow_mut().holes = None;
}
pub(crate) fn generic_array_items(it: &mut Interp, t: &Value) -> Vec<Value> {
    if is_real_array(t) {
        this_items(t)
    } else {
        array_like_items(it, t)
    }
}
/// 配列でない array-like オブジェクト（`length` + 添字プロパティ）を `Vec<Value>` に
/// 展開する。`Array.prototype.concat` が `Symbol.isConcatSpreadable` で true を明示した
/// 非配列オブジェクトを展開する際に使う。
pub(crate) fn array_like_items(it: &mut Interp, v: &Value) -> Vec<Value> {
    let len = it
        .get_property(v, "length")
        .map(|l| l.to_number())
        .unwrap_or(0.0);
    let len = if len.is_finite() && len > 0.0 { len as usize } else { 0 };
    let mut out = Vec::with_capacity(len);
    for i in 0..len {
        out.push(
            it.get_property(v, &i.to_string())
                .unwrap_or(Value::Undefined),
        );
    }
    out
}

/// `Array.prototype.concat` は仕様上 `Symbol.isConcatSpreadable` を尊重すべきだが、
/// 以前は単に `ObjKind::Array` かどうかだけで展開の有無を決めており、
/// `arr[Symbol.isConcatSpreadable] = false` な配列も無条件に展開され、逆に
/// `Symbol.isConcatSpreadable = true` を明示した非配列 array-like オブジェクトは
/// 展開されず単一要素として push されてしまっていた。
/// `concat` の各オペランド（`this` 含む）を isConcatSpreadable 判定に従って
/// `items` に展開/push する共通ロジック。以前は `this`（第一引数の呼び出し対象）
/// にはこのロジックが適用されておらず `this_items` を直接使っていたため、
/// `[].concat.call(arrayLikeObj, x)` のような非配列 `this` が結果から丸ごと
/// 消えてしまう（本来は spreadable でなければ `this` 自体が単一要素として
/// 含まれるべき）静かな破壊バグだった。
pub(crate) fn concat_push(it: &mut Interp, v: &Value, items: &mut Vec<Value>) -> Result<(), Value> {
    match v {
        Value::Object(o) => {
            let flag = it.get_property(v, "Symbol(Symbol.isConcatSpreadable)")?;
            let is_array = matches!(o.borrow().kind, ObjKind::Array(_));
            let spreadable = if matches!(flag, Value::Undefined) {
                is_array
            } else {
                flag.truthy()
            };
            if !spreadable {
                items.push(v.clone());
            } else if is_array {
                if let ObjKind::Array(other) = &o.borrow().kind {
                    items.extend(other.clone());
                }
            } else {
                items.extend(array_like_items(it, v));
            }
        }
        other => items.push(other.clone()),
    }
    Ok(())
}
pub(crate) fn arr_concat(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let mut items = Vec::new();
    let mut mask: Vec<bool> = Vec::new();
    for v in core::iter::once(&t).chain(a.iter()) {
        let before = items.len();
        concat_push(it, v, &mut items)?;
        let added = items.len() - before;
        let h = holes_of(v);
        mask.extend((0..added).map(|i| added == h.len() && is_hole_at(&h, i)));
    }
    let a_obj = array_species_create(it, &t, 0)?;
    let r = populate_array_species(it, &a_obj, items)?;
    set_holes(&r, mask);
    Ok(r)
}
pub(crate) fn arr_reverse(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(o) = this_objref(&t) {
        drop_holes(&o);
        if let ObjKind::Array(items) = &mut o.borrow_mut().kind {
            items.reverse();
        }
    }
    Ok(t)
}
pub(crate) fn arr_to_string(_: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::str(t.to_js_string()))
}
/// `Array.prototype.toLocaleString()`（ES3）が丸ごと欠落していた。各要素の
/// `toLocaleString()` を呼び出し `,` で連結する（`Intl` 非搭載のためロケール依存の書式化は
/// 行わず、要素が `toLocaleString` を持たなければ通常の文字列化にフォールバックする簡略実装。
/// `Date.prototype.toLocaleString` 等、要素側の実装があればそちらが優先される）。
pub(crate) fn arr_to_locale_string(it: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let mut parts = Vec::with_capacity(items.len());
    for v in items {
        if matches!(v, Value::Undefined | Value::Null) {
            parts.push(String::new());
            continue;
        }
        let method = it.get_property(&v, "toLocaleString").unwrap_or(Value::Undefined);
        let s = if matches!(&method, Value::Object(f) if f.borrow().is_callable()) {
            it.call_value(&method, v.clone(), &[])?.to_js_string()
        } else {
            v.to_js_string()
        };
        parts.push(s);
    }
    Ok(Value::str(parts.join(",")))
}
/// 高階配列メソッドのコールバックは第2引数 `thisArg` を受け付ける（`map`/`filter`/
/// `forEach`/`find` 系すべてに共通の仕様だが、以前はどれも `Value::Undefined` を
/// 決め打ちしており `thisArg` が完全に無視されていた）。
pub(crate) fn arr_map(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let f = arg(a, 0);
    let this_arg = arg(a, 1);
    let holes = holes_of(&t);
    let mut out = Vec::with_capacity(items.len());
    for (i, v) in items.iter().enumerate() {
        if is_hole_at(&holes, i) {
            out.push(Value::Undefined);
            continue;
        }
        let r = it.call_value(
            &f,
            this_arg.clone(),
            &[v.clone(), Value::Number(i as f64), t.clone()],
        )?;
        out.push(r);
    }
    if is_typed_array(&t) {
        return Ok(same_kind_as(it, &t, out));
    }
    let a_obj = array_species_create(it, &t, items.len())?;
    let r = populate_array_species(it, &a_obj, out)?;
    set_holes(&r, holes);
    Ok(r)
}
pub(crate) fn arr_filter(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let f = arg(a, 0);
    let this_arg = arg(a, 1);
    let mut out = Vec::new();
    let holes = holes_of(&t);
    for (i, v) in items.iter().enumerate() {
        if is_hole_at(&holes, i) {
            continue;
        }
        if it
            .call_value(
                &f,
                this_arg.clone(),
                &[v.clone(), Value::Number(i as f64), t.clone()],
            )?
            .truthy()
        {
            out.push(v.clone());
        }
    }
    if is_typed_array(&t) {
        return Ok(same_kind_as(it, &t, out));
    }
    let a_obj = array_species_create(it, &t, 0)?;
    populate_array_species(it, &a_obj, out)
}
/// `Array.prototype.forEach` は仕様上ジェネリックメソッドだが、以前は `this_items`
/// （`ObjKind::Array` 以外は無条件で空 `Vec`）を直接使っていたため、`.call(arrayLikeObj,
/// fn)`（`arguments`/`NodeList` 等への定番イディオム）が何も反復しない静かな破壊
/// バグだった（`join`/`slice`/`concat` で修正済みの同型バグ）。
pub(crate) fn arr_for_each(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let f = arg(a, 0);
    let this_arg = arg(a, 1);
    let holes = holes_of(&t);
    for (i, v) in items.iter().enumerate() {
        if is_hole_at(&holes, i) {
            continue;
        }
        it.call_value(
            &f,
            this_arg.clone(),
            &[v.clone(), Value::Number(i as f64), t.clone()],
        )?;
    }
    Ok(Value::Undefined)
}
/// `reduce`/`find`/`findIndex`/`some`/`every` にも `forEach`/`map`/`filter`/`indexOf`/
/// `includes` と同型のジェネリックメソッド未対応バグがあった（`this_items` を直接
/// 使っており array-like への `.call()` が常に「何もしない/見つからない」になっていた）。
pub(crate) fn arr_reduce(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let f = arg(a, 0);
    let holes = holes_of(&t);
    let mut idx = 0;
    let mut acc = if a.len() >= 2 {
        arg(a, 1)
    } else {
        while is_hole_at(&holes, idx) {
            idx += 1;
        }
        if idx >= items.len() {
            return Err(it.error("Reduce of empty array with no initial value"));
        }
        idx += 1;
        items[idx - 1].clone()
    };
    while idx < items.len() {
        if is_hole_at(&holes, idx) {
            idx += 1;
            continue;
        }
        acc = it.call_value(
            &f,
            Value::Undefined,
            &[
                acc,
                items[idx].clone(),
                Value::Number(idx as f64),
                t.clone(),
            ],
        )?;
        idx += 1;
    }
    Ok(acc)
}
pub(crate) fn arr_find(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let f = arg(a, 0);
    let this_arg = arg(a, 1);
    for (i, v) in items.iter().enumerate() {
        if it
            .call_value(
                &f,
                this_arg.clone(),
                &[v.clone(), Value::Number(i as f64), t.clone()],
            )?
            .truthy()
        {
            return Ok(v.clone());
        }
    }
    Ok(Value::Undefined)
}
pub(crate) fn arr_find_index(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let f = arg(a, 0);
    let this_arg = arg(a, 1);
    for (i, v) in items.iter().enumerate() {
        if it
            .call_value(
                &f,
                this_arg.clone(),
                &[v.clone(), Value::Number(i as f64), t.clone()],
            )?
            .truthy()
        {
            return Ok(Value::Number(i as f64));
        }
    }
    Ok(Value::Number(-1.0))
}
pub(crate) fn arr_some(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let f = arg(a, 0);
    let this_arg = arg(a, 1);
    let holes = holes_of(&t);
    for (i, v) in items.iter().enumerate() {
        if is_hole_at(&holes, i) {
            continue;
        }
        if it
            .call_value(
                &f,
                this_arg.clone(),
                &[v.clone(), Value::Number(i as f64), t.clone()],
            )?
            .truthy()
        {
            return Ok(Value::Bool(true));
        }
    }
    Ok(Value::Bool(false))
}
pub(crate) fn arr_every(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let f = arg(a, 0);
    let this_arg = arg(a, 1);
    let holes = holes_of(&t);
    for (i, v) in items.iter().enumerate() {
        if is_hole_at(&holes, i) {
            continue;
        }
        if !it
            .call_value(
                &f,
                this_arg.clone(),
                &[v.clone(), Value::Number(i as f64), t.clone()],
            )?
            .truthy()
        {
            return Ok(Value::Bool(false));
        }
    }
    Ok(Value::Bool(true))
}
/// 仕様上 `sort`/`toSorted` は `undefined` 要素を比較関数に一切渡さず、常に配列末尾に
/// 送る特別扱いが必要(ECMA-262 `SortCompare`)。以前はこの特別扱いが無く `undefined` も
/// 通常の要素として文字列比較/比較関数に渡していたため、例えば
/// `[undefined, 5].sort((a,b)=>a-b)` は `a-b` が `NaN` になり順序が保証されない
/// (常に末尾に来るはずが来ない)バグがあった。
pub(crate) fn sort_excluding_undefined(
    it: &mut Interp,
    mut items: alloc::vec::Vec<Value>,
    cmp: &Value,
) -> Result<alloc::vec::Vec<Value>, Value> {
    // 【2026-10-19】挿入ソート（O(n²)）から安定なマージソート（O(n log n)）へ。
    // YouTube の kevlar_base が HTML 実体参照名（約 2200 個）を比較関数付きで sort し、
    // 比較関数を約 250 万回呼んでいた（同じ呼び出しが約 1500 回で済む）。
    let undefined_count = items.iter().filter(|v| matches!(v, Value::Undefined)).count();
    items.retain(|v| !matches!(v, Value::Undefined));
    let n = items.len();
    let keys: Option<alloc::vec::Vec<String>> = if matches!(cmp, Value::Undefined) {
        Some(items.iter().map(|v| v.to_js_string()).collect())
    } else {
        None
    };
    // a が b より後ろへ行くべきか（等しければ偽 = 元の順を保つ）。
    let greater = |it: &mut Interp, a: usize, b: usize| -> Result<bool, Value> {
        match &keys {
            Some(k) => Ok(k[a] > k[b]),
            None => Ok(it
                .call_value(cmp, Value::Undefined, &[items[a].clone(), items[b].clone()])?
                .to_number()
                > 0.0),
        }
    };
    let mut idx: alloc::vec::Vec<usize> = (0..n).collect();
    let mut buf: alloc::vec::Vec<usize> = alloc::vec![0; n];
    let mut width = 1;
    while width < n {
        let mut lo = 0;
        while lo < n {
            let mid = (lo + width).min(n);
            let hi = (lo + 2 * width).min(n);
            let (mut l, mut r, mut k) = (lo, mid, lo);
            while l < mid && r < hi {
                if greater(it, idx[l], idx[r])? {
                    buf[k] = idx[r];
                    r += 1;
                } else {
                    buf[k] = idx[l];
                    l += 1;
                }
                k += 1;
            }
            buf[k..k + (mid - l)].copy_from_slice(&idx[l..mid]);
            k += mid - l;
            buf[k..k + (hi - r)].copy_from_slice(&idx[r..hi]);
            lo += 2 * width;
        }
        core::mem::swap(&mut idx, &mut buf);
        width *= 2;
    }
    let mut out: alloc::vec::Vec<Value> = idx.into_iter().map(|i| items[i].clone()).collect();
    for _ in 0..undefined_count {
        out.push(Value::Undefined);
    }
    Ok(out)
}
pub(crate) fn arr_sort(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = this_items(&t);
    let cmp = arg(a, 0);
    let items = sort_excluding_undefined(it, items, &cmp)?;
    if let Some(o) = this_objref(&t) {
        drop_holes(&o);
        if let ObjKind::Array(slot) = &mut o.borrow_mut().kind {
            *slot = items;
        }
    }
    Ok(t)
}
/// `Array.prototype.fill(value, start, end)`。以前は `start`/`end`（第2/第3引数）を
/// 完全に無視して常に配列全体を上書きしており、`[1,2,3,4,5].fill(0,1,3)` のような
/// 部分埋めの定番パターンが機能していなかった。
pub(crate) fn arr_fill(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(o) = this_objref(&t) {
        if let ObjKind::Array(items) = &mut o.borrow_mut().kind {
            let v = arg(a, 0);
            let len = items.len() as i64;
            let start = norm_index(arg(a, 1).to_number(), len, 0).max(0) as usize;
            let end = if matches!(arg(a, 2), Value::Undefined) {
                len
            } else {
                norm_index(arg(a, 2).to_number(), len, len)
            }
            .max(0) as usize;
            let end = end.min(items.len());
            for slot in items.iter_mut().take(end).skip(start) {
                *slot = v.clone();
            }
        }
    }
    Ok(t)
}
pub(crate) fn arr_splice(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let o = match this_objref(&t) {
        Some(o) => o,
        None => return Ok(Value::Object(Obj::array(alloc::vec![]))),
    };
    let mut items = if let ObjKind::Array(v) = &o.borrow().kind {
        v.clone()
    } else {
        return Ok(Value::Object(Obj::array(alloc::vec![])));
    };
    let len = items.len() as i64;
    let start_raw = arg(a, 0).to_number() as i64;
    let start = if start_raw < 0 {
        (len + start_raw).max(0) as usize
    } else {
        start_raw.min(len) as usize
    };
    let delete_count = if a.len() < 2 {
        items.len() - start
    } else {
        let dc = arg(a, 1).to_number() as i64;
        dc.max(0).min((len - start as i64).max(0)) as usize
    };
    let insert: alloc::vec::Vec<Value> = a.iter().skip(2).cloned().collect();
    let removed: alloc::vec::Vec<Value> = items.drain(start..start + delete_count).collect();
    for (i, v) in insert.into_iter().enumerate() {
        items.insert(start + i, v);
    }
    drop_holes(&o);
    if let ObjKind::Array(slot) = &mut o.borrow_mut().kind {
        *slot = items;
    }
    let a_obj = array_species_create(it, &t, removed.len())?;
    populate_array_species(it, &a_obj, removed)
}

/// `Array.prototype.lastIndexOf(searchElement, fromIndex)`。同じ `fromIndex` 無視バグが
/// こちらにもあった（`indexOf`/`includes` と同じ調査で発見）。既定は末尾（`length-1`）から、
/// 負の値は末尾からのオフセットとして解釈し、その位置から先頭へ向かって探索する。
/// `Array.prototype.lastIndexOf(target, fromIndex)`。仕様の `ToIntegerOrInfinity` は
/// `NaN` を `0` として扱うため、`fromIndex` に `NaN` を渡した場合は「index 0 のみを見る」
/// （`fromIndex=0` と同じ）挙動になるはずだが、以前は `NaN` を検知すると無条件に `-1` を
/// 返しており、`[5,1,2].lastIndexOf(5, NaN)` が本来の `0` ではなく `-1` になっていた。
pub(crate) fn arr_last_index_of(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let target = arg(a, 0);
    let len = items.len() as i64;
    if len == 0 {
        return Ok(Value::Number(-1.0));
    }
    let start = if matches!(arg(a, 1), Value::Undefined) {
        len - 1
    } else {
        let n = arg(a, 1).to_number();
        let n = if n.is_nan() { 0.0 } else { n };
        if n < 0.0 {
            len + n as i64
        } else {
            (n as i64).min(len - 1)
        }
    };
    if start < 0 {
        return Ok(Value::Number(-1.0));
    }
    for i in (0..=start as usize).rev() {
        if items[i].strict_eq(&target) {
            return Ok(Value::Number(i as f64));
        }
    }
    Ok(Value::Number(-1.0))
}

pub(crate) fn arr_copy_within(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let o = match this_objref(&t) {
        Some(o) => o,
        None => return Ok(t),
    };
    let mut items = if let ObjKind::Array(v) = &o.borrow().kind {
        v.clone()
    } else {
        return Ok(t);
    };
    let len = items.len() as i64;
    let to_raw = arg(a, 0).to_number() as i64;
    let to = if to_raw < 0 {
        (len + to_raw).max(0) as usize
    } else {
        to_raw.min(len) as usize
    };
    let from_raw = if matches!(arg(a, 1), Value::Undefined) { 0i64 } else { arg(a, 1).to_number() as i64 };
    let from = if from_raw < 0 {
        (len + from_raw).max(0) as usize
    } else {
        from_raw.min(len) as usize
    };
    let end_raw = if matches!(arg(a, 2), Value::Undefined) { len } else { arg(a, 2).to_number() as i64 };
    let end = if end_raw < 0 {
        (len + end_raw).max(0) as usize
    } else {
        end_raw.min(len) as usize
    };
    let count = if end > from { (end - from).min(len as usize - to) } else { 0 };
    let src: alloc::vec::Vec<Value> = items[from..from + count].to_vec();
    for (i, v) in src.into_iter().enumerate() {
        if to + i < items.len() {
            items[to + i] = v;
        }
    }
    if let ObjKind::Array(slot) = &mut o.borrow_mut().kind {
        *slot = items;
    }
    Ok(t)
}

/// `Array.prototype.toSorted/toReversed/toSpliced/with`（ES2023）は %TypedArray%
/// にも同名メソッドが仕様化されているが、この処理系ではどれも `this` が TypedArray
/// （`ObjKind::Array` を流用し `_ta_kind` タグで区別）かどうかを見ずに常に素の
/// `Obj::array(items)` を返しており、`new Int8Array([3,1,2]).toSorted()` が
/// `Int8Array` ではなく普通の配列に化けるバグだった（`structuredClone(TypedArray)`
/// と同種）。`this` の `_ta_kind` を引き継いで返す共通ヘルパーで対応する。
pub(crate) fn is_typed_array(t: &Value) -> bool {
    if let Value::Object(o) = t {
        o.borrow().props.contains_key("_ta_kind")
    } else {
        false
    }
}

/// `ArraySpeciesCreate(originalArray, length)` (ECMAScript 9.4.2.3)。
///
/// `map`/`filter`/`slice`/`splice`/`concat`/`flatMap` 等の派生配列生成で、
/// `this.constructor[Symbol.species]` を参照して結果オブジェクトを槃築する。
pub(crate) fn array_species_create(
    it: &mut Interp,
    original: &Value,
    length: usize,
) -> Result<Value, Value> {
    let is_array = match original {
        Value::Object(o) => matches!(o.borrow().kind, ObjKind::Array(_)),
        _ => false,
    };
    if !is_array {
        return Ok(Value::Object(Obj::array(alloc::vec::Vec::with_capacity(length))));
    }

    let ctor = match it.get_property(original, "constructor") {
        Ok(v) => v,
        Err(_) => return Ok(Value::Object(Obj::array(alloc::vec::Vec::with_capacity(length)))),
    };

    let ctor_is_obj = matches!(ctor, Value::Object(_));
    if !ctor_is_obj {
        return Ok(Value::Object(Obj::array(alloc::vec::Vec::with_capacity(length))));
    }

    // @@species を取得
    let species_val = match it.get_property(&ctor, "Symbol(Symbol.species)") {
        Ok(v) => v,
        Err(_) => ctor.clone(),
    };

    if matches!(species_val, Value::Null | Value::Undefined) {
        return Ok(Value::Object(Obj::array(alloc::vec::Vec::with_capacity(length))));
    }

    // もし標準の Array コンストラクタなら高速路
    if let Value::Object(ref so) = species_val {
        if let Some(Value::Object(ref ao)) = it.global.borrow().vars.get("Array") {
            if core::ptr::eq(so.as_ref(), ao.as_ref()) {
                return Ok(Value::Object(Obj::array(alloc::vec::Vec::with_capacity(length))));
            }
        }
        if so.borrow().is_callable() {
            return it.construct_value(&species_val, &[Value::Number(length as f64)]);
        }
    }

    Err(it.type_error("Symbol.species is not a constructor"))
}

pub(crate) fn populate_array_species(
    it: &mut Interp,
    target: &Value,
    items: alloc::vec::Vec<Value>,
) -> Result<Value, Value> {
    if let Value::Object(o) = target {
        let is_plain_array = matches!(o.borrow().kind, ObjKind::Array(_));
        if is_plain_array {
            let len = items.len();
            o.borrow_mut().kind = ObjKind::Array(items);
            o.borrow_mut().props.insert("length".into(), Value::Number(len as f64));
            return Ok(target.clone());
        }
    }
    let len = items.len();
    for (i, v) in items.into_iter().enumerate() {
        let _ = it.set_property(target, &i.to_string(), v);
    }
    let _ = it.set_property(target, "length", Value::Number(len as f64));
    Ok(target.clone())
}

pub(crate) fn same_kind_as(it: &mut Interp, t: &Value, items: alloc::vec::Vec<Value>) -> Value {
    let ta_kind_tag = if let Value::Object(o) = t {
        o.borrow().props.get("_ta_kind").map(|v| v.to_js_string())
    } else {
        None
    };
    match ta_kind_tag {
        Some(tag) => {
            // `with()` の第2引数のような、まだ型変換（ラップ/クランプ）を経ていない
            // 生の値が混ざっている場合があるため、コンストラクタ/`set`/索引代入と
            // 同じ `TaKind::convert()` を通す（既に有効域内の値には無害）。
            let kind = TaKind::from_name(&tag);
            let values: alloc::vec::Vec<f64> = items.iter().map(|v| kind.convert(v)).collect();
            make_typed_array(it, values, kind)
        }
        None => Value::Object(Obj::array(items)),
    }
}
pub(crate) fn arr_to_sorted(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let cmp = arg(a, 0);
    let items = sort_excluding_undefined(it, items, &cmp)?;
    Ok(same_kind_as(it, &t, items))
}

pub(crate) fn arr_to_reversed(it: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    let mut items = generic_array_items(it, &t);
    items.reverse();
    Ok(same_kind_as(it, &t, items))
}

pub(crate) fn arr_to_spliced(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let mut items = generic_array_items(it, &t);
    let len = items.len() as i64;
    let start_raw = arg(a, 0).to_number() as i64;
    let start = if start_raw < 0 {
        (len + start_raw).max(0) as usize
    } else {
        start_raw.min(len) as usize
    };
    let delete_count = if a.len() < 2 {
        items.len() - start
    } else {
        let dc = arg(a, 1).to_number() as i64;
        dc.max(0).min((len - start as i64).max(0)) as usize
    };
    let insert: alloc::vec::Vec<Value> = a.iter().skip(2).cloned().collect();
    items.drain(start..start + delete_count);
    for (i, v) in insert.into_iter().enumerate() {
        items.insert(start + i, v);
    }
    Ok(same_kind_as(it, &t, items))
}

/// `Array.prototype.with(index, value)`（ES2023）。範囲外 `index` は仕様上 `RangeError` だが、
/// 以前は黙って無視して元と同じ配列を返していた（呼び出し側が範囲外に気づけないバグ）。
pub(crate) fn arr_with(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let mut items = generic_array_items(it, &t);
    let len = items.len() as i64;
    let idx_raw = arg(a, 0).to_number() as i64;
    let idx = if idx_raw < 0 { len + idx_raw } else { idx_raw };
    if idx < 0 || idx >= len {
        return Err(it.error("Invalid index"));
    }
    items[idx as usize] = arg(a, 1);
    Ok(same_kind_as(it, &t, items))
}

/// 再帰的に `depth` 段だけネスト配列を展開する（`arr_flat` のヘルパ）。
/// `depth=Infinity`（`arr.flat(Infinity)`）は定番イディオムだが、`depth - 1.0`
/// は `Infinity` のままなので、循環参照する配列（`a.push(a)`）に対しては
/// 祖先追跡ガードが無いと無限再帰になり、この no_std 環境ではスタック
/// オーバーフロー（クラッシュ/ハング）に直結し得る（`Value::to_js_string`
/// で修正済みの「循環参照でスタックオーバーフロー」系と同種のバグ。
/// 2026-07-13 の横断監査で発見）。既に祖先に現れた配列を再訪した時点で、
/// それ以上展開せずそのまま（配列のまま）結果へ積んで打ち切る。
pub(crate) fn flatten_depth(items: Vec<Value>, depth: f64, out: &mut Vec<Value>, seen: &mut Vec<ObjRef>) {
    for v in items {
        match v {
            Value::Object(o) if depth > 0.0 && matches!(o.borrow().kind, ObjKind::Array(_)) => {
                if seen.iter().any(|s| Rc::ptr_eq(s, &o)) {
                    out.push(Value::Object(o));
                    continue;
                }
                seen.push(o.clone());
                let inner = match &o.borrow().kind {
                    ObjKind::Array(inner) => inner.clone(),
                    _ => Vec::new(),
                };
                flatten_depth(inner, depth - 1.0, out, seen);
                seen.pop();
            }
            other => out.push(other),
        }
    }
}
/// `Array.prototype.flat(depth = 1)`。以前は `depth` 引数を完全に無視して常に1段だけ
/// 展開する実装になっており、`arr.flat(2)` や、深いネスト解除の定番イディオムである
/// `arr.flat(Infinity)` が仕様どおりに動かない（1段しか展開されない）バグだった。
pub(crate) fn arr_flat(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let items = generic_array_items(it, &t);
    let depth = if matches!(arg(a, 0), Value::Undefined) {
        1.0
    } else {
        arg(a, 0).to_number()
    };
    let mut out = Vec::new();
    flatten_depth(items, depth, &mut out, &mut Vec::new());
    Ok(Value::Object(Obj::array(out)))
}
/// `hasOwnProperty`/`Object.hasOwn` の実体。以前は `props.contains_key` だけを見ており、
/// (1) `accessors`（getter/setter 限定プロパティ）専用マップに存在するプロパティ
/// （`{get x(){}}.hasOwnProperty('x')`）と (2) 配列の数値インデックス/`length`
/// （`ObjKind::Array` 側にあり `props` には無い。`[1,2].hasOwnProperty(0)`）の
/// 2種類を「自身にあるのに無い」と誤判定するバグだった（`in`/`for...in` 等と同種）。
pub(crate) fn has_own_property(o: &super::super::value::ObjRef, key: &str) -> bool {
    let b = o.borrow();
    if let ObjKind::Array(items) = &b.kind {
        if key == "length" {
            return true;
        }
        if let Ok(idx) = key.parse::<usize>() {
            return idx < items.len();
        }
    }
    b.props.contains_key(key) || b.accessors.contains_key(key)
}
pub(crate) fn obj_has_own(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let key = arg(a, 0).to_js_string();
    if let Value::Object(o) = &t {
        // DOM 要素のハンドル: 自前のプロパティは要素側の expando（組込みは原型のアクセサ扱い）。
        let dom_idx = match o.borrow().kind {
            ObjKind::DomElement(i) => Some(i),
            _ => None,
        };
        if let Some(i) = dom_idx {
            return Ok(Value::Bool(it.dom.borrow().expandos.get(&i).is_some_and(|m| m.contains_key(&key))));
        }
        return Ok(Value::Bool(has_own_property(o, &key)));
    }
    // 文字列は `length` と各添字を自身のプロパティとして持つ。
    if let Value::Str(s) = &t {
        let n = s.chars().count();
        return Ok(Value::Bool(key == "length" || key.parse::<usize>().is_ok_and(|i| i < n)));
    }
    Ok(Value::Bool(false))
}
/// `Object.prototype.toString.call(x)`（`{}.toString()` 含む）。以前は `this` の
/// 実際の種別を一切見ず常に `"[object Object]"` を返しており、`lodash` 等の
/// ライブラリで広く使われる型判定イディオム（`Object.prototype.toString.call(x)
/// === '[object Array]'` 等）が配列/Map/Set/Date/RegExp/関数のいずれに対しても
/// 常に `"[object Object]"` になってしまう、実用上かなり影響の大きいバグだった。
pub(crate) fn obj_to_string(it: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    // `Symbol.toStringTag`（クラスで `get [Symbol.toStringTag](){ return 'Foo'; }` の
    // ように定義するカスタムタグ）が優先される仕様だが、以前は一切考慮していなかった。
    // プロトタイプ連鎖を辿ってデータプロパティ/アクセサ（getter）どちらの定義方法も見る。
    if let Value::Object(o) = &t {
        let mut cur = Some(o.clone());
        while let Some(c) = cur {
            let (own_tag, getter, next) = {
                let b = c.borrow();
                (
                    b.props.get("Symbol(Symbol.toStringTag)").cloned(),
                    b.accessors
                        .get("Symbol(Symbol.toStringTag)")
                        .and_then(|acc| acc.get.clone()),
                    b.proto.clone(),
                )
            };
            if let Some(v) = own_tag {
                return Ok(Value::str(format!("[object {}]", v.to_js_string())));
            }
            if let Some(g) = getter {
                let v = it.call_value(&g, t.clone(), &[])?;
                return Ok(Value::str(format!("[object {}]", v.to_js_string())));
            }
            cur = next;
        }
    }
    let tag = match &t {
        Value::Undefined => "Undefined",
        Value::Null => "Null",
        Value::Object(o) => {
            let b = o.borrow();
            if b.is_callable() {
                "Function"
            } else {
                match &b.kind {
                    ObjKind::Array(_) => "Array",
                    ObjKind::DateObj(_) => "Date",
                    ObjKind::RegExpObj(_) => "RegExp",
                    ObjKind::MapObj(_) => "Map",
                    ObjKind::SetObj(_) => "Set",
                    ObjKind::PromiseObj(_) => "Promise",
                    ObjKind::Generator(_) => "Generator",
                    _ => "Object",
                }
            }
        }
        // 【2026-09-05 バグ修正】プリミティブが全部 `[object Object]` になっていた。
        //
        // 仕様では種別ごとに `[object String]` / `[object Number]` /
        // `[object Boolean]` / `[object BigInt]` / `[object Symbol]` を返す。
        //
        // これは見た目の問題では済まない。jQuery 1.8.2 は
        // `class2type[Object.prototype.toString.call(x)]` で型を判定し、
        // `jQuery.extend(true, ...)` の深いマージで「素のオブジェクトなら
        // 再帰的にマージ」する。文字列が `[object Object]` を返すと
        // **文字列が `{}` に置き換わる**。実際に `s.type`（"GET"）が
        // 空オブジェクトになり、`s.type.toUpperCase()` で
        // `$.getJSON` が落ちていた。
        Value::Str(_) => "String",
        Value::Number(_) => "Number",
        Value::Bool(_) => "Boolean",
        Value::BigInt(_) => "BigInt",
    };
    Ok(Value::str(format!("[object {}]", tag)))
}
/// `Object.prototype.isPrototypeOf(obj)`: `this` が `obj` のプロトタイプ連鎖上に
/// 存在するか（`instanceof` の `r.prototype` 版に相当。こちらは呼び出し元自身と比較する）。
pub(crate) fn obj_is_prototype_of(_: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let (Value::Object(target), Value::Object(candidate)) = (&t, &arg(a, 0)) else {
        return Ok(Value::Bool(false));
    };
    let mut cur = candidate.borrow().proto.clone();
    let mut guard = 0;
    while let Some(p) = cur {
        if Rc::ptr_eq(&p, target) {
            return Ok(Value::Bool(true));
        }
        cur = p.borrow().proto.clone();
        guard += 1;
        if guard > 1000 {
            break;
        }
    }
    Ok(Value::Bool(false))
}
/// `Object.prototype.propertyIsEnumerable(key)`: この処理系は独自プロパティに enumerable
/// フラグを持たないため、「自身の直接プロパティかどうか」で近似する（`hasOwnProperty` と
/// 同じ判定だが、プロトタイプ継承プロパティに対しては仕様通り false になる点は共通）。
pub(crate) fn obj_property_is_enumerable(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    obj_has_own(it, t, a)
}

// ===== Function.prototype.call/apply/bind =====
// `Reflect.apply`/`Reflect.construct` は既にあったが、実用上はるかに一般的なこちらの
// インスタンスメソッド（`fn.call(this, ...)` 等）が長期間丸ごと欠落していた。
pub fn function_method(key: &str) -> Value {
    match key {
        "call" => nv("call", fn_call),
        "apply" => nv("apply", fn_apply),
        "bind" => nv("bind", fn_bind),
        _ => Value::Undefined,
    }
}
/// `Function.prototype.toString`: `this`（関数）のソース表現／`[native code]` を返す。
/// 関数でなければ TypeError（仕様どおり）。
pub(crate) fn fn_to_string(it: &mut Interp, t: Value, _a: &[Value]) -> Result<Value, Value> {
    match &t {
        Value::Object(o) if o.borrow().is_callable() => Ok(Value::str(t.to_js_string())),
        _ => Err(it.type_error("Function.prototype.toString requires that 'this' be a Function")),
    }
}
pub(crate) fn fn_call(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let this_arg = arg(a, 0);
    let rest: Vec<Value> = a.get(1..).map(|s| s.to_vec()).unwrap_or_default();
    it.call_value(&t, this_arg, &rest)
}
// `Function.prototype.apply` の第2引数も `Reflect.apply` と同じく
// `CreateListFromArrayLike`（array-like 全般）を経由すべきだが、`&mut Interp` を
// 持たない `iterable_values` を使っており素の array-like（実配列ではない）を渡すと
// 引数が丸ごと消える同型のバグだった。
pub(crate) fn fn_apply(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let this_arg = arg(a, 0);
    let args_vec = match arg(a, 1) {
        Value::Undefined | Value::Null => Vec::new(),
        v => array_like_items(it, &v),
    };
    it.call_value(&t, this_arg, &args_vec)
}
pub(crate) fn fn_bind(_it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    let bound_this = arg(a, 0);
    let bound_args: Vec<Value> = a.get(1..).map(|s| s.to_vec()).unwrap_or_default();
    Ok(Value::Object(Obj::bound(t, bound_this, bound_args)))
}

// ============ 小ヘルパ ============

pub(crate) fn norm_index(v: f64, len: i64, default: i64) -> i64 {
    if v.is_nan() {
        return default;
    }
    let i = libm::trunc(v) as i64;
    if i < 0 {
        (len + i).max(0)
    } else {
        i.min(len)
    }
}
pub(crate) fn clamp_idx(v: f64, len: usize) -> usize {
    if v.is_nan() || v < 0.0 {
        0
    } else {
        (v as usize).min(len)
    }
}
pub(crate) fn pad_str(s: &str, target: usize, pad: &str, start: bool) -> String {
    let cur = s.chars().count();
    if cur >= target || pad.is_empty() {
        return String::from(s);
    }
    let mut padding = String::new();
    let pad_chars: Vec<char> = pad.chars().collect();
    let mut i = 0;
    while padding.chars().count() < target - cur {
        padding.push(pad_chars[i % pad_chars.len()]);
        i += 1;
    }
    if start {
        format!("{}{}", padding, s)
    } else {
        format!("{}{}", s, padding)
    }
}
pub(crate) fn format_fixed(n: f64, digits: usize) -> String {
    let neg = n < 0.0;
    let n = libm::fabs(n);
    let int_part = libm::trunc(n) as i64;
    let scale = libm::pow(10.0, digits as f64);
    let frac = libm::trunc((n - libm::trunc(n)) * scale + 0.5) as i64;
    let frac_str = format!("{:0width$}", frac, width = digits);
    format!("{}{}.{}", if neg { "-" } else { "" }, int_part, frac_str)
}