atmos/os_lib/js/builtins/

dom.rs

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

// ============ DOM ネイティブ ============

/// 無害な no-op（未対応 API 用）。
pub fn dom_noop(_: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}

/// `new XMLSerializer()`（丸ごと未対応だった。`.serializeToString(node)`
/// という定番パターン）。
pub(crate) fn xml_serializer_ctor(_it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let o = Obj::plain();
    o.borrow_mut().props.insert(
        "serializeToString".into(),
        nv("serializeToString", xml_serializer_serialize_to_string),
    );
    Ok(Value::Object(o))
}
/// `serializer.serializeToString(node)`。既存の `element.outerHTML` ゲッター
/// （`interp.rs`）と同じ `DomBridge::get_outer_html` を再利用する（DOM 要素
/// ハンドルでない値/未接続ノードは仕様の詳細な例外分岐を省略し空文字列を返す
/// 簡略実装）。
pub(crate) fn xml_serializer_serialize_to_string(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let node = arg(a, 0);
    match this_dom_idx(&node) {
        Some(idx) => Ok(Value::str(it.dom.borrow().get_outer_html(idx))),
        None => Ok(Value::str("")),
    }
}

/// `this`（DOM 要素ハンドル）からノード index を取り出す。
pub(crate) fn this_dom_idx(this: &Value) -> Option<usize> {
    if let Value::Object(o) = this {
        if let ObjKind::DomElement(i) = o.borrow().kind {
            return Some(i);
        }
    }
    None
}

/// `this`（Host("classList:N") など）から prefix を剥がして index を取り出す。
/// `element.style.setProperty(name, value)`/`getPropertyValue(name)`/`removeProperty(name)`
/// が丸ごと欠落していた（直接のプロパティ代入 `el.style.color = 'red'` と、
/// `getComputedStyle().getPropertyValue()` はあったが、インラインスタイルの
/// メソッド経由の読み書きが無かった）。特に CSS カスタムプロパティ（`--foo`）は
/// camelCase のプロパティアクセサ経由では設定できないため、`setProperty` の欠落は
/// カスタムプロパティを使う実用コードで特に影響が大きかった。
pub fn dom_style_set_property(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let name = arg(a, 0).to_js_string();
        let value = arg(a, 1).to_js_string();
        // `setProperty(name, value, priority)` の第3引数（丸ごと無視されて
        // いた。2026-07-16 発見）。生の値文字列末尾に `!important` を
        // 付加して保存すれば、`serialize_inline_style` 経由で再構築される
        // `style` 属性文字列を通じて既存のカスケード側 `!important` パーサ
        // （`css.rs`）にもそのまま伝わる。
        let priority = arg(a, 2).to_js_string();
        let stored = if !value.is_empty() && priority.eq_ignore_ascii_case("important") {
            alloc::format!("{} !important", value)
        } else {
            value
        };
        it.dom.borrow_mut().set_style(idx, &name, &stored);
    }
    Ok(Value::Undefined)
}
pub fn dom_style_get_property_priority(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let name = arg(a, 0).to_js_string();
        return Ok(Value::str(it.dom.borrow().get_style_priority(idx, &name)));
    }
    Ok(Value::str(""))
}
pub fn dom_style_get_property_value(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let name = arg(a, 0).to_js_string();
        return Ok(Value::str(it.dom.borrow().get_style(idx, &name)));
    }
    Ok(Value::str(""))
}
pub fn dom_style_remove_property(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let name = arg(a, 0).to_js_string();
        let prev = it.dom.borrow().get_style(idx, &name);
        it.dom.borrow_mut().set_style(idx, &name, "");
        return Ok(Value::str(prev));
    }
    Ok(Value::str(""))
}
/// `style.item(index)`（丸ごと未対応だった。`style.length`と対）。
/// `get_css_text`の直列化文字列を`;`で分割し直す簡略実装（`dom_props.rs`
/// の`length`ゲッターと同じロジック）。
pub fn dom_style_item(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "style:") {
        let names: alloc::vec::Vec<String> = it
            .dom
            .borrow()
            .get_css_text(idx)
            .split(';')
            .filter_map(|d| d.split_once(':').map(|(k, _)| k.trim().to_string()))
            .filter(|k| !k.is_empty())
            .collect();
        let i = arg(a, 0).to_number();
        if i.is_finite() && i >= 0.0 {
            if let Some(name) = names.get(i as usize) {
                return Ok(Value::str(name.clone()));
            }
        }
    }
    Ok(Value::str(""))
}
pub(crate) fn this_host_idx(this: &Value, prefix: &str) -> Option<usize> {
    if let Value::Object(o) = this {
        if let ObjKind::Host(t) = &o.borrow().kind {
            if let Some(rest) = t.strip_prefix(prefix) {
                return rest.parse().ok();
            }
        }
    }
    None
}

/// 要素ハンドルを Value にして返す。idx が無ければ null。
pub(crate) fn dom_handle(idx: Option<usize>) -> Value {
    match idx {
        Some(i) => Value::Object(Obj::dom(i)),
        None => Value::Null,
    }
}

pub(crate) fn document_get_element_by_id(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let id = arg(a, 0).to_js_string();
    let idx = it.dom.borrow().get_element_by_id(&id);
    Ok(dom_handle(idx))
}

pub(crate) fn document_query_selector(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let sel = arg(a, 0).to_js_string();
    let idx = it.dom.borrow().query(&sel);
    Ok(dom_handle(idx))
}

pub(crate) fn document_query_selector_all(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let sel = arg(a, 0).to_js_string();
    let indices = it.dom.borrow().query_all(&sel);
    let items: Vec<Value> = indices
        .into_iter()
        .map(|i| Value::Object(Obj::dom(i)))
        .collect();
    Ok(Value::Object(Obj::array(items)))
}
/// 座標 `(x, y)` を含む矩形を持つ要素を、面積が小さい（＝最も深くネストした）
/// 順に列挙する共通ヘルパー。`elementFromPoint`/`elementsFromPoint` で共有。
pub(crate) fn dom_hit_test(it: &Interp, x: f64, y: f64) -> alloc::vec::Vec<(usize, i64)> {
    let dom = it.dom.borrow();
    let mut matches: alloc::vec::Vec<(usize, i64)> = alloc::vec::Vec::new();
    for (&idx, &(l, t, w, h)) in dom.rects.iter() {
        let (lf, tf, wf, hf) = (l as f64, t as f64, w as f64, h as f64);
        if x >= lf && x < lf + wf && y >= tf && y < tf + hf {
            matches.push((idx, (w as i64) * (h as i64)));
        }
    }
    matches.sort_by_key(|&(_, area)| area);
    matches
}
pub(crate) fn document_element_from_point(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let x = arg(a, 0).to_number();
    let y = arg(a, 1).to_number();
    let matches = dom_hit_test(it, x, y);
    Ok(match matches.first() {
        Some(&(idx, _)) => Value::Object(Obj::dom(idx)),
        None => Value::Null,
    })
}
pub(crate) fn document_elements_from_point(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let x = arg(a, 0).to_number();
    let y = arg(a, 1).to_number();
    let items: alloc::vec::Vec<Value> = dom_hit_test(it, x, y)
        .into_iter()
        .map(|(idx, _)| Value::Object(Obj::dom(idx)))
        .collect();
    Ok(Value::Object(Obj::array(items)))
}

pub fn dom_add_event_listener(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let event = arg(a, 0).to_js_string();
        let func = arg(a, 1);
        let (capture, once) = parse_listener_opts(&arg(a, 2));
        let signal = parse_listener_signal(&arg(a, 2));
        if matches!(func, Value::Object(_)) {
            it.dom
                .borrow_mut()
                .add_listener_opts_signal(idx, &event, func, capture, once, signal);
        }
    }
    Ok(Value::Undefined)
}

/// addEventListener / removeEventListener の第3引数を解釈する。
/// boolean なら capture フラグ、オブジェクトなら {capture, once} を読む。
pub(crate) fn parse_listener_opts(opt: &Value) -> (bool, bool) {
    match opt {
        Value::Bool(b) => (*b, false),
        Value::Object(o) => {
            let b = o.borrow();
            let capture = b.props.get("capture").map(|v| v.truthy()).unwrap_or(false);
            let once = b.props.get("once").map(|v| v.truthy()).unwrap_or(false);
            (capture, once)
        }
        _ => (false, false),
    }
}
/// `addEventListener(type, fn, {signal})`（丸ごと未対応だった）の `signal`
/// オプションを取り出す。`AbortSignal` らしきオブジェクト（`aborted` プロパティ
/// を持つ）以外は無視する。
pub(crate) fn parse_listener_signal(opt: &Value) -> Option<Value> {
    if let Value::Object(o) = opt {
        let s = o.borrow().props.get("signal").cloned();
        if let Some(sig @ Value::Object(so)) = &s {
            if so.borrow().props.contains_key("aborted") {
                return Some(sig.clone());
            }
        }
    }
    None
}

/// element.removeEventListener(type, fn, opts): 一致するリスナを削除する。
pub fn dom_remove_event_listener(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let event = arg(a, 0).to_js_string();
        let func = arg(a, 1);
        let (capture, _once) = parse_listener_opts(&arg(a, 2));
        if matches!(func, Value::Object(_)) {
            it.dom
                .borrow_mut()
                .remove_listener(idx, &event, &func, capture);
        }
    }
    Ok(Value::Undefined)
}

/// element.dispatchEvent(ev): ev.type のイベントを当該要素から発火する。
/// 戻り値は !defaultPrevented（DOM 仕様）。
pub fn dom_dispatch_event(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let idx = match this_dom_idx(&this) {
        Some(i) => i,
        None => return Ok(Value::Bool(true)),
    };
    let ev = arg(a, 0);
    // ev.type を取得。bubbles など追加プロパティはそのまま渡す。
    let (etype, extra) = if let Value::Object(o) = &ev {
        let b = o.borrow();
        let t = b
            .props
            .get("type")
            .map(|v| v.to_js_string())
            .unwrap_or_default();
        // 既知の組み込みプロパティ以外を extra として転送（detail など）。`bubbles`
        // は以前ここで除外されており、コメント「bubbles など追加プロパティは
        // そのまま渡す」と矛盾していた（実際には常に除外され `dispatch_event_*`
        // 側で無条件 `true` 決め打ちに繋がっていた）。非バブリングイベントを
        // 正しく伝播させるため、`bubbles` は除外せず転送する。
        let mut extra: Vec<(String, Value)> = Vec::new();
        for (k, v) in b.props.iter() {
            if matches!(
                k.as_str(),
                "type"
                    | "target"
                    | "currentTarget"
                    | "eventPhase"
                    | "defaultPrevented"
                    | "preventDefault"
                    | "stopPropagation"
                    | "stopImmediatePropagation"
                    | "composedPath"
                    | "_composedPath"
                    | "_stop"
                    | "_stopImmediate"
            ) {
                continue;
            }
            extra.push((k.clone(), v.clone()));
        }
        (t, extra)
    } else {
        (ev.to_js_string(), Vec::new())
    };
    if etype.is_empty() {
        return Ok(Value::Bool(true));
    }
    let (_fired, prevented) = it.dispatch_event_in_interp(idx, &etype, &extra);
    Ok(Value::Bool(!prevented))
}

/// `node.hasChildNodes()`（丸ごと未対応だった。`node.childNodes.length > 0`
/// の定番の手間を省くメソッド）。
pub fn dom_has_child_nodes(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let has_kids = it
            .dom
            .borrow()
            .nodes
            .get(idx)
            .map(|n| !n.children.is_empty())
            .unwrap_or(false);
        return Ok(Value::Bool(has_kids));
    }
    Ok(Value::Bool(false))
}
pub fn dom_get_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        return Ok(match it.dom.borrow().get_attr(idx, &name) {
            Some(v) => Value::str(v),
            None => Value::Null,
        });
    }
    Ok(Value::Null)
}

pub fn dom_has_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        return Ok(Value::Bool(it.dom.borrow().has_attr(idx, &name)));
    }
    Ok(Value::Bool(false))
}

/// `element.attributes`（`NamedNodeMap`。`{name,value}` の簡略表現）と同じ
/// 形で `Attr` ノード相当のオブジェクトを作る。`ownerElement` も含める。
pub(crate) fn make_attr_node(name: &str, value: &str, owner: &Value) -> Value {
    let o = Obj::plain();
    let mut b = o.borrow_mut();
    b.props.insert("name".into(), Value::str(name));
    b.props.insert("value".into(), Value::str(value));
    b.props.insert("ownerElement".into(), owner.clone());
    drop(b);
    Value::Object(o)
}
/// `document.createAttribute(name)`（丸ごと未対応だった。`getAttributeNode`
/// と対になる、`Attr` ノードを新規に作ってから `setAttributeNode()` で
/// 要素へ取り付ける定番パターン）。HTML 文書のため仕様どおり名前を
/// 小文字化し、値は空文字列・`ownerElement` は `null`（未取り付け）で返す。
pub fn document_create_attribute(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let name = arg(a, 0).to_js_string().to_lowercase();
    Ok(make_attr_node(&name, "", &Value::Null))
}
/// `element.getAttributeNode(name)`（丸ごと未対応だった。`getAttribute`
/// より古い/低レベルな `Attr` ノード経由の定番イディオム）。この処理系には
/// `Attr` 専用の内部表現が無いため、`element.attributes` と同じ
/// `{name, value, ownerElement}` の簡略オブジェクトを返す。
pub fn dom_get_attribute_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        if let Some(v) = it.dom.borrow().get_attr(idx, &name) {
            return Ok(make_attr_node(&name, &v, &this));
        }
    }
    Ok(Value::Null)
}
/// `element.setAttributeNode(attr)`。`attr.name`/`attr.value` を読み取って
/// 通常の `setAttribute` と同じストアへ反映する。戻り値は仕様上「置換された
/// 旧 Attr ノード（無ければ null）」。
pub fn dom_set_attribute_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let attr = arg(a, 0);
        if matches!(attr, Value::Object(_)) {
            let name = obj_prop(&attr, "name").map(|v| v.to_js_string()).unwrap_or_default();
            let value = obj_prop(&attr, "value").map(|v| v.to_js_string()).unwrap_or_default();
            let old = it.dom.borrow().get_attr(idx, &name);
            it.dom.borrow_mut().set_attr(idx, &name, &value);
            if let Some(old_v) = old {
                return Ok(make_attr_node(&name, &old_v, &this));
            }
        }
    }
    Ok(Value::Null)
}
/// `element.getAttributeNodeNS(namespace, localName)`（丸ごと未対応だった）。
/// 他の `*AttributeNS` と同じく `namespace` 引数は無視し `localName` で検索する。
pub fn dom_get_attribute_node_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = if a.len() >= 2 {
            arg(a, 1).to_js_string()
        } else {
            arg(a, 0).to_js_string()
        };
        if let Some(v) = it.dom.borrow().get_attr(idx, &name) {
            return Ok(make_attr_node(&name, &v, &this));
        }
    }
    Ok(Value::Null)
}
/// `element.removeAttributeNode(attr)`。`attr.name` の属性を削除し、削除した
/// `Attr` ノードを返す（仕様上、未存在なら `NotFoundError` だがこの処理系は
/// 例外機構が限定的なため簡略化し `null` を返す）。
pub fn dom_remove_attribute_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = obj_prop(&arg(a, 0), "name").map(|v| v.to_js_string()).unwrap_or_default();
        // `it.dom.borrow()` の一時 `Ref` を `if let` ブロック内で保持したまま
        // `borrow_mut()` すると panic する既知のバグ族（`select_options_remove`
        // で実際に発生した既知パターン。2026-07-14 の RefCell 二重借用横断監査で
        // この形自体は洗い出し済みだったが、同日の新規コードでまた作り込んで
        // しまった）。owned な値へ一度 materialize してから使う。
        let old = it.dom.borrow().get_attr(idx, &name);
        if let Some(v) = old {
            it.dom.borrow_mut().remove_attr(idx, &name);
            return Ok(make_attr_node(&name, &v, &this));
        }
    }
    Ok(Value::Null)
}

pub fn dom_remove_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        it.dom.borrow_mut().remove_attr(idx, &name);
    }
    Ok(Value::Undefined)
}

/// `getAttributeNS`/`setAttributeNS`/`hasAttributeNS`/`removeAttributeNS`
/// （丸ごと未対応だった。SVG 等で `setAttributeNS(null, 'viewBox', ...)` のように
/// 使われる定番イディオム）。この処理系は XML 名前空間を一切モデル化していないため、
/// 第1引数（namespace）は無視して非 NS 版と同じ属性ストアへ委譲する簡略実装
/// （多くの実用コードは namespace に `null` を渡すため実害は小さい）。
pub fn dom_get_attribute_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_get_attribute(it, this, &a[1.min(a.len())..])
}
pub fn dom_set_attribute_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_set_attribute(it, this, &a[1.min(a.len())..])
}
pub fn dom_has_attribute_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_has_attribute(it, this, &a[1.min(a.len())..])
}
pub fn dom_remove_attribute_ns(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_remove_attribute(it, this, &a[1.min(a.len())..])
}

pub fn dom_get_attribute_names(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let names: Vec<Value> = it
            .dom
            .borrow()
            .attr_names(idx)
            .into_iter()
            .map(Value::str)
            .collect();
        return Ok(Value::Object(Obj::array(names)));
    }
    Ok(Value::Object(Obj::array(Vec::new())))
}
/// `element.hasAttributes()`（丸ごと未対応だった。単一属性の有無を見る `hasAttribute(name)`
/// は既に実装済みだったが、「1つでも属性を持つか」を見るこちらが漏れていた）。
pub fn dom_has_attributes(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        return Ok(Value::Bool(!it.dom.borrow().attr_names(idx).is_empty()));
    }
    Ok(Value::Bool(false))
}
/// `node.normalize()`（丸ごと未対応だった。連続する隣接テキストノードを1つに連結し、
/// 空のテキストノードを取り除く DOM 標準メソッド）。
pub fn dom_normalize(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dom.borrow_mut().normalize_node(idx);
    }
    Ok(Value::Undefined)
}
/// `CharacterData.appendData`/`.deleteData`/`.insertData`/`.replaceData`/
/// `.substringData`（丸ごと未対応だった。2026-07-16 発見）。テキストノード
/// のみに意味を持つ（呼び出し元の interp.rs 側で `is_text` ガード済み）ため
/// ここでは無条件にテキスト内容を読み書きする。他の文字列系メソッド
/// （`str_slice`/`str_substring`）と同じ char 単位オフセットの簡略実装
/// （UTF-16 コード単位ではない）。
fn char_data_chars(it: &Interp, idx: usize) -> alloc::vec::Vec<char> {
    it.dom.borrow().get_text_content(idx).chars().collect()
}
pub fn dom_char_data_append(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let mut s = it.dom.borrow().get_text_content(idx);
        s.push_str(&arg(a, 0).to_js_string());
        it.dom.borrow_mut().set_text_content(idx, &s);
    }
    Ok(Value::Undefined)
}
/// `CharacterData`編集メソッド群（`deleteData`/`insertData`/`replaceData`/
/// `substringData`）は仕様上、`offset`が`length`を超える場合`IndexSizeError`を
/// 投げるべき（`count`側は超過分を自動的にクランプするだけで例外にはならない）
/// が、以前は`offset`も`len`へ黙ってクランプしてしまい、範囲外呼び出しが
/// 常に無害な no-op（`deleteData`/`substringData`）や末尾への追記
/// （`insertData`）として成立していた。`table.insertRow`等と同じ「範囲外
/// インデックスの黙殺」バグ族の一つ。
fn char_data_check_offset(offset_arg: Value, len: usize) -> Result<usize, Value> {
    let raw = offset_arg.to_number();
    let offset = if raw.is_finite() { raw.max(0.0) as usize } else { 0 };
    if offset > len {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The offset is greater than the length of the data",
        ));
    }
    Ok(offset)
}
pub fn dom_char_data_delete(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let chars = char_data_chars(it, idx);
        let len = chars.len();
        let offset = char_data_check_offset(arg(a, 0), len)?;
        let count = (arg(a, 1).to_number().max(0.0) as usize).min(len - offset);
        let out: String = chars[..offset].iter().chain(chars[offset + count..].iter()).collect();
        it.dom.borrow_mut().set_text_content(idx, &out);
    }
    Ok(Value::Undefined)
}
pub fn dom_char_data_insert(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let chars = char_data_chars(it, idx);
        let len = chars.len();
        let offset = char_data_check_offset(arg(a, 0), len)?;
        let insert = arg(a, 1).to_js_string();
        let out: String = chars[..offset]
            .iter()
            .collect::<String>()
            + &insert
            + &chars[offset..].iter().collect::<String>();
        it.dom.borrow_mut().set_text_content(idx, &out);
    }
    Ok(Value::Undefined)
}
pub fn dom_char_data_replace(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let chars = char_data_chars(it, idx);
        let len = chars.len();
        let offset = char_data_check_offset(arg(a, 0), len)?;
        let count = (arg(a, 1).to_number().max(0.0) as usize).min(len - offset);
        let replacement = arg(a, 2).to_js_string();
        let out: String = chars[..offset]
            .iter()
            .collect::<String>()
            + &replacement
            + &chars[offset + count..].iter().collect::<String>();
        it.dom.borrow_mut().set_text_content(idx, &out);
    }
    Ok(Value::Undefined)
}
pub fn dom_char_data_substring(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let chars = char_data_chars(it, idx);
        let len = chars.len();
        let offset = char_data_check_offset(arg(a, 0), len)?;
        let count = (arg(a, 1).to_number().max(0.0) as usize).min(len - offset);
        return Ok(Value::str(chars[offset..offset + count].iter().collect::<String>()));
    }
    Ok(Value::str(""))
}
/// `Text.splitText(offset)`（丸ごと未対応だった。2026-07-16 発見。
/// `CharacterData`編集メソッド群の隣で発見。テキストノードを`offset`位置で
/// 2つに分割し、後半を新しいテキストノードとして直後の兄弟に挿入して返す
/// 仕様どおりの動作。`char_data_chars`と同じ char 単位オフセットの簡略実装）。
pub fn dom_split_text(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let chars = char_data_chars(it, idx);
    let len = chars.len();
    // `deleteData`等と同じ仕様: `offset > length`は`IndexSizeError`（詳細は
    // `char_data_check_offset`のコメント参照）。
    let offset = char_data_check_offset(arg(a, 0), len)?;
    let before: String = chars[..offset].iter().collect();
    let after: String = chars[offset..].iter().collect();
    it.dom.borrow_mut().set_text_content(idx, &before);
    let new_idx = it.dom.borrow_mut().create_text_node(&after);
    let (parent, next_sibling) = {
        let dom = it.dom.borrow();
        match dom.nodes.get(idx).and_then(|n| n.parent) {
            Some(p) => {
                let pos = dom.nodes[p].children.iter().position(|&c| c == idx);
                let next = pos.and_then(|i| dom.nodes[p].children.get(i + 1)).copied();
                (Some(p), next)
            }
            None => (None, None),
        }
    };
    if let Some(p) = parent {
        it.dom.borrow_mut().insert_before(p, new_idx, next_sibling);
    }
    Ok(Value::Object(Obj::dom(new_idx)))
}

/// HTML5 Table DOM（`table.insertRow`/`.deleteRow`/`.rows`、`tr.insertCell`/
/// `.deleteCell`/`.cells`）が丸ごと未対応だった（2026-07-17 発見。`select.
/// options.add`/`.remove` と同じ「動的に構築する」定番イディオム）。`thead`/
/// `tbody`/`tfoot` を明示的にモデル化せず、常に文書順の `descendants_by_tags`
/// で `tr`/`td`/`th` を集約する簡略実装（新規行は「参照行の親」＝既存の
/// `tbody`があればその中、無ければ`table`直下へ挿入する）。
pub fn dom_table_insert_row(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(table_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let rows = it.dom.borrow().descendants_by_tags(table_idx, &["tr"]);
    let len = rows.len();
    let pos = arg(a, 0).to_number();
    let pos = if pos.is_nan() { -1 } else { pos as i64 };
    // 仕様上 `insertRow(index)` の有効範囲は `-1 <= index <= rows.length`
    // （`-1`/`length`は末尾への追加を意味する）で、範囲外は`IndexSizeError`を
    // 投げるべきだが、以前は範囲外の値をすべて「末尾へ追加」として黙って
    // 受け入れてしまっていた（`table.insertRow(9999)`が例外にならず末尾追加
    // として成功していた）。`insertCell`/`deleteRow`/`deleteCell`にも同じ
    // パターンのバグがあり、まとめて修正した。
    if pos < -1 || pos > len as i64 {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The index provided is outside the range of rows represented by this table",
        ));
    }
    let (parent, ref_child) = if pos >= 0 && (pos as usize) < len {
        let r = rows[pos as usize];
        (it.dom.borrow().nodes.get(r).and_then(|n| n.parent).unwrap_or(table_idx), Some(r))
    } else if let Some(&last) = rows.last() {
        (it.dom.borrow().nodes.get(last).and_then(|n| n.parent).unwrap_or(table_idx), None)
    } else {
        (table_idx, None)
    };
    let new_row = it.dom.borrow_mut().create_element("tr");
    it.dom.borrow_mut().insert_before(parent, new_row, ref_child);
    Ok(Value::Object(Obj::dom(new_row)))
}
pub fn dom_table_delete_row(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(table_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let rows = it.dom.borrow().descendants_by_tags(table_idx, &["tr"]);
    let pos = arg(a, 0).to_number();
    let pos = if pos.is_nan() { -1 } else { pos as i64 };
    // 仕様上 `deleteRow(index)` の有効範囲は `-1 <= index < rows.length`
    // （`-1`は末尾行の削除を意味する）で、範囲外は`IndexSizeError`を投げる
    // べきだが、以前は範囲外の値をすべて「末尾行を削除」として黙って受け
    // 入れてしまっていた（詳細は`insertRow`側の同種コメント参照）。
    if pos < -1 || pos >= rows.len() as i64 {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The index provided is outside the range of rows represented by this table",
        ));
    }
    let target = if pos >= 0 {
        Some(rows[pos as usize])
    } else {
        rows.last().copied()
    };
    if let Some(r) = target {
        it.dom.borrow_mut().remove_node(r);
    }
    Ok(Value::Undefined)
}
pub fn dom_table_insert_cell(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(row_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let cells = it.dom.borrow().descendants_by_tags(row_idx, &["td", "th"]);
    let len = cells.len();
    let pos = arg(a, 0).to_number();
    let pos = if pos.is_nan() { -1 } else { pos as i64 };
    // `insertRow`と同じ仕様上の有効範囲チェック（`-1 <= index <= cells.length`）。
    // 詳細はそちらの同種コメント参照。
    if pos < -1 || pos > len as i64 {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The index provided is outside the range of cells represented by this row",
        ));
    }
    let ref_child = if pos >= 0 && (pos as usize) < len { Some(cells[pos as usize]) } else { None };
    let new_cell = it.dom.borrow_mut().create_element("td");
    it.dom.borrow_mut().insert_before(row_idx, new_cell, ref_child);
    Ok(Value::Object(Obj::dom(new_cell)))
}
pub fn dom_table_delete_cell(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(row_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let cells = it.dom.borrow().descendants_by_tags(row_idx, &["td", "th"]);
    let pos = arg(a, 0).to_number();
    let pos = if pos.is_nan() { -1 } else { pos as i64 };
    // `deleteRow`と同じ仕様上の有効範囲チェック（`-1 <= index < cells.length`）。
    // 詳細はそちらの同種コメント参照。
    if pos < -1 || pos >= cells.len() as i64 {
        return Err(make_dom_exception(
            "IndexSizeError",
            "The index provided is outside the range of cells represented by this row",
        ));
    }
    let target = if pos >= 0 {
        Some(cells[pos as usize])
    } else {
        cells.last().copied()
    };
    if let Some(c) = target {
        it.dom.borrow_mut().remove_node(c);
    }
    Ok(Value::Undefined)
}

/// `table.createTHead()`/`.createTFoot()`/`.createCaption()`（丸ごと未対応
/// だった。2026-07-17 発見。仕様上「既存の該当要素があればそれを返す、
/// 無ければ新規作成して挿入する」冪等な動作）。直接の子のみを対象とする
/// （`tHead`/`tFoot`/`caption`ゲッターと同じ制約）。`caption`は最初の子、
/// `thead`は最初の子（`caption`の後）、`tfoot`は最後の子として挿入する
/// 簡略実装（`colgroup`との相対位置関係は厳密には対象外）。
fn table_create_section(it: &mut Interp, table_idx: usize, tag: &str, append: bool) -> Value {
    let existing = {
        let dom = it.dom.borrow();
        dom.nodes[table_idx].children.iter().find(|&&c| dom.nodes[c].tag == tag).copied()
    };
    if let Some(i) = existing {
        return Value::Object(Obj::dom(i));
    }
    let new_idx = it.dom.borrow_mut().create_element(tag);
    let ref_child = if append {
        None
    } else {
        it.dom.borrow().nodes[table_idx].children.first().copied()
    };
    it.dom.borrow_mut().insert_before(table_idx, new_idx, ref_child);
    Value::Object(Obj::dom(new_idx))
}
fn table_delete_section(it: &mut Interp, table_idx: usize, tag: &str) {
    let existing = {
        let dom = it.dom.borrow();
        dom.nodes[table_idx].children.iter().find(|&&c| dom.nodes[c].tag == tag).copied()
    };
    if let Some(i) = existing {
        it.dom.borrow_mut().remove_node(i);
    }
}
pub fn dom_table_create_thead(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(match this_dom_idx(&this) {
        Some(idx) => table_create_section(it, idx, "thead", false),
        None => Value::Undefined,
    })
}
pub fn dom_table_create_tfoot(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(match this_dom_idx(&this) {
        Some(idx) => table_create_section(it, idx, "tfoot", true),
        None => Value::Undefined,
    })
}
pub fn dom_table_create_caption(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(match this_dom_idx(&this) {
        Some(idx) => table_create_section(it, idx, "caption", false),
        None => Value::Undefined,
    })
}
pub fn dom_table_delete_thead(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        table_delete_section(it, idx, "thead");
    }
    Ok(Value::Undefined)
}
pub fn dom_table_delete_tfoot(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        table_delete_section(it, idx, "tfoot");
    }
    Ok(Value::Undefined)
}
pub fn dom_table_delete_caption(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        table_delete_section(it, idx, "caption");
    }
    Ok(Value::Undefined)
}

/// `img.decode()`（丸ごと未対応だった。2026-07-17 発見）。実デコード成否を
/// 追跡する経路が無いため、`complete`ゲッターと同じ「`src`があれば
/// ロード試行済み」前提で、`src`があれば解決・無ければ`DOMException
/// ("EncodingError")`で拒否するPromiseを返す簡略実装。
pub fn dom_img_decode(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let has_src = this_dom_idx(&this)
        .map(|idx| it.dom.borrow().get_attr(idx, "src").map(|s| !s.is_empty()).unwrap_or(false))
        .unwrap_or(false);
    if has_src {
        Ok(resolved_promise(it, Value::Undefined))
    } else {
        let reason = make_dom_exception("EncodingError", "The source image cannot be decoded");
        Ok(rejected_promise(it, reason))
    }
}

/// 現在の`.value`文字列を読む（`textarea`は`value`属性優先、無ければ
/// `initial_text`にフォールバック。`interp/dom_props.rs`の`value`
/// ゲッターと同じロジック）。
fn current_field_value(it: &Interp, idx: usize) -> String {
    let dom = it.dom.borrow();
    let tag = dom.nodes.get(idx).map(|n| n.tag.as_str()).unwrap_or("");
    if tag == "textarea" {
        dom.get_attr(idx, "_live_value")
            .or_else(|| dom.get_attr(idx, "value"))
            .unwrap_or_else(|| dom.nodes.get(idx).map(|n| n.initial_text.clone()).unwrap_or_default())
    } else {
        dom.get_attr(idx, "_live_value")
            .or_else(|| dom.get_attr(idx, "value"))
            .unwrap_or_default()
    }
}
/// `input`/`textarea.setSelectionRange(start, end, direction?)`（丸ごと
/// 未対応だった。`selectionStart`/`.selectionEnd`/`.selectionDirection`
/// と対になる一括設定メソッド。2026-07-17 発見・実装）。3プロパティへの
/// 個別代入と同じ内部専用属性へまとめて保存する簡略実装。
pub fn dom_set_selection_range(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let start = arg(a, 0).to_number();
        let end = arg(a, 1).to_number();
        let direction = if matches!(arg(a, 2), Value::Undefined) {
            String::from("none")
        } else {
            arg(a, 2).to_js_string()
        };
        let mut dom = it.dom.borrow_mut();
        dom.set_attr(idx, "_selection_start", &Value::Number(start).to_js_string());
        dom.set_attr(idx, "_selection_end", &Value::Number(end).to_js_string());
        dom.set_attr(idx, "_selection_direction", &direction);
    }
    Ok(Value::Undefined)
}
/// `input`/`textarea.setRangeText(replacement, start?, end?, selectMode?)`
/// （丸ごと未対応だった。2026-07-17 発見・実装）。`start`/`end`省略時は
/// 現在の`selectionStart`/`.selectionEnd`を使う（仕様どおり）。
/// `selectMode`は`"select"`（置換後の範囲を選択）/`"start"`（キャレットを
/// 置換範囲の先頭へ）/`"end"`（末尾へ、既定）/`"preserve"`（元の選択位置を
/// 維持しようと試みる）に対応する簡略実装。
pub fn dom_set_range_text(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let replacement = arg(a, 0).to_js_string();
        let chars: alloc::vec::Vec<char> = current_field_value(it, idx).chars().collect();
        let len = chars.len();
        let cur_start = it
            .dom
            .borrow()
            .get_attr(idx, "_selection_start")
            .and_then(|v| v.parse::<f64>().ok())
            .unwrap_or(0.0);
        let cur_end = it
            .dom
            .borrow()
            .get_attr(idx, "_selection_end")
            .and_then(|v| v.parse::<f64>().ok())
            .unwrap_or(0.0);
        let start = if matches!(arg(a, 1), Value::Undefined) { cur_start } else { arg(a, 1).to_number() };
        let end = if matches!(arg(a, 2), Value::Undefined) { cur_end } else { arg(a, 2).to_number() };
        let start = (start.max(0.0) as usize).min(len);
        let end = (end.max(0.0) as usize).min(len).max(start);
        let select_mode = if matches!(arg(a, 3), Value::Undefined) { String::from("preserve") } else { arg(a, 3).to_js_string() };
        let new_value: String =
            chars[..start].iter().chain(replacement.chars().collect::<alloc::vec::Vec<_>>().iter()).chain(chars[end..].iter()).collect();
        let new_end = start + replacement.chars().count();
        let (sel_start, sel_end) = match select_mode.as_str() {
            "select" => (start, new_end),
            "start" => (start, start),
            "end" => (new_end, new_end),
            _ => (start, new_end), // "preserve" は簡略実装として置換範囲を返す
        };
        let mut dom = it.dom.borrow_mut();
        dom.set_attr(idx, "_live_value", &new_value);
        dom.set_attr(idx, "_selection_start", &Value::Number(sel_start as f64).to_js_string());
        dom.set_attr(idx, "_selection_end", &Value::Number(sel_end as f64).to_js_string());
    }
    Ok(Value::Undefined)
}
/// `node.isSameNode(other)`（丸ごと未対応だった。DOM 標準の参照同一性判定。`===` と
/// 同義だが、DOM ノードを扱うライブラリで明示的に使われる定番メソッド）。
pub fn dom_is_same_node(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let self_idx = this_dom_idx(&this);
    let other_idx = this_dom_idx(&arg(a, 0));
    Ok(Value::Bool(self_idx.is_some() && self_idx == other_idx))
}
/// `node.isEqualNode(other)`（丸ごと未対応だった。参照ではなく構造的な等価性
/// — タグ名/属性/子要素が全て一致するか — を見る DOM 標準メソッド）。既存の
/// `outerHTML` シリアライズを再利用し、文字列として一致するかで近似する
/// （属性は `BTreeMap` 由来で常に同じ順序にシリアライズされるため、挿入順序に
/// 依存しない安定した比較になる）。
pub fn dom_is_equal_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let self_idx = this_dom_idx(&this);
    let other_idx = this_dom_idx(&arg(a, 0));
    match (self_idx, other_idx) {
        (Some(ai), Some(bi)) => {
            let dom = it.dom.borrow();
            Ok(Value::Bool(dom.get_outer_html(ai) == dom.get_outer_html(bi)))
        }
        _ => Ok(Value::Bool(false)),
    }
}

/// element.getBoundingClientRect(): レイアウト後の矩形（DomBridge.rects、ページ座標）から
/// DOMRect 風オブジェクト {x,left,y,top,width,height,right,bottom} を返す。未登録なら 0。
/// `element.setPointerCapture(pointerId)`（Pointer Events。丸ごと未対応
/// だった。ドラッグ操作で `el.setPointerCapture(e.pointerId)` する定番
/// パターン）。
pub fn dom_set_pointer_capture(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dom.borrow_mut().set_pointer_capture(idx, arg(a, 0).to_number() as i32);
    }
    Ok(Value::Undefined)
}
/// `element.releasePointerCapture(pointerId)`。
pub fn dom_release_pointer_capture(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dom
            .borrow_mut()
            .release_pointer_capture(idx, arg(a, 0).to_number() as i32);
    }
    Ok(Value::Undefined)
}
/// `element.hasPointerCapture(pointerId)`。
pub fn dom_has_pointer_capture(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let has = this_dom_idx(&this)
        .map(|idx| it.dom.borrow().has_pointer_capture(idx, arg(a, 0).to_number() as i32))
        .unwrap_or(false);
    Ok(Value::Bool(has))
}

/// `(x,y,w,h)` から `DOMRect` 相当のプレーンオブジェクトを組み立てる。
/// `getBoundingClientRect`/`getClientRects` で共有する。
/// `new DOMRect(x, y, width, height)`（丸ごと未対応だった。手動で矩形を
/// 構築する定番パターン。2026-07-17 発見）。`getBoundingClientRect()`が
/// 返す`make_dom_rect`と同じプロパティ形状（`x`/`y`/`left`/`top`/
/// `width`/`height`/`right`/`bottom`）だが、引数は整数丸め無しの浮動小数
/// 点のまま保持する（手動構築ではサブピクセル値も仕様上有効なため）。
/// `DOMRectReadOnly`も同じ形状のため区別せず同一コンストラクタで代用する
/// 簡略実装（`fromRect`静的メソッド・書き込み可能プロパティの違いは
/// 対象外）。
pub(crate) fn dom_rect_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let x = arg(a, 0).to_number();
    let y = arg(a, 1).to_number();
    let w = arg(a, 2).to_number();
    let h = arg(a, 3).to_number();
    let x = if x.is_nan() { 0.0 } else { x };
    let y = if y.is_nan() { 0.0 } else { y };
    let w = if w.is_nan() { 0.0 } else { w };
    let h = if h.is_nan() { 0.0 } else { h };
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("x".into(), Value::Number(x));
        b.props.insert("left".into(), Value::Number(x));
        b.props.insert("y".into(), Value::Number(y));
        b.props.insert("top".into(), Value::Number(y));
        b.props.insert("width".into(), Value::Number(w));
        b.props.insert("height".into(), Value::Number(h));
        b.props.insert("right".into(), Value::Number(x + w));
        b.props.insert("bottom".into(), Value::Number(y + h));
        b.props.insert(
            "toJSON".into(),
            nv("toJSON", |_: &mut Interp, this: Value, _: &[Value]| {
                if let Value::Object(o) = &this {
                    let clone = Obj::plain();
                    for (k, v) in o.borrow().props.iter() {
                        if k != "toJSON" {
                            clone.borrow_mut().props.insert(k.clone(), v.clone());
                        }
                    }
                    return Ok(Value::Object(clone));
                }
                Ok(Value::Undefined)
            }),
        );
    }
    Ok(Value::Object(o))
}
fn get_num_prop(it: &mut Interp, val: &Value, name: &str, default: f64) -> f64 {
    it.get_property(val, name).map(|v| v.to_number()).unwrap_or(default)
}

pub fn dom_point_matrix_transform(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let px = get_num_prop(it, &this, "x", 0.0);
    let py = get_num_prop(it, &this, "y", 0.0);
    let pz = get_num_prop(it, &this, "z", 0.0);
    let pw = get_num_prop(it, &this, "w", 1.0);
    let m = arg(a, 0);

    let def_a = get_num_prop(it, &m, "a", 1.0);
    let m11 = get_num_prop(it, &m, "m11", def_a);
    let def_b = get_num_prop(it, &m, "b", 0.0);
    let m12 = get_num_prop(it, &m, "m12", def_b);
    let m13 = get_num_prop(it, &m, "m13", 0.0);
    let m14 = get_num_prop(it, &m, "m14", 0.0);

    let def_c = get_num_prop(it, &m, "c", 0.0);
    let m21 = get_num_prop(it, &m, "m21", def_c);
    let def_d = get_num_prop(it, &m, "d", 1.0);
    let m22 = get_num_prop(it, &m, "m22", def_d);
    let m23 = get_num_prop(it, &m, "m23", 0.0);
    let m24 = get_num_prop(it, &m, "m24", 0.0);

    let m31 = get_num_prop(it, &m, "m31", 0.0);
    let m32 = get_num_prop(it, &m, "m32", 0.0);
    let m33 = get_num_prop(it, &m, "m33", 1.0);
    let m34 = get_num_prop(it, &m, "m34", 0.0);

    let def_e = get_num_prop(it, &m, "e", 0.0);
    let m41 = get_num_prop(it, &m, "m41", def_e);
    let def_f = get_num_prop(it, &m, "f", 0.0);
    let m42 = get_num_prop(it, &m, "m42", def_f);
    let m43 = get_num_prop(it, &m, "m43", 0.0);
    let m44 = get_num_prop(it, &m, "m44", 1.0);

    let nx = m11 * px + m21 * py + m31 * pz + m41 * pw;
    let ny = m12 * px + m22 * py + m32 * pz + m42 * pw;
    let nz = m13 * px + m23 * py + m33 * pz + m43 * pw;
    let nw = m14 * px + m24 * py + m34 * pz + m44 * pw;
    dom_point_ctor(it, Value::Undefined, &[Value::Number(nx), Value::Number(ny), Value::Number(nz), Value::Number(nw)])
}

/// `new DOMPoint(x, y, z, w)`（幾何形体プリミティブ。2026-07-17 発見、2026-07-21 拡張）。
/// 仕様どおり `z`/`w` 省略時の既定値はそれぞれ `0`/`1`。`DOMPointReadOnly` も同形状で代用。
/// `matrixTransform(matrix)` で `DOMMatrix` による座標変換に対応。
pub(crate) fn dom_point_ctor(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let x = arg(a, 0).to_number();
    let y = arg(a, 1).to_number();
    let z = arg(a, 2).to_number();
    let w = arg(a, 3).to_number();
    let x = if x.is_nan() { 0.0 } else { x };
    let y = if y.is_nan() { 0.0 } else { y };
    let z = if z.is_nan() { 0.0 } else { z };
    let w = if matches!(arg(a, 3), Value::Undefined) || w.is_nan() { 1.0 } else { w };
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("x".into(), Value::Number(x));
        b.props.insert("y".into(), Value::Number(y));
        b.props.insert("z".into(), Value::Number(z));
        b.props.insert("w".into(), Value::Number(w));
        b.props.insert(
            "matrixTransform".into(),
            nv("matrixTransform", dom_point_matrix_transform),
        );
        b.props.insert(
            "toJSON".into(),
            nv("toJSON", |_: &mut Interp, this: Value, _: &[Value]| {
                if let Value::Object(o) = &this {
                    let clone = Obj::plain();
                    for (k, v) in o.borrow().props.iter() {
                        if k != "toJSON" && k != "matrixTransform" {
                            clone.borrow_mut().props.insert(k.clone(), v.clone());
                        }
                    }
                    return Ok(Value::Object(clone));
                }
                Ok(Value::Undefined)
            }),
        );
    }
    Ok(Value::Object(o))
}

pub(crate) fn dom_rect_from_rect(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let r = arg(a, 0);
    let x = get_num_prop(it, &r, "x", 0.0);
    let y = get_num_prop(it, &r, "y", 0.0);
    let w = get_num_prop(it, &r, "width", 0.0);
    let h = get_num_prop(it, &r, "height", 0.0);
    dom_rect_ctor(it, Value::Undefined, &[Value::Number(x), Value::Number(y), Value::Number(w), Value::Number(h)])
}

pub(crate) fn dom_point_from_point(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let p = arg(a, 0);
    let x = get_num_prop(it, &p, "x", 0.0);
    let y = get_num_prop(it, &p, "y", 0.0);
    let z = get_num_prop(it, &p, "z", 0.0);
    let w = get_num_prop(it, &p, "w", 1.0);
    dom_point_ctor(it, Value::Undefined, &[Value::Number(x), Value::Number(y), Value::Number(z), Value::Number(w)])
}

pub fn dom_matrix_to_string(it: &mut Interp, this: Value, _: &[Value]) -> Result<Value, Value> {
    let is_2d = it.get_property(&this, "is2D").map(|v| v.truthy()).unwrap_or(true);
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m13 = get_num_prop(it, &this, "m13", 0.0);
    let m14 = get_num_prop(it, &this, "m14", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m23 = get_num_prop(it, &this, "m23", 0.0);
    let m24 = get_num_prop(it, &this, "m24", 0.0);
    let m31 = get_num_prop(it, &this, "m31", 0.0);
    let m32 = get_num_prop(it, &this, "m32", 0.0);
    let m33 = get_num_prop(it, &this, "m33", 1.0);
    let m34 = get_num_prop(it, &this, "m34", 0.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);
    let m43 = get_num_prop(it, &this, "m43", 0.0);
    let m44 = get_num_prop(it, &this, "m44", 1.0);
    if is_2d {
        Ok(Value::str(alloc::format!("matrix({}, {}, {}, {}, {}, {})", m11, m12, m21, m22, m41, m42)))
    } else {
        Ok(Value::str(alloc::format!(
            "matrix3d({}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {})",
            m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44
        )))
    }
}

pub fn dom_matrix_multiply(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);

    let other = arg(a, 0);
    let om11 = get_num_prop(it, &other, "m11", 1.0);
    let om12 = get_num_prop(it, &other, "m12", 0.0);
    let om21 = get_num_prop(it, &other, "m21", 0.0);
    let om22 = get_num_prop(it, &other, "m22", 1.0);
    let om41 = get_num_prop(it, &other, "m41", 0.0);
    let om42 = get_num_prop(it, &other, "m42", 0.0);

    let res_a = m11 * om11 + m21 * om12;
    let res_b = m12 * om11 + m22 * om12;
    let res_c = m11 * om21 + m21 * om22;
    let res_d = m12 * om21 + m22 * om22;
    let res_e = m11 * om41 + m21 * om42 + m41;
    let res_f = m12 * om41 + m22 * om42 + m42;

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(res_a), Value::Number(res_b),
        Value::Number(res_c), Value::Number(res_d),
        Value::Number(res_e), Value::Number(res_f)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_matrix_translate(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);

    let tx = arg(a, 0).to_number();
    let ty = arg(a, 1).to_number();
    let tx = if tx.is_nan() { 0.0 } else { tx };
    let ty = if ty.is_nan() { 0.0 } else { ty };

    let res_e = m11 * tx + m21 * ty + m41;
    let res_f = m12 * tx + m22 * ty + m42;

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(m11), Value::Number(m12),
        Value::Number(m21), Value::Number(m22),
        Value::Number(res_e), Value::Number(res_f)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_matrix_scale(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);

    let sx = arg(a, 0).to_number();
    let sy = arg(a, 1).to_number();
    let sx = if sx.is_nan() { 1.0 } else { sx };
    let sy = if matches!(arg(a, 1), Value::Undefined) || sy.is_nan() { sx } else { sy };

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(m11 * sx), Value::Number(m12 * sx),
        Value::Number(m21 * sy), Value::Number(m22 * sy),
        Value::Number(m41), Value::Number(m42)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_matrix_rotate(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let m11 = get_num_prop(it, &this, "m11", 1.0);
    let m12 = get_num_prop(it, &this, "m12", 0.0);
    let m21 = get_num_prop(it, &this, "m21", 0.0);
    let m22 = get_num_prop(it, &this, "m22", 1.0);
    let m41 = get_num_prop(it, &this, "m41", 0.0);
    let m42 = get_num_prop(it, &this, "m42", 0.0);

    let angle_deg = arg(a, 0).to_number();
    let angle_deg = if angle_deg.is_nan() { 0.0 } else { angle_deg };
    let rad = angle_deg * core::f64::consts::PI / 180.0;
    let cos_a = libm::cos(rad);
    let sin_a = libm::sin(rad);

    let res_a = m11 * cos_a + m21 * sin_a;
    let res_b = m12 * cos_a + m22 * sin_a;
    let res_c = m11 * (-sin_a) + m21 * cos_a;
    let res_d = m12 * (-sin_a) + m22 * cos_a;

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(res_a), Value::Number(res_b),
        Value::Number(res_c), Value::Number(res_d),
        Value::Number(m41), Value::Number(m42)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_matrix_invert(it: &mut Interp, this: Value, _: &[Value]) -> Result<Value, Value> {
    let a = get_num_prop(it, &this, "m11", 1.0);
    let b = get_num_prop(it, &this, "m12", 0.0);
    let c = get_num_prop(it, &this, "m21", 0.0);
    let d = get_num_prop(it, &this, "m22", 1.0);
    let e = get_num_prop(it, &this, "m41", 0.0);
    let f = get_num_prop(it, &this, "m42", 0.0);

    let det = a * d - b * c;
    if det == 0.0 || det.is_nan() {
        let arr = Value::Object(Obj::array(alloc::vec![
            Value::Number(f64::NAN), Value::Number(f64::NAN),
            Value::Number(f64::NAN), Value::Number(f64::NAN),
            Value::Number(f64::NAN), Value::Number(f64::NAN)
        ]));
        return dom_matrix_ctor(it, Value::Undefined, &[arr]);
    }
    let inv_a = d / det;
    let inv_b = -b / det;
    let inv_c = -c / det;
    let inv_d = a / det;
    let inv_e = (c * f - d * e) / det;
    let inv_f = (b * e - a * f) / det;

    let arr = Value::Object(Obj::array(alloc::vec![
        Value::Number(inv_a), Value::Number(inv_b),
        Value::Number(inv_c), Value::Number(inv_d),
        Value::Number(inv_e), Value::Number(inv_f)
    ]));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

fn update_matrix_props(target: &Value, new_m: Value) {
    if let (Value::Object(to), Value::Object(from)) = (target, &new_m) {
        let from_props = from.borrow().props.clone();
        let mut b = to.borrow_mut();
        for (k, v) in from_props {
            if k != "toJSON" && k != "toString" && k != "multiply" && k != "translate" && k != "scale" && k != "rotate" && k != "invert"
                && k != "multiplySelf" && k != "translateSelf" && k != "scaleSelf" && k != "rotateSelf" && k != "invertSelf" {
                b.props.insert(k, v);
            }
        }
    }
}

pub fn dom_matrix_translate_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_translate(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_scale_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_scale(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_rotate_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_rotate(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_multiply_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_multiply(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_invert_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_invert(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_skew_x(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let deg = arg(a, 0).to_number();
    let rad = deg * core::f64::consts::PI / 180.0;
    let tan_val = libm::tan(rad);
    let skew_m = dom_matrix_ctor(
        it,
        Value::Undefined,
        &[
            Value::Number(1.0),
            Value::Number(0.0),
            Value::Number(tan_val),
            Value::Number(1.0),
            Value::Number(0.0),
            Value::Number(0.0),
        ],
    )?;
    dom_matrix_multiply(it, this, &[skew_m])
}

pub fn dom_matrix_skew_y(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let deg = arg(a, 0).to_number();
    let rad = deg * core::f64::consts::PI / 180.0;
    let tan_val = libm::tan(rad);
    let skew_m = dom_matrix_ctor(
        it,
        Value::Undefined,
        &[
            Value::Number(1.0),
            Value::Number(tan_val),
            Value::Number(0.0),
            Value::Number(1.0),
            Value::Number(0.0),
            Value::Number(0.0),
        ],
    )?;
    dom_matrix_multiply(it, this, &[skew_m])
}

pub fn dom_matrix_skew_x_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_skew_x(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_skew_y_self(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_m = dom_matrix_skew_y(it, this.clone(), a)?;
    update_matrix_props(&this, new_m);
    Ok(this)
}

pub fn dom_matrix_transform_point(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let pt = arg(a, 0);
    dom_point_matrix_transform(it, pt, &[this])
}

/// `new DOMMatrix([init])` / `DOMMatrixReadOnly` (Geometry Interfaces Module Level 1)
/// 2D / 3D 変換行列コンストラクタ。
pub(crate) fn dom_matrix_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let mut m11 = 1.0; let mut m12 = 0.0; let mut m13 = 0.0; let mut m14 = 0.0;
    let mut m21 = 0.0; let mut m22 = 1.0; let mut m23 = 0.0; let mut m24 = 0.0;
    let mut m31 = 0.0; let mut m32 = 0.0; let mut m33 = 1.0; let mut m34 = 0.0;
    let mut m41 = 0.0; let mut m42 = 0.0; let mut m43 = 0.0; let mut m44 = 1.0;

    let init = arg(a, 0);
    if let Value::Object(o) = &init {
        // `DOMMatrixInit`は仕様上「数値6/16個のシーケンス（配列/TypedArray、この
        // エンジンではどちらも`ObjKind::Array`）」か「`{a,b,c,d,e,f,...}`形式の
        // 平オブジェクト」のいずれか。以前は非配列オブジェクトも`it.iterate_values`
        // へ通していたが、この関数はプレーンオブジェクトに対しても（`Symbol.
        // iterator`を持たないにも関わらず）自身の列挙可能プロパティ値をそのまま
        // 返す簡略実装のため、`{a:2,d:3,e:5,f:10}`（4値）のような非配列dictでも
        // 空でないVecが返ってしまい、`arr.len()>=16`/`>=6`のどちらにも該当せず
        // 何も設定されないまま、本来読むべき`.a`/`.b`/`.c`/`.d`/`.e`/`.f`
        // プロパティ読み取りのelseブランチへ一切到達できないバグだった
        // （`DOMMatrix.fromMatrix({...})`が常に単位行列のまま返る）。
        // `ObjKind::Array`（TypedArrayもこの表現を流用）のときのみ数値シーケンス
        // として扱い、それ以外は無条件でプロパティ読み取り側へ回す。
        // 【2026-07-23続報】この修正自体だけでは`m2.a`/`m2.e`が期待値にならない
        // ことが判明しており、原因はこの関数の別の箇所（`.a`/`.e`プロパティの
        // 最終露出ロジック）に残っている可能性が高い。ロジックとしては正しい
        // 改善のため残すが、根本解決は未完了として記録する。
        let vals_opt = if let crate::os_lib::js::value::ObjKind::Array(ref arr) = o.borrow().kind {
            Some(arr.clone())
        } else {
            None
        };
        if let Some(arr) = vals_opt {
            if arr.len() >= 16 {
                m11 = arr[0].to_number(); m12 = arr[1].to_number(); m13 = arr[2].to_number(); m14 = arr[3].to_number();
                m21 = arr[4].to_number(); m22 = arr[5].to_number(); m23 = arr[6].to_number(); m24 = arr[7].to_number();
                m31 = arr[8].to_number(); m32 = arr[9].to_number(); m33 = arr[10].to_number(); m34 = arr[11].to_number();
                m41 = arr[12].to_number(); m42 = arr[13].to_number(); m43 = arr[14].to_number(); m44 = arr[15].to_number();
            } else if arr.len() >= 6 {
                m11 = arr[0].to_number(); m12 = arr[1].to_number();
                m21 = arr[2].to_number(); m22 = arr[3].to_number();
                m41 = arr[4].to_number(); m42 = arr[5].to_number();
            }
        } else {
            if let Ok(v) = it.get_property(&init, "a") { if !matches!(v, Value::Undefined) { m11 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "b") { if !matches!(v, Value::Undefined) { m12 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "c") { if !matches!(v, Value::Undefined) { m21 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "d") { if !matches!(v, Value::Undefined) { m22 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "e") { if !matches!(v, Value::Undefined) { m41 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "f") { if !matches!(v, Value::Undefined) { m42 = v.to_number(); } }

            if let Ok(v) = it.get_property(&init, "m11") { if !matches!(v, Value::Undefined) { m11 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m12") { if !matches!(v, Value::Undefined) { m12 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m13") { if !matches!(v, Value::Undefined) { m13 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m14") { if !matches!(v, Value::Undefined) { m14 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m21") { if !matches!(v, Value::Undefined) { m21 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m22") { if !matches!(v, Value::Undefined) { m22 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m23") { if !matches!(v, Value::Undefined) { m23 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m24") { if !matches!(v, Value::Undefined) { m24 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m31") { if !matches!(v, Value::Undefined) { m31 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m32") { if !matches!(v, Value::Undefined) { m32 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m33") { if !matches!(v, Value::Undefined) { m33 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m34") { if !matches!(v, Value::Undefined) { m34 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m41") { if !matches!(v, Value::Undefined) { m41 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m42") { if !matches!(v, Value::Undefined) { m42 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m43") { if !matches!(v, Value::Undefined) { m43 = v.to_number(); } }
            if let Ok(v) = it.get_property(&init, "m44") { if !matches!(v, Value::Undefined) { m44 = v.to_number(); } }
        }
    }

    let is_2d = m13 == 0.0 && m14 == 0.0 && m23 == 0.0 && m24 == 0.0 && m31 == 0.0 && m32 == 0.0 && m33 == 1.0 && m34 == 0.0 && m43 == 0.0;
    let is_identity = m11 == 1.0 && m12 == 0.0 && m13 == 0.0 && m14 == 0.0
        && m21 == 0.0 && m22 == 1.0 && m23 == 0.0 && m24 == 0.0
        && m31 == 0.0 && m32 == 0.0 && m33 == 1.0 && m34 == 0.0
        && m41 == 0.0 && m42 == 0.0 && m43 == 0.0 && m44 == 1.0;

    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("a".into(), Value::Number(m11));
        b.props.insert("b".into(), Value::Number(m12));
        b.props.insert("c".into(), Value::Number(m21));
        b.props.insert("d".into(), Value::Number(m22));
        b.props.insert("e".into(), Value::Number(m41));
        b.props.insert("f".into(), Value::Number(m42));

        b.props.insert("m11".into(), Value::Number(m11));
        b.props.insert("m12".into(), Value::Number(m12));
        b.props.insert("m13".into(), Value::Number(m13));
        b.props.insert("m14".into(), Value::Number(m14));
        b.props.insert("m21".into(), Value::Number(m21));
        b.props.insert("m22".into(), Value::Number(m22));
        b.props.insert("m23".into(), Value::Number(m23));
        b.props.insert("m24".into(), Value::Number(m24));
        b.props.insert("m31".into(), Value::Number(m31));
        b.props.insert("m32".into(), Value::Number(m32));
        b.props.insert("m33".into(), Value::Number(m33));
        b.props.insert("m34".into(), Value::Number(m34));
        b.props.insert("m41".into(), Value::Number(m41));
        b.props.insert("m42".into(), Value::Number(m42));
        b.props.insert("m43".into(), Value::Number(m43));
        b.props.insert("m44".into(), Value::Number(m44));

        b.props.insert("is2D".into(), Value::Bool(is_2d));
        b.props.insert("isIdentity".into(), Value::Bool(is_identity));

        b.props.insert("toString".into(), nv("toString", dom_matrix_to_string));
        b.props.insert("multiply".into(), nv("multiply", dom_matrix_multiply));
        b.props.insert("translate".into(), nv("translate", dom_matrix_translate));
        b.props.insert("scale".into(), nv("scale", dom_matrix_scale));
        b.props.insert("rotate".into(), nv("rotate", dom_matrix_rotate));
        b.props.insert("skewX".into(), nv("skewX", dom_matrix_skew_x));
        b.props.insert("skewY".into(), nv("skewY", dom_matrix_skew_y));
        b.props.insert("invert".into(), nv("invert", dom_matrix_invert));

        b.props.insert("multiplySelf".into(), nv("multiplySelf", dom_matrix_multiply_self));
        b.props.insert("translateSelf".into(), nv("translateSelf", dom_matrix_translate_self));
        b.props.insert("scaleSelf".into(), nv("scaleSelf", dom_matrix_scale_self));
        b.props.insert("rotateSelf".into(), nv("rotateSelf", dom_matrix_rotate_self));
        b.props.insert("skewXSelf".into(), nv("skewXSelf", dom_matrix_skew_x_self));
        b.props.insert("skewYSelf".into(), nv("skewYSelf", dom_matrix_skew_y_self));
        b.props.insert("invertSelf".into(), nv("invertSelf", dom_matrix_invert_self));

        b.props.insert("transformPoint".into(), nv("transformPoint", dom_matrix_transform_point));
        b.props.insert(
            "toJSON".into(),
            nv("toJSON", |_: &mut Interp, this: Value, _: &[Value]| {
                if let Value::Object(o) = &this {
                    let clone = Obj::plain();
                    for (k, v) in o.borrow().props.iter() {
                        if k != "toJSON" && k != "toString" && k != "multiply" && k != "translate" && k != "scale" && k != "rotate" && k != "invert"
                            && k != "multiplySelf" && k != "translateSelf" && k != "scaleSelf" && k != "rotateSelf" && k != "invertSelf"
                            && k != "skewX" && k != "skewY" && k != "skewXSelf" && k != "skewYSelf" && k != "transformPoint" {
                            clone.borrow_mut().props.insert(k.clone(), v.clone());
                        }
                    }
                    return Ok(Value::Object(clone));
                }
                Ok(Value::Undefined)
            }),
        );
    }
    Ok(Value::Object(o))
}

pub fn dom_quad_get_bounds(it: &mut Interp, this: Value, _: &[Value]) -> Result<Value, Value> {
    let p1 = it.get_property(&this, "p1").unwrap_or(Value::Undefined);
    let p2 = it.get_property(&this, "p2").unwrap_or(Value::Undefined);
    let p3 = it.get_property(&this, "p3").unwrap_or(Value::Undefined);
    let p4 = it.get_property(&this, "p4").unwrap_or(Value::Undefined);

    let x1 = get_num_prop(it, &p1, "x", 0.0);
    let y1 = get_num_prop(it, &p1, "y", 0.0);
    let x2 = get_num_prop(it, &p2, "x", 0.0);
    let y2 = get_num_prop(it, &p2, "y", 0.0);
    let x3 = get_num_prop(it, &p3, "x", 0.0);
    let y3 = get_num_prop(it, &p3, "y", 0.0);
    let x4 = get_num_prop(it, &p4, "x", 0.0);
    let y4 = get_num_prop(it, &p4, "y", 0.0);

    let min_x = x1.min(x2).min(x3).min(x4);
    let max_x = x1.max(x2).max(x3).max(x4);
    let min_y = y1.min(y2).min(y3).min(y4);
    let max_y = y1.max(y2).max(y3).max(y4);

    let w = (max_x - min_x).max(0.0) as i32;
    let h = (max_y - min_y).max(0.0) as i32;
    Ok(Value::Object(make_dom_rect(min_x as i32, min_y as i32, w, h)))
}



/// `new DOMQuad(p1, p2, p3, p4)` (Geometry Interfaces Module Level 1)
pub(crate) fn dom_quad_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let p1 = if matches!(arg(a, 0), Value::Undefined) { dom_point_ctor(it, Value::Undefined, &[])? } else { arg(a, 0) };
    let p2 = if matches!(arg(a, 1), Value::Undefined) { dom_point_ctor(it, Value::Undefined, &[])? } else { arg(a, 1) };
    let p3 = if matches!(arg(a, 2), Value::Undefined) { dom_point_ctor(it, Value::Undefined, &[])? } else { arg(a, 2) };
    let p4 = if matches!(arg(a, 3), Value::Undefined) { dom_point_ctor(it, Value::Undefined, &[])? } else { arg(a, 3) };

    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("p1".into(), p1.clone());
        b.props.insert("p2".into(), p2.clone());
        b.props.insert("p3".into(), p3.clone());
        b.props.insert("p4".into(), p4.clone());

        b.props.insert("getBounds".into(), nv("getBounds", dom_quad_get_bounds));
        b.props.insert(
            "toJSON".into(),
            nv("toJSON", |_: &mut Interp, this: Value, _: &[Value]| {
                if let Value::Object(o) = &this {
                    let clone = Obj::plain();
                    for (k, v) in o.borrow().props.iter() {
                        if k != "toJSON" && k != "getBounds" {
                            clone.borrow_mut().props.insert(k.clone(), v.clone());
                        }
                    }
                    return Ok(Value::Object(clone));
                }
                Ok(Value::Undefined)
            }),
        );
    }
    Ok(Value::Object(o))
}
pub(crate) fn make_dom_rect(x: i32, y: i32, w: i32, h: i32) -> ObjRef {
    let o = Obj::plain();
    {
        let mut b = o.borrow_mut();
        b.props.insert("x".into(), Value::Number(x as f64));
        b.props.insert("left".into(), Value::Number(x as f64));
        b.props.insert("y".into(), Value::Number(y as f64));
        b.props.insert("top".into(), Value::Number(y as f64));
        b.props.insert("width".into(), Value::Number(w as f64));
        b.props.insert("height".into(), Value::Number(h as f64));
        b.props
            .insert("right".into(), Value::Number((x + w) as f64));
        b.props
            .insert("bottom".into(), Value::Number((y + h) as f64));
    }
    o
}

pub fn dom_get_bounding_client_rect(
    it: &mut Interp,
    this: Value,
    _a: &[Value],
) -> Result<Value, Value> {
    let (x, y, w, h) = this_dom_idx(&this)
        .and_then(|idx| it.dom.borrow().get_rect(idx))
        .unwrap_or((0, 0, 0, 0));
    Ok(Value::Object(make_dom_rect(x, y, w, h)))
}

/// `element.getClientRects()`（DOM 標準。丸ごと未対応だった。本来は行ボックス
/// 単位で複数の `DOMRect` を返すが、この処理系にはテキストの行フラグメント
/// モデル自体が無い（`text-overflow`/インライン折返し等と同じ既存の簡略化と
/// 同方針）ため、要素1つにつき `getBoundingClientRect()` と同じ矩形を0個
/// （未レンダリング）か1個だけ持つ配列として返す）。
pub fn dom_get_client_rects(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let rect = this_dom_idx(&this).and_then(|idx| it.dom.borrow().get_rect(idx));
    let items = match rect {
        Some((x, y, w, h)) => alloc::vec![Value::Object(make_dom_rect(x, y, w, h))],
        None => Vec::new(),
    };
    Ok(Value::Object(Obj::array(items)))
}

/// getComputedStyle(el): 算出スタイルを読む host プロキシ `computed:idx` を返す。
pub(crate) fn get_computed_style(_it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    match this_dom_idx(&arg(a, 0)) {
        Some(idx) => Ok(Value::Object(Obj::host(&format!("computed:{}", idx)))),
        None => Ok(Value::Object(Obj::host("computed:18446744073709551615"))), // 無効idx
    }
}

/// computedStyle.getPropertyValue(name): kebab-case のプロパティ値を返す。
pub fn computed_get_property_value(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "computed:") {
        let prop = arg(a, 0).to_js_string();
        return Ok(Value::str(it.dom.borrow().get_computed(idx, &prop)));
    }
    Ok(Value::str(""))
}

pub fn dom_matches(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        // `:scope`（丸ごと未対応だった）。`el.matches()` における `:scope` は
        // 呼び出し元の要素自身を指す。
        return Ok(Value::Bool(it.dom.borrow().node_matches_scoped(idx, &sel, Some(idx))));
    }
    Ok(Value::Bool(false))
}

/// closest(selector): 自身を含め祖先方向へ最初にマッチする要素。無ければ null。
pub fn dom_closest(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(start) = this_dom_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        let mut cur = Some(start);
        let mut guard = 0;
        while let Some(c) = cur {
            // `:scope`（丸ごと未対応だった）。`el.closest()` における `:scope` は
            // 探索中の祖先ではなく、呼び出し元の起点要素（`start`）を指す。
            if dom.node_matches_scoped(c, &sel, Some(start)) {
                return Ok(dom_handle(Some(c)));
            }
            cur = dom.nodes.get(c).and_then(|n| n.parent);
            guard += 1;
            if guard > dom.nodes.len() {
                break;
            }
        }
    }
    Ok(Value::Null)
}

/// element.querySelector: 子孫に限定して最初にマッチする要素。`:scope`
/// （Selectors Level 4。丸ごと未対応だった）は呼び出し元の要素自身を指す。
pub fn dom_element_query_selector(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        for c in dom.query_all_scoped(&sel, Some(idx)) {
            if dom.is_ancestor_of(idx, c) {
                return Ok(dom_handle(Some(c)));
            }
        }
    }
    Ok(Value::Null)
}

/// element.querySelectorAll: 子孫に限定してマッチする要素配列。`:scope`
/// （Selectors Level 4。丸ごと未対応だった）は呼び出し元の要素自身を指す。
pub fn dom_element_query_selector_all(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let mut items: Vec<Value> = Vec::new();
    if let Some(idx) = this_dom_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        for c in dom.query_all_scoped(&sel, Some(idx)) {
            if dom.is_ancestor_of(idx, c) {
                items.push(Value::Object(Obj::dom(c)));
            }
        }
    }
    Ok(Value::Object(Obj::array(items)))
}

/// `element.getElementsByClassName(name)`（`document.getElementsByClassName` は
/// 対応済みだったが、要素インスタンス版が丸ごと未対応だった。`querySelectorAll` と
/// 同じ「自身の子孫のみに絞り込む」ロジックを再利用する）。
pub fn dom_element_get_elements_by_class_name(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let mut items: Vec<Value> = Vec::new();
    if let Some(idx) = this_dom_idx(&this) {
        let raw = arg(a, 0).to_js_string();
        let sel_classes: Vec<String> = raw
            .split_whitespace()
            .map(|c| alloc::format!(".{}", c))
            .collect();
        let sel = if sel_classes.is_empty() {
            alloc::format!(".__invalid_class__")
        } else {
            sel_classes.concat()
        };
        let dom = it.dom.borrow();
        for c in dom.query_all(&sel) {
            if dom.is_ancestor_of(idx, c) {
                items.push(Value::Object(Obj::dom(c)));
            }
        }
    }
    Ok(Value::Object(Obj::array(items)))
}
/// `element.getElementsByTagName(tag)`（上記と同じ理由で丸ごと未対応だった）。
pub fn dom_element_get_elements_by_tag_name(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let mut items: Vec<Value> = Vec::new();
    if let Some(idx) = this_dom_idx(&this) {
        let tag = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        // 【2026-09-05 バグ修正】以前は文書全体を `query_all` で引いてから
        // 先祖関係で絞っていた。`query_all` は**文書に繋がっていないノードを
        // 除外する**ので、切り離した要素の子孫が一切返らなかった。
        // 仕様では接続の有無に関係なく自分の子孫を返す。詳細は
        // `dom_bridge::descendants_by_tag_name` の説明。
        for c in dom.descendants_by_tag_name(idx, &tag) {
            items.push(Value::Object(Obj::dom(c)));
        }
    }
    Ok(Value::Object(Obj::array(items)))
}
/// `element.getElementsByTagNameNS(namespace, localName)`（丸ごと未対応だった）。
pub fn dom_element_get_elements_by_tag_name_ns(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let mut items: Vec<Value> = Vec::new();
    if let Some(idx) = this_dom_idx(&this) {
        let tag = if a.len() >= 2 {
            arg(a, 1).to_js_string()
        } else {
            arg(a, 0).to_js_string()
        };
        let dom = it.dom.borrow();
        for c in dom.query_all(&tag) {
            if dom.is_ancestor_of(idx, c) {
                items.push(Value::Object(Obj::dom(c)));
            }
        }
    }
    Ok(Value::Object(Obj::array(items)))
}

pub fn dom_set_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        let val = arg(a, 1).to_js_string();
        it.dom.borrow_mut().set_attr(idx, &name, &val);
        if name == "src" && val.starts_with("blob:") {
            let is_media = it
                .dom
                .borrow()
                .nodes
                .get(idx)
                .map(|n| n.tag == "video" || n.tag == "audio")
                .unwrap_or(false);
            if is_media {
                let ms_val = match it.global.borrow().vars.get("__media_source_urls") {
                    Some(Value::Object(r)) => r.borrow().props.get(&val).cloned(),
                    _ => None,
                };
                if let Some(ms) = ms_val {
                    super::media_source_open_internal(it, &ms);
                }
            }
        }
    }
    Ok(Value::Undefined)
}

/// element.checkValidity() / reportValidity(): 現在値で制約バリデーションを実行し、
/// 妥当なら true、違反があれば false を返す。
/// （invalid イベントはフォーム送信経路 submit_form 側で WebEngine が発火する。
///  Interp からは DOM イベント発火経路が無いため、ここでは bool 判定のみ。）
/// **重要**: `<form>` 自身に対する `checkValidity()` が、フォームの子孫コントロール
/// を一切見ず `validate_field(form_idx, ...)` を直接呼んでいたため、`<form>` タグは
/// `type` が email/url/number のいずれにも一致せず常に無条件で `true`（妥当）を
/// 返してしまうバグだった（`WebEngine::submit_form` 側は `descendants_by_tags` で
/// 子孫を正しく走査していたのに、JS から呼ぶ `checkValidity()` だけが非対称だった）。
pub fn dom_check_validity(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let tag = it.dom.borrow().nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
        if tag == "form" {
            let dom = it.dom.borrow();
            // `form_associated_controls`は子孫に加え、`form="このformのid"`属性で
            // フォーム外から明示的に関連付けられたコントロール（HTML5仕様の
            // 「form owner」）も含む。以前は`descendants_by_tags`（子孫のみ）
            // だったため、`<form>`の外に置かれた`<input form="...">`が
            // `checkValidity()`の対象から漏れる兄弟ギャップだった。
            let fields = dom.form_associated_controls(idx, &["input", "textarea", "select"]);
            let all_valid = fields.iter().all(|&node| {
                let value = dom.effective_form_value(node);
                dom.validate_field(node, &value).is_none()
            });
            return Ok(Value::Bool(all_valid));
        }
        let value = it.dom.borrow().effective_form_value(idx);
        let valid = it.dom.borrow().validate_field(idx, &value).is_none();
        return Ok(Value::Bool(valid));
    }
    Ok(Value::Bool(true))
}

/// element.setCustomValidity(msg): カスタム検証メッセージを設定。空文字でクリア。
/// 内部的には隠し属性 `_custom_validity` に保存し、validate_field が最優先で参照する。
pub fn dom_set_custom_validity(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let msg = arg(a, 0).to_js_string();
        if msg.is_empty() {
            it.dom.borrow_mut().remove_attr(idx, "_custom_validity");
        } else {
            it.dom.borrow_mut().set_attr(idx, "_custom_validity", &msg);
        }
    }
    Ok(Value::Undefined)
}

/// `classList.forEach(fn)`（丸ごと未対応だった。`DOMTokenList` は仕様上イテラブル/
/// `forEach` を持つ配列風のオブジェクトだが、この処理系の `classList` は専用の
/// `Host("classList:N")` プロキシで表現されており、`Symbol.iterator`/`forEach` が
/// 一切配線されていなかった。`for (const c of el.classList)` も同じ理由で常に
/// 何も反復しない黙殺バグだった — `iterate_values()` 側の修正と対）。
pub fn dom_classlist_for_each(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let classes = it.dom.borrow().nodes.get(idx).map(|n| n.classes.clone()).unwrap_or_default();
        let cb = arg(a, 0);
        for (i, c) in classes.into_iter().enumerate() {
            it.call_value(&cb, Value::Undefined, &[Value::str(c), Value::Number(i as f64)])?;
        }
    }
    Ok(Value::Undefined)
}
pub fn dom_classlist_add(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        for v in a {
            it.dom
                .borrow_mut()
                .class_add(idx, &v.to_js_string());
        }
    }
    Ok(Value::Undefined)
}

pub fn dom_classlist_remove(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        for v in a {
            it.dom
                .borrow_mut()
                .class_remove(idx, &v.to_js_string());
        }
    }
    Ok(Value::Undefined)
}

/// `classList.supports(token)`（DOM Standard §4.3）。
pub fn dom_classlist_supports(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(false))
}


/// `classList.toggle(name, force)`。以前は第2引数 `force`（真偽値を渡すと現在の状態に
/// 関係なく強制的に付与/除去する）を完全に無視し、常に単純なトグルだけを行っていた
/// （`el.classList.toggle('active', isActive)` という定番パターンが動かなかった）。
pub fn dom_classlist_toggle(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let cls = arg(a, 0).to_js_string();
        if matches!(arg(a, 1), Value::Undefined) {
            let on = it.dom.borrow_mut().class_toggle(idx, &cls);
            return Ok(Value::Bool(on));
        }
        let force = arg(a, 1).truthy();
        if force {
            it.dom.borrow_mut().class_add(idx, &cls);
        } else {
            it.dom.borrow_mut().class_remove(idx, &cls);
        }
        return Ok(Value::Bool(force));
    }
    Ok(Value::Bool(false))
}

pub fn dom_classlist_contains(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        return Ok(Value::Bool(
            it.dom
                .borrow()
                .class_contains(idx, &arg(a, 0).to_js_string()),
        ));
    }
    Ok(Value::Bool(false))
}

/// `classList.entries()`/`.keys()`/`.values()`（丸ごと未対応だった。`DOMTokenList`
/// は仕様上 `forEach`/`Symbol.iterator` に加えこの3メソッドも持つが、`forEach`と
/// for-of 反復（`iterable_values`）のみ配線され、これらの明示イテレータ取得
/// メソッドは未配線だった。`Array.prototype` の同名メソッドと同じく既存の
/// `make_iterator` ヘルパーへ委譲する薄い実装。
pub fn dom_classlist_entries(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let classes = it.dom.borrow().nodes.get(idx).map(|n| n.classes.clone()).unwrap_or_default();
        let out: Vec<Value> = classes
            .into_iter()
            .enumerate()
            .map(|(i, c)| Value::Object(Obj::array(alloc::vec![Value::Number(i as f64), Value::str(c)])))
            .collect();
        return Ok(Value::Object(make_iterator(out)));
    }
    Ok(Value::Object(make_iterator(alloc::vec![])))
}
pub fn dom_classlist_keys(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let n = it.dom.borrow().nodes.get(idx).map(|n| n.classes.len()).unwrap_or(0);
        return Ok(Value::Object(make_iterator(
            (0..n).map(|i| Value::Number(i as f64)).collect(),
        )));
    }
    Ok(Value::Object(make_iterator(alloc::vec![])))
}
pub fn dom_classlist_values(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let classes = it.dom.borrow().nodes.get(idx).map(|n| n.classes.clone()).unwrap_or_default();
        return Ok(Value::Object(make_iterator(
            classes.into_iter().map(Value::str).collect(),
        )));
    }
    Ok(Value::Object(make_iterator(alloc::vec![])))
}

pub(crate) fn document_create_element(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let tag = arg(a, 0).to_js_string();
    let idx = it.dom.borrow_mut().create_element(&tag);
    // 定義済みのカスタム要素ならその場で構築する（仕様の「同期カスタム要素フラグ」）。
    if tag.contains('-') {
        it.ce_try_upgrade(idx, false);
    }
    Ok(Value::Object(Obj::dom(idx)))
}
/// `document.createElementNS(namespaceURI, qualifiedName)`（丸ごと未対応
/// だった。SVG 要素（`document.createElementNS('http://www.w3.org/2000/svg',
/// 'circle')` 等）を JS から動的生成する標準的な定番パターン）。この処理系は
/// `*AttributeNS` 系と同じく XML 名前空間を一切モデル化していないため、
/// 第1引数（namespace）は無視して非 NS 版の `createElement` へ委譲する
/// 簡略実装（多くの実用コードは SVG 名前空間しか渡さないため実害は小さい）。
pub(crate) fn document_create_element_ns(it: &mut Interp, t: Value, a: &[Value]) -> Result<Value, Value> {
    document_create_element(it, t, &[arg(a, 1)])
}

/// `new Option(text?, value?, defaultSelected?, selected?)`（HTML5。丸ごと
/// 未対応だった）。`document.createElement('option')` を土台に組み立てる。
pub(crate) fn option_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let idx = it.dom.borrow_mut().create_element("option");
    let text = arg(a, 0);
    if !matches!(text, Value::Undefined) {
        it.dom.borrow_mut().set_text_content(idx, &text.to_js_string());
    }
    let value = arg(a, 1);
    if !matches!(value, Value::Undefined) {
        it.dom.borrow_mut().set_attr(idx, "value", &value.to_js_string());
    }
    if arg(a, 2).truthy() || arg(a, 3).truthy() {
        it.dom.borrow_mut().set_attr(idx, "selected", "selected");
    }
    Ok(Value::Object(Obj::dom(idx)))
}

pub(crate) fn document_create_text_node(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let text = arg(a, 0).to_js_string();
    let idx = it.dom.borrow_mut().create_text_node(&text);
    Ok(Value::Object(Obj::dom(idx)))
}

pub(crate) fn document_create_comment(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let text = arg(a, 0).to_js_string();
    let idx = it.dom.borrow_mut().create_comment(&text);
    Ok(Value::Object(Obj::dom(idx)))
}

pub(crate) fn document_create_document_fragment(it: &mut Interp, _t: Value, _a: &[Value]) -> Result<Value, Value> {
    let idx = it.dom.borrow_mut().create_document_fragment();
    Ok(Value::Object(Obj::dom(idx)))
}

pub(crate) fn split_css_rules(css: &str) -> alloc::vec::Vec<String> {
    let mut rules = alloc::vec![];
    let mut current_rule = String::new();
    let mut depth = 0;
    for c in css.chars() {
        current_rule.push(c);
        if c == '{' {
            depth += 1;
        } else if c == '}' {
            if depth > 0 {
                depth -= 1;
            }
            if depth == 0 {
                let trimmed = current_rule.trim();
                if !trimmed.is_empty() {
                    rules.push(trimmed.to_string());
                }
                current_rule.clear();
            }
        }
    }
    let trimmed = current_rule.trim();
    if !trimmed.is_empty() {
        rules.push(trimmed.to_string());
    }
    rules
}

pub(crate) fn dom_stylesheet_insert_rule(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let rule_text = arg(a, 0).to_js_string();
    let insert_index = arg(a, 1).to_number() as usize;
    if let Value::Object(o) = this {
        if let ObjKind::Host(t) = &o.borrow().kind {
            if let Some(rest) = t.strip_prefix("stylesheet:") {
                let idx: usize = rest.parse().unwrap_or(usize::MAX);
                let text = it.dom.borrow().get_text_content(idx);
                let mut rules = split_css_rules(&text);
                let actual_index = insert_index.min(rules.len());
                rules.insert(actual_index, rule_text);
                let new_css = rules.join("\n");
                it.dom.borrow_mut().set_text_content(idx, &new_css);
                return Ok(Value::Number(actual_index as f64));
            }
        }
    }
    Ok(Value::Number(0.0))
}

pub(crate) fn dom_stylesheet_delete_rule(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let delete_index = arg(a, 0).to_number() as usize;
    if let Value::Object(o) = this {
        if let ObjKind::Host(t) = &o.borrow().kind {
            if let Some(rest) = t.strip_prefix("stylesheet:") {
                let idx: usize = rest.parse().unwrap_or(usize::MAX);
                let text = it.dom.borrow().get_text_content(idx);
                let mut rules = split_css_rules(&text);
                if delete_index < rules.len() {
                    rules.remove(delete_index);
                    let new_css = rules.join("\n");
                    it.dom.borrow_mut().set_text_content(idx, &new_css);
                }
            }
        }
    }
    Ok(Value::Undefined)
}

pub fn dom_append_child(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let child = arg(a, 0);
    if let (Some(p), Some(c)) = (this_dom_idx(&this), this_dom_idx(&child)) {
        it.dom.borrow_mut().append_child(p, c);
    }
    Ok(child) // appendChild は追加した子を返す。
}

/// parent.insertBefore(newChild, refChild)。ref が null/undefined なら末尾。
pub fn dom_insert_before(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let new_child = arg(a, 0);
    if let (Some(p), Some(nc)) = (this_dom_idx(&this), this_dom_idx(&new_child)) {
        let rc = this_dom_idx(&arg(a, 1)); // null/undefined → None
        if let Some(r) = rc {
            let is_child =
                it.dom.borrow().nodes.get(r).and_then(|n| n.parent) == Some(p);
            if !is_child {
                return Err(make_dom_exception(
                    "NotFoundError",
                    "The node before which the new node is to be inserted is not a child of this node",
                ));
            }
        }
        it.dom.borrow_mut().insert_before(p, nc, rc);
    }
    Ok(new_child)
}

/// `parent.moveBefore(movedNode, referenceNode)`（DOM。2025年にChromeへ
/// 実装が入った比較的新しいAPI。丸ごと未対応だった）。仕様上の主眼は
/// 「`remove()`してから`insertBefore()`する」場合と異なり、`<iframe>`の
/// 読み込み状態・`<video>`の再生状態・カスタム要素のライフサイクル
/// コールバック発火等を保持したまま木構造内を移動できる点にあるが、
/// この処理系にはそれらの「保持すべき生きた状態」自体が実装されて
/// いない（`<iframe>`は実際のナビゲーション状態を持たず、`<video>`は
/// 実再生をしない等）ため、実務上は`insertBefore`と同じ「detachしてから
/// 指定位置へ挿入」の`insert_before`（`dom_bridge.rs`。既に自動で元の
/// 親から外す実装）をそのまま再利用する誠実な簡略実装で十分に仕様どおり
/// 動作する。`referenceNode`（`null`可）が`this`の子でない場合は
/// `insertBefore`と同じ`NotFoundError`規則を踏襲。2026-07-18 発見・実装。
pub fn dom_move_before(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let moved_node = arg(a, 0);
    if let (Some(p), Some(mn)) = (this_dom_idx(&this), this_dom_idx(&moved_node)) {
        let rc = this_dom_idx(&arg(a, 1));
        if let Some(r) = rc {
            let is_child = it.dom.borrow().nodes.get(r).and_then(|n| n.parent) == Some(p);
            if !is_child {
                return Err(make_dom_exception(
                    "NotFoundError",
                    "The node before which the moved node is to be inserted is not a child of this node",
                ));
            }
        }
        it.dom.borrow_mut().insert_before(p, mn, rc);
    }
    Ok(moved_node)
}

/// `select.options.add(option, before?)`（HTML5 `HTMLOptionsCollection`。
/// 動的にドロップダウンを構築する `select.options.add(new Option(...))` という
/// 定番イディオムが、`options` が素の配列（メソッドを一切持たない）を返す
/// だけだったため丸ごと未対応（`TypeError: not a function`）だった。`options`
/// 取得時に配列オブジェクト自身へ `_select_idx`（隠しプロパティ。既存の
/// `_is_headers`/`_ta_kind` 等と同じ内部タグ付けパターン）を仕込んでおき、
/// この配列を経由して元の `<select>` を辿れるようにする。`before` は仕様どおり
/// 省略時は末尾追加、数値ならその位置の既存 option の前、`<option>` 要素
/// そのものでもよい。
pub fn select_options_add(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let select_idx = match &this {
        Value::Object(o) => o.borrow().props.get("_select_idx").map(|v| v.to_number() as usize),
        _ => None,
    };
    let (Some(select_idx), Some(opt_idx)) = (select_idx, this_dom_idx(&arg(a, 0))) else {
        return Ok(Value::Undefined);
    };
    let before = arg(a, 1);
    let ref_idx = match &before {
        Value::Number(n) => it.dom.borrow().select_options(select_idx).get(*n as usize).copied(),
        Value::Object(_) => this_dom_idx(&before),
        _ => None,
    };
    it.dom.borrow_mut().insert_before(select_idx, opt_idx, ref_idx);
    Ok(Value::Undefined)
}
/// `select.add(element, before)`（`HTMLSelectElement`直下の便利メソッド。
/// `select.options.add`と全く同じ意味だが、`this`が`options`コレクション
/// 配列ではなく`<select>`要素自身になる点だけが違う。丸ごと未対応
/// だった。`select_options_add`とほぼ同じロジックだが、`_select_idx`
/// 隠しプロパティ経由ではなく`this_dom_idx`で直接`<select>`のインデックス
/// を取る。2026-07-18 発見・実装）。
pub fn dom_select_add(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let (Some(select_idx), Some(opt_idx)) = (this_dom_idx(&this), this_dom_idx(&arg(a, 0))) else {
        return Ok(Value::Undefined);
    };
    let before = arg(a, 1);
    let ref_idx = match &before {
        Value::Number(n) => it.dom.borrow().select_options(select_idx).get(*n as usize).copied(),
        Value::Object(_) => this_dom_idx(&before),
        _ => None,
    };
    it.dom.borrow_mut().insert_before(select_idx, opt_idx, ref_idx);
    Ok(Value::Undefined)
}
/// `select.options.remove(index)`（`HTMLOptionsCollection`。上記 `add` と対に
/// なる、指定インデックスの `<option>` を取り除く定番メソッド）。
pub fn select_options_remove(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let select_idx = match &this {
        Value::Object(o) => o.borrow().props.get("_select_idx").map(|v| v.to_number() as usize),
        _ => None,
    };
    let Some(select_idx) = select_idx else {
        return Ok(Value::Undefined);
    };
    let n = arg(a, 0).to_number() as usize;
    // `if let Some(x) = obj.borrow()...` は scrutinee の一時 `Ref` が if-let ブロック
    // 終端まで生き続けるため、ブロック内で `borrow_mut()` すると「RefCell already
    // borrowed」で panic する（このファイルの `report_error` 修正と同型のバグ。
    // 一度 owned な値へ materialize してから `if let` することで回避する）。
    let opt_idx = it.dom.borrow().select_options(select_idx).get(n).copied();
    if let Some(opt_idx) = opt_idx {
        it.dom.borrow_mut().remove_child(select_idx, opt_idx);
    }
    Ok(Value::Undefined)
}
/// `select.options.namedItem(name)`（`HTMLOptionsCollection`。`id`/`name`
/// 属性が一致する `<option>` を探す定番メソッド。見つからなければ仕様どおり
/// `null`）。
pub fn select_options_named_item(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let select_idx = match &this {
        Value::Object(o) => o.borrow().props.get("_select_idx").map(|v| v.to_number() as usize),
        _ => None,
    };
    let Some(select_idx) = select_idx else {
        return Ok(Value::Null);
    };
    let name = arg(a, 0).to_js_string();
    let dom = it.dom.borrow();
    for opt_idx in dom.select_options(select_idx) {
        if dom.get_attr(opt_idx, "id").as_deref() == Some(name.as_str())
            || dom.get_attr(opt_idx, "name").as_deref() == Some(name.as_str())
        {
            return Ok(Value::Object(Obj::dom(opt_idx)));
        }
    }
    Ok(Value::Null)
}

/// parent.replaceChild(newChild, oldChild)。置換された old を返す。
pub fn dom_replace_child(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let old_child = arg(a, 1);
    if let (Some(p), Some(nc), Some(oc)) = (
        this_dom_idx(&this),
        this_dom_idx(&arg(a, 0)),
        this_dom_idx(&old_child),
    ) {
        // `insertBefore`と同じ理由（詳細はそちらの同種コメント参照）で、
        // `oldChild`が`this`の子でない場合は仕様上`NotFoundError`を投げる
        // べきだが、以前は`replace_child`（`dom_bridge.rs`）が黙って何もせず
        // 成功したかのように振る舞っていた。
        let is_child = it.dom.borrow().nodes.get(oc).and_then(|n| n.parent) == Some(p);
        if !is_child {
            return Err(make_dom_exception(
                "NotFoundError",
                "The node to be replaced is not a child of this node",
            ));
        }
        it.dom.borrow_mut().replace_child(p, nc, oc);
    }
    Ok(old_child)
}

/// 引数を DOM ノード idx に解決（要素はそのまま、文字列はテキストノード生成）。
pub(crate) fn arg_to_node(it: &mut Interp, v: &Value) -> Option<usize> {
    match this_dom_idx(v) {
        Some(i) => Some(i),
        None => match v {
            Value::Undefined | Value::Null => None,
            other => Some(it.dom.borrow_mut().create_text_node(&other.to_js_string())),
        },
    }
}

/// element.insertAdjacentHTML(position, html)。
/// `element.getHTML(options?)`（DOM。`innerHTML`ゲッターの明示的メソッド版
/// として2024年頃に標準化。丸ごと未対応だった）。仕様上の`options`
/// （`{serializableShadowRoots, shadowRoots}`）はShadow DOM自体が
/// この処理系に存在しないため意味を持たず無視する。`innerHTML`と全く同じ
/// `get_inner_html`をそのまま呼ぶだけの簡略実装。2026-07-18 発見・実装。
pub fn dom_get_html(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        return Ok(Value::str(it.dom.borrow().get_inner_html(idx)));
    }
    Ok(Value::str(""))
}

/// `element.setHTMLUnsafe(html)`（DOM。`innerHTML`セッターのTrusted
/// Types検証を明示的にバイパスする版として標準化。丸ごと未対応だった）。
/// この処理系にはTrusted Typesの強制自体が実装されていないため、
/// `innerHTML`セッターと全く同じ`set_inner_html`をそのまま呼ぶだけの
/// 簡略実装で仕様上の可視的な違いは無い。2026-07-18 発見・実装。
pub fn dom_set_html_unsafe(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let html = arg(a, 0).to_js_string();
        it.dom.borrow_mut().set_inner_html(idx, &html);
    }
    Ok(Value::Undefined)
}

pub fn dom_insert_adjacent_html(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        // `position` は仕様上 ASCII 大文字小文字を無視して照合すべきだが
        // （`"beforeBegin"`/`"BEFOREEND"` 等も有効）、以前は完全一致のみで
        // 小文字以外を渡すと静かに no-op になっていた。
        let pos = arg(a, 0).to_js_string().to_lowercase();
        let html = arg(a, 1).to_js_string();
        it.dom.borrow_mut().insert_adjacent_html(idx, &pos, &html);
    }
    Ok(Value::Undefined)
}
/// element.insertAdjacentElement(position, element)。
pub fn dom_insert_adjacent_element(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let el = arg(a, 1);
    if let (Some(idx), Some(node)) = (this_dom_idx(&this), this_dom_idx(&el)) {
        let pos = arg(a, 0).to_js_string().to_lowercase();
        it.dom.borrow_mut().insert_adjacent_node(idx, &pos, node);
    }
    Ok(el)
}
/// element.insertAdjacentText(position, text)。
pub fn dom_insert_adjacent_text(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let pos = arg(a, 0).to_js_string().to_lowercase();
        let node = it
            .dom
            .borrow_mut()
            .create_text_node(&arg(a, 1).to_js_string());
        it.dom.borrow_mut().insert_adjacent_node(idx, &pos, node);
    }
    Ok(Value::Undefined)
}
/// element.toggleAttribute(name[, force]) → 操作後の存在を返す。
pub fn dom_toggle_attribute(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let name = arg(a, 0).to_js_string();
        let has = it.dom.borrow().has_attr(idx, &name);
        let new_state = if a.len() > 1 && !matches!(arg(a, 1), Value::Undefined) {
            arg(a, 1).truthy()
        } else {
            !has
        };
        if new_state {
            it.dom.borrow_mut().set_attr(idx, &name, "");
        } else {
            it.dom.borrow_mut().remove_attr(idx, &name);
        }
        return Ok(Value::Bool(new_state));
    }
    Ok(Value::Bool(false))
}

/// `dialog.show()`（`<dialog>` が丸ごと未対応だった）。`open` 属性を付ける
/// だけの簡略実装。
pub fn dom_dialog_show(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dom.borrow_mut().set_attr(idx, "open", "open");
    }
    Ok(Value::Undefined)
}

/// `dialog.showModal()`。以前は`.show()`と全く同じ`dom_dialog_show`を共有して
/// おり、モーダル/非モーダルの区別自体が存在しなかった（`showModal()`本来の
/// モーダルフォーカストラップ・`::backdrop`描画は依然対象外だが対象外）。CSS
/// `:modal`疑似クラス（丸ごと未対応だった。2026-07-18 発見・実装）が判定
/// できるよう、`open`属性に加え`:fullscreen`と同じ内部専用属性パターンで
/// `_modal`を書き込む点だけが`.show()`と異なる。
pub fn dom_dialog_show_modal(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let mut dom = it.dom.borrow_mut();
        dom.set_attr(idx, "open", "open");
        dom.set_attr(idx, "_modal", "1");
    }
    Ok(Value::Undefined)
}

/// `dialog.close(returnValue?)`。`open` 属性を外し、`returnValue` を設定してから
/// `close` イベントを発火する（仕様どおり）。DOM 要素は汎用の `Obj.props` ではなく
/// `interp.rs` 側の明示的なプロパティ一覧を介してアクセスされるため、`checked`/
/// `indeterminate` と同じ「内部専用の `_` プレフィックス属性キー」パターン
/// （`_return_value`）で持たせる（`this.props` へ直接書いても読み出し経路が
/// 無く反映されない）。
pub fn dom_dialog_close(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        {
            let mut dom = it.dom.borrow_mut();
            dom.remove_attr(idx, "open");
            dom.remove_attr(idx, "_modal");
        }
        if !a.is_empty() {
            it.dom
                .borrow_mut()
                .set_attr(idx, "_return_value", &arg(a, 0).to_js_string());
        }
        let _ = it.dispatch_event_in_interp(idx, "close", &[]);
    }
    Ok(Value::Undefined)
}

// `dialog.requestClose(returnValue?)`（HTML Living Standard。`.close()`と
// 違い、閉じる直前に取消可能な`cancel`イベントを発火し、リスナが
// `preventDefault()`すればダイアログを開いたままにできる。丸ごと
// 未対応だった。`.close()`自体は無条件クローズのため対になるこちらの
// 「ユーザーの閉じる操作を横取り可能にする」経路が漏れていた。
// `popover_toggle_extra`と同じ「取消可能イベント→未阻止なら実処理」
// パターンを再利用する。2026-07-18 発見・実装）。
pub fn dom_dialog_request_close(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let (_, prevented) = it.dispatch_event_in_interp(idx, "cancel", &[]);
        if !prevented {
            {
                let mut dom = it.dom.borrow_mut();
                dom.remove_attr(idx, "open");
                dom.remove_attr(idx, "_modal");
            }
            if !a.is_empty() {
                it.dom
                    .borrow_mut()
                    .set_attr(idx, "_return_value", &arg(a, 0).to_js_string());
            }
            let _ = it.dispatch_event_in_interp(idx, "close", &[]);
        }
    }
    Ok(Value::Undefined)
}

/// `element.showPopover()`/`.hidePopover()`/`.togglePopover(force?)`（Popover
/// API。丸ごと未対応だった）。`<dialog>` の `open` 属性と同じく、内部専用属性
/// （`_popover_open`）を付け外しするだけの簡略実装（`css.rs` 側の UA 既定
/// display 切り替えと対）。`beforetoggle`/`toggle` イベント発火・
/// `:popover-open` 疑似クラス・ライトディスミスは対象外。
// `showPopover`/`hidePopover`/`togglePopover`が状態変化を`toggle`イベント
// として発火していなかった（丸ごと未対応だった。`<dialog>.close()`は既に
// `"close"`イベントを発火していたのに、同じ「開閉状態変化を通知する」
// 役目のPopover側だけ漏れていた非対称ギャップ。2026-07-17 発見）。仕様上は
// `oldState`/`newState`を持つ`ToggleEvent`だが、この処理系に`ToggleEvent`
// コンストラクタ自体が無いため、`<details>`の`toggle`イベント修正と同じ
// 簡略方針で`dispatch_event_in_interp`にプレーンな`Event`へ同名プロパティ
// を追加する形（`extra`引数）で代用する。対になる取消可能な`beforetoggle`
// （状態変更「前」に発火し`preventDefault()`で開閉を中止できる。同じく
// 丸ごと未対応だった）も同時に実装。
fn popover_toggle_extra(old_open: bool, new_open: bool) -> alloc::vec::Vec<(String, Value)> {
    alloc::vec![
        (String::from("oldState"), Value::str(if old_open { "open" } else { "closed" })),
        (String::from("newState"), Value::str(if new_open { "open" } else { "closed" })),
    ]
}
pub fn dom_show_popover(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let was_open = it.dom.borrow().has_attr(idx, "_popover_open");
        // `beforetoggle`（状態変更「前」に発火する取消可能なイベント。
        // `preventDefault()`で開閉自体を中止できる。丸ごと未対応だった。
        // 2026-07-17 発見・実装）。
        let (_, prevented) =
            it.dispatch_event_in_interp(idx, "beforetoggle", &popover_toggle_extra(was_open, true));
        if prevented {
            return Ok(Value::Undefined);
        }
        it.dom.borrow_mut().set_attr(idx, "_popover_open", "");
        let _ = it.dispatch_event_in_interp(idx, "toggle", &popover_toggle_extra(was_open, true));
    }
    Ok(Value::Undefined)
}
pub fn dom_hide_popover(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let was_open = it.dom.borrow().has_attr(idx, "_popover_open");
        let (_, prevented) =
            it.dispatch_event_in_interp(idx, "beforetoggle", &popover_toggle_extra(was_open, false));
        if prevented {
            return Ok(Value::Undefined);
        }
        it.dom.borrow_mut().remove_attr(idx, "_popover_open");
        let _ = it.dispatch_event_in_interp(idx, "toggle", &popover_toggle_extra(was_open, false));
    }
    Ok(Value::Undefined)
}
pub fn dom_toggle_popover(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let was_open = it.dom.borrow().has_attr(idx, "_popover_open");
        let force = if matches!(arg(a, 0), Value::Undefined) {
            !was_open
        } else {
            arg(a, 0).truthy()
        };
        let (_, prevented) =
            it.dispatch_event_in_interp(idx, "beforetoggle", &popover_toggle_extra(was_open, force));
        if prevented {
            return Ok(Value::Bool(was_open));
        }
        if force {
            it.dom.borrow_mut().set_attr(idx, "_popover_open", "");
        } else {
            it.dom.borrow_mut().remove_attr(idx, "_popover_open");
        }
        let _ = it.dispatch_event_in_interp(idx, "toggle", &popover_toggle_extra(was_open, force));
        return Ok(Value::Bool(force));
    }
    Ok(Value::Bool(false))
}

/// element.append(...nodes)：末尾に複数追加（文字列はテキスト）。
/// `element.replaceChildren(...nodes)`（DOM 標準。`el.innerHTML=''; el.append(...)`
/// の1行版として使われる定番イディオム）が丸ごと未対応だった。既存の
/// `set_inner_html(idx, "")`（子を丸ごとクリア）と `append`/`arg_to_node` と同じ
/// 「文字列は text node、DOM ノードはそのまま」変換を組み合わせて実装する。
pub fn dom_replace_children(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(p) = this_dom_idx(&this) {
        it.dom.borrow_mut().set_inner_html(p, "");
        for v in a {
            if let Some(c) = arg_to_node(it, v) {
                it.dom.borrow_mut().append_child(p, c);
            }
        }
    }
    Ok(Value::Undefined)
}
pub fn dom_append(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(p) = this_dom_idx(&this) {
        for v in a {
            if let Some(c) = arg_to_node(it, v) {
                it.dom.borrow_mut().append_child(p, c);
            }
        }
    }
    Ok(Value::Undefined)
}
/// element.prepend(...nodes)：先頭に複数追加（順序保持）。
pub fn dom_prepend(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(p) = this_dom_idx(&this) {
        let refnode = it
            .dom
            .borrow()
            .nodes
            .get(p)
            .and_then(|n| n.children.first().copied());
        for v in a {
            if let Some(c) = arg_to_node(it, v) {
                it.dom.borrow_mut().insert_before(p, c, refnode);
            }
        }
    }
    Ok(Value::Undefined)
}
/// element.before(...nodes)：自身の前に兄弟として挿入。
pub fn dom_before(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(s) = this_dom_idx(&this) {
        let parent = it.dom.borrow().nodes.get(s).and_then(|n| n.parent);
        if let Some(p) = parent {
            for v in a {
                if let Some(c) = arg_to_node(it, v) {
                    it.dom.borrow_mut().insert_before(p, c, Some(s));
                }
            }
        }
    }
    Ok(Value::Undefined)
}
/// element.after(...nodes)：自身の後に兄弟として挿入。
pub fn dom_after(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(s) = this_dom_idx(&this) {
        let (parent, next) = {
            let dom = it.dom.borrow();
            let parent = dom.nodes.get(s).and_then(|n| n.parent);
            let next = parent.and_then(|p| dom.nodes.get(p)).and_then(|n| {
                n.children
                    .iter()
                    .position(|&c| c == s)
                    .and_then(|i| n.children.get(i + 1).copied())
            });
            (parent, next)
        };
        if let Some(p) = parent {
            for v in a {
                if let Some(c) = arg_to_node(it, v) {
                    it.dom.borrow_mut().insert_before(p, c, next);
                }
            }
        }
    }
    Ok(Value::Undefined)
}
/// element.replaceWith(...nodes)：自身を nodes で置換。
pub fn dom_replace_with(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(s) = this_dom_idx(&this) {
        let parent = it.dom.borrow().nodes.get(s).and_then(|n| n.parent);
        if let Some(p) = parent {
            for v in a {
                if let Some(c) = arg_to_node(it, v) {
                    it.dom.borrow_mut().insert_before(p, c, Some(s));
                }
            }
            it.dom.borrow_mut().remove_node(s);
        }
    }
    Ok(Value::Undefined)
}

/// node.cloneNode(deep)。複製ノード（親なし）を返す。
pub fn dom_clone_node(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let deep = arg(a, 0).truthy();
        let new_idx = it.dom.borrow_mut().clone_node(idx, deep);
        return Ok(dom_handle(Some(new_idx)));
    }
    Ok(Value::Null)
}
/// `document.importNode(externalNode, deep)`（丸ごと未対応だった。
/// `<template>` の中身を複製して自文書へ取り込む定番パターン
/// `document.importNode(template.content, true)` で使われる）。この処理系は
/// 単一文書（複数 `Document` オブジェクトという概念自体が無い）のため、
/// 「別文書から取り込む」という仕様上の意味は無く、実質 `node.cloneNode(deep)`
/// と同じ結果になる簡略実装。仕様上 `deep` は省略時 `false` だが、実務では
/// ほぼ常に明示的に `true` が渡される。
pub fn document_import_node(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_clone_node(it, arg(a, 0), a.get(1..).unwrap_or(&[]))
}
/// `document.adoptNode(node)`（丸ごと未対応だった）。単一文書のこの処理系
/// では「別文書から養子縁組する」という意味は無いため、仕様の副作用
/// （現在の親から取り外す）のみを再現し、渡されたノードをそのまま返す。
pub fn document_adopt_node(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let node = arg(a, 0);
    if let Some(idx) = this_dom_idx(&node) {
        it.dom.borrow_mut().remove_node(idx);
    }
    Ok(node)
}

/// `element.click()`。以前は単なる no-op で、実際のクリック
/// （`onclick`/`addEventListener('click', ...)` リスナの発火）を一切引き起こさな
/// かった。実マウス操作からも呼ばれる既存の `dispatch_click()` を再利用する。
/// `checkbox`/`radio` は仕様上クリックすると（リスナの実行前に）自身の選択状態が
/// 切り替わる。以前は `element.checked` という JS プロパティ自体が丸ごと未実装
/// だったため、この状態切替もできていなかった。**重要**: 同じ `name` を持つ
/// ラジオボタン間の排他選択（1つを選ぶと他が自動で解除される、ラジオボタンの
/// 最も基本的な仕様上の挙動）も以前は非対応の簡略化として明示的に見送られていたが、
/// `uncheck_radio_group_siblings` を新設し配線した。
/// `element.scrollTo(x, y)`/`.scrollTo({top, left, behavior})` が丸ごと未対応
/// `element.scrollTop`/`element.scrollLeft` および `scrollTo`/`scrollBy`/`scroll`
/// の対象座標を引数から抽出する。オブジェクト引数 `{top, left}` または
/// 位置引数 `(x, y)` の両方に対応する。
pub(crate) fn scroll_top_target(a: &[Value]) -> Option<i32> {
    match arg(a, 0) {
        Value::Object(_) => obj_prop(&arg(a, 0), "top").map(|v| v.to_number() as i32),
        Value::Undefined => None,
        _ => Some(arg(a, 1).to_number() as i32),
    }
}

pub(crate) fn scroll_left_target(a: &[Value]) -> Option<i32> {
    match arg(a, 0) {
        Value::Object(_) => obj_prop(&arg(a, 0), "left").map(|v| v.to_number() as i32),
        Value::Undefined => None,
        _ => Some(arg(a, 0).to_number() as i32),
    }
}

pub fn dom_scroll_to(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let top = scroll_top_target(a);
        let left = scroll_left_target(a);
        if top.is_some() || left.is_some() {
            let mut dom = it.dom.borrow_mut();
            if let Some(t) = top {
                dom.scroll_tops.insert(idx, t.max(0));
            }
            if let Some(l) = left {
                dom.scroll_lefts.insert(idx, l.max(0));
            }
            dom.dirty = true;
        }
    }
    Ok(Value::Undefined)
}

/// `element.scrollBy(x, y)`/`.scrollBy({top, left})`。現在値からの相対移動である点
/// のみ `scrollTo` と異なる。
pub fn dom_scroll_by(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let delta_top = scroll_top_target(a);
        let delta_left = scroll_left_target(a);
        if delta_top.is_some() || delta_left.is_some() {
            let mut dom = it.dom.borrow_mut();
            if let Some(dt) = delta_top {
                let cur = dom.scroll_tops.get(&idx).copied().unwrap_or(0);
                dom.scroll_tops.insert(idx, (cur + dt).max(0));
            }
            if let Some(dl) = delta_left {
                let cur = dom.scroll_lefts.get(&idx).copied().unwrap_or(0);
                dom.scroll_lefts.insert(idx, (cur + dl).max(0));
            }
            dom.dirty = true;
        }
    }
    Ok(Value::Undefined)
}
/// `element.scrollIntoView()`/`.scrollIntoView({behavior, block})`が丸ごと
/// no-opだった（HTML Standard §"scroll into view"の簡略実装が丸ごと欠落。
/// 実サイト www.sugi-lab.net のナビゲーションリンク（`target.scrollIntoView(
/// {behavior:'smooth', block:'start'})`）が完全に無効化されており、クリック
/// しても一切スクロールしないという実害があった。2026-07-22発見・修正）。
/// 既存の`window.scrollTo`と同じ`pending_scroll_abs_y`機構（`render.rs`の
/// `draw()`冒頭で消費・`fire_scroll()`呼び出しまで行う、既に動作確認済みの
/// 経路）を再利用する。対象要素の現在のビューポート相対Y座標
/// （`get_rect`。`getBoundingClientRect`と同じ値）に現在のスクロール量
/// （`window.scrollY`）を加算し、文書内の絶対Y座標を求めて要素の上端が
/// ビューポート上端に来るようにスクロールする（`block:'start'`相当。
/// `center`/`end`/`nearest`は簡略化しすべて`start`と同一視する。`behavior`
/// は既存の`scrollTo`と同様、実時間アニメーションの概念が無いため即座に
/// 反映する）。
pub fn dom_scroll_into_view(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let Some((_, y, _, _)) = it.dom.borrow().get_rect(idx) else {
        return Ok(Value::Undefined);
    };
    let current_scroll_y = it
        .global
        .borrow()
        .vars
        .get("scrollY")
        .map(|v| v.to_number())
        .unwrap_or(0.0);
    let target_abs_y = (current_scroll_y + y as f64).max(0.0);
    it.dom.borrow_mut().pending_scroll_abs_y = Some(target_abs_y as i32);
    Ok(Value::Undefined)
}
pub fn dom_click(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let ty = it.dom.borrow().get_attr(idx, "type").unwrap_or_default();
        match ty.as_str() {
            "checkbox" => {
                let checked = {
                    let dom = it.dom.borrow();
                    if let Some(lc) = dom.get_attr(idx, "_live_checked") {
                        lc == "true"
                    } else {
                        dom.has_attr(idx, "checked")
                    }
                };
                let mut dom = it.dom.borrow_mut();
                if checked {
                    dom.set_attr(idx, "_live_checked", "false");
                } else {
                    dom.set_attr(idx, "_live_checked", "true");
                }
            }
            "radio" => {
                let mut dom = it.dom.borrow_mut();
                dom.set_attr(idx, "_live_checked", "true");
                dom.uncheck_radio_group_siblings(idx);
            }
            _ => {}
        }
        it.dispatch_event_in_interp(idx, "click", &[]);
    }
    Ok(Value::Undefined)
}

/// `element.focus()`（HTML5。丸ごと未対応だった。`document.activeElement`
/// と対になる書き込み側。以前は `scrollIntoView` と同じ no-op で
/// `document.activeElement` が常に `null` 固定になっていた）。`DomBridge::
/// focused_idx` を直接更新し、仕様どおりの順序（旧要素の `blur`/
/// `focusout` → 新要素の `focus`/`focusin`）でイベントを発火する。レンダラ側
/// の `WebEngine::focused_id`（実クリック/`autofocus` 用の文字列キー版状態）
/// との同期は対象外（詳細は `DomBridge::focused_idx` のコメント参照）。
pub fn dom_focus(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let prev = it.dom.borrow().focused_idx;
        if prev == Some(idx) {
            return Ok(Value::Undefined);
        }
        if let Some(p) = prev {
            it.dom.borrow_mut().focused_idx = None;
            let _ = it.dispatch_event_in_interp(p, "blur", &[]);
            let _ = it.dispatch_event_in_interp(p, "focusout", &[]);
        }
        it.dom.borrow_mut().focused_idx = Some(idx);
        let _ = it.dispatch_event_in_interp(idx, "focus", &[]);
        let _ = it.dispatch_event_in_interp(idx, "focusin", &[]);
    }
    Ok(Value::Undefined)
}
/// `element.blur()`（HTML5。丸ごと未対応だった。`dom_focus` の対）。自身が
/// 現在のフォーカス対象である場合のみ解除して `blur`/`focusout` を発火する
/// （仕様どおり、フォーカスされていない要素での `.blur()` は no-op）。
pub fn dom_blur(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let is_focused = it.dom.borrow().focused_idx == Some(idx);
        if is_focused {
            it.dom.borrow_mut().focused_idx = None;
            let _ = it.dispatch_event_in_interp(idx, "blur", &[]);
            let _ = it.dispatch_event_in_interp(idx, "focusout", &[]);
        }
    }
    Ok(Value::Undefined)
}

/// `input.stepUp(n?)`/`.stepDown(n?)`（HTML5。`<input type="number"/"range">`
/// で値を `step` 刻みで増減する定番メソッド）が丸ごと未対応だった。`value`/
/// `step`/`min`/`max` 属性を読み、`min`/`max` があればクランプしてから
/// `value` 属性へ書き戻す（`step="any"`等パース不能な場合は既定値 1 に
/// フォールバックする、この処理系の他の数値属性パースと同じ寛容な簡略化）。
pub(crate) fn dom_step_by(it: &mut Interp, this: Value, a: &[Value], sign: f64) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let (cur, step, min, max) = {
            let dom = it.dom.borrow();
            let raw_val = dom.get_attr(idx, "_live_value")
                .or_else(|| dom.get_attr(idx, "value"));
            (
                raw_val.and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(0.0),
                dom.get_attr(idx, "step").and_then(|s| s.trim().parse::<f64>().ok()).unwrap_or(1.0),
                dom.get_attr(idx, "min").and_then(|s| s.trim().parse::<f64>().ok()),
                dom.get_attr(idx, "max").and_then(|s| s.trim().parse::<f64>().ok()),
            )
        };
        let multiplier = match arg(a, 0) {
            Value::Undefined => 1.0,
            n => n.to_number(),
        };
        let mut new_val = cur + sign * step * multiplier;
        if let Some(mn) = min {
            if new_val < mn {
                new_val = mn;
            }
        }
        if let Some(mx) = max {
            if new_val > mx {
                new_val = mx;
            }
        }
        let str_val = Value::Number(new_val).to_js_string();
        it.dom.borrow_mut().set_attr(idx, "_live_value", &str_val);
    }
    Ok(Value::Undefined)
}
pub fn dom_step_up(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_step_by(it, this, a, 1.0)
}
pub fn dom_step_down(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    dom_step_by(it, this, a, -1.0)
}

/// `form.requestSubmit(submitter?)`（HTML5）が丸ごと未対応だった。既存の
/// `dom_click` と同じ `dispatch_event_in_interp` 経由で `submit` イベントを
/// 発火する（`preventDefault()` で中止可能。`submitter` 引数は現状無視）。
pub fn dom_request_submit(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        it.dispatch_event_in_interp(idx, "submit", &[]);
    }
    Ok(Value::Undefined)
}

/// `node.contains(other)`（DOM 標準。`other` が `node` 自身または子孫かどうか。
/// click-outside 判定などで広く使われる）が丸ごと未対応だった。既存の
/// `is_ancestor_of()` は「`idx` 自身は含まない」仕様のため、仕様どおり自身も
/// 含めるにはここで等価チェックを補う。
pub fn dom_contains(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let other = arg(a, 0);
    if let (Some(anc), Some(desc)) = (this_dom_idx(&this), this_dom_idx(&other)) {
        let contains = anc == desc || it.dom.borrow().is_ancestor_of(anc, desc);
        return Ok(Value::Bool(contains));
    }
    Ok(Value::Bool(false))
}

/// `node.getRootNode()`（DOM標準。`el.getRootNode() === document` という
/// 「接続済みか」の定番判定や、shadow DOM 対応コードの分岐で使われる）が丸ごと
/// 未対応だった。この処理系は shadow DOM を持たないため、親を辿れる限り辿った
/// 最上位ノードを返す単純な実装で仕様の意図（最も遠い祖先）を満たす。
pub fn dom_get_root_node(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let mut cur = idx;
        let mut guard = 0;
        loop {
            let parent = it.dom.borrow().nodes.get(cur).and_then(|n| n.parent);
            match parent {
                Some(p) => {
                    cur = p;
                    guard += 1;
                    if guard > it.dom.borrow().nodes.len() {
                        break;
                    }
                }
                None => break,
            }
        }
        if cur == 0 {
            if let Some(doc) = it.global.borrow().vars.get("document").cloned() {
                return Ok(doc);
            }
        }
        return Ok(Value::Object(Obj::dom(cur)));
    }
    if matches!(this, Value::Object(_)) {
        if let Ok(parent) = it.get_property(&this, "parentNode") {
            if !matches!(parent, Value::Null | Value::Undefined) {
                return dom_get_root_node(it, parent, _a);
            }
        }
        return Ok(this);
    }
    Ok(Value::Undefined)
}

/// `element.checkVisibility()`（DOM 標準。丸ごと未対応だった）。オプション引数
/// （`checkOpacity`/`checkVisibilityCSS`/`contentVisibilityAuto` 等）は未対応で
/// 常に無視する簡略実装。自身の算出 `visibility` が `hidden`/`collapse` の場合、
/// および自身または祖先のいずれかの算出 `display` が `none` の場合に `false` を返す。
/// `node.lookupNamespaceURI(prefix)`/`.lookupPrefix(namespace)`/
/// `.isDefaultNamespace(namespace)`（丸ごと未対応だった。2026-07-16
/// 発見）。この処理系は `*AttributeNS`/`createElementNS` と同じく XML
/// 名前空間を一切モデル化していない（`document_create_element_ns` は
/// namespace 引数を無視して委譲するのみ）ため、`xmlns`/`xmlns:*` 属性を
/// 祖先チェーンから探索する誠実な実装は行わず、常に「名前空間なし」を表す
/// 値（`lookupNamespaceURI`/`lookupPrefix` は `null`）を返す簡略実装。
/// `isDefaultNamespace(namespace)` は仕様上 `lookupNamespaceURI(null) ===
/// namespace` と等価なので、`lookupNamespaceURI` が常に `null` を返す
/// このモデルでは `namespace` が `null`/`undefined` の時のみ `true` になる。
pub fn dom_lookup_namespace_uri(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Null)
}

pub fn dom_lookup_prefix(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Null)
}

pub fn dom_is_default_namespace(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Bool(matches!(arg(a, 0), Value::Null | Value::Undefined)))
}

pub fn dom_check_visibility(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let visibility = it.dom.borrow().get_computed(idx, "visibility");
        if visibility == "hidden" || visibility == "collapse" {
            return Ok(Value::Bool(false));
        }
        let mut cur = idx;
        let mut guard = 0;
        loop {
            if it.dom.borrow().get_computed(cur, "display") == "none" {
                return Ok(Value::Bool(false));
            }
            let parent = it.dom.borrow().nodes.get(cur).and_then(|n| n.parent);
            match parent {
                Some(p) => {
                    cur = p;
                    guard += 1;
                    if guard > it.dom.borrow().nodes.len() {
                        break;
                    }
                }
                None => break,
            }
        }
        return Ok(Value::Bool(true));
    }
    Ok(Value::Bool(false))
}

/// `node.compareDocumentPosition(other)`（DOM標準）が丸ごと未対応だった。
/// `DomBridge::document_position` にビットマスク計算を委譲する。`other` が DOM ノードで
/// なければ仕様上 `TypeError` だが、この処理系では簡略化して disconnected 扱いにする。
pub fn dom_compare_document_position(
    it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    let other = arg(a, 0);
    if let (Some(this_idx), Some(other_idx)) = (this_dom_idx(&this), this_dom_idx(&other)) {
        let mask = it.dom.borrow().document_position(this_idx, other_idx);
        return Ok(Value::Number(mask as f64));
    }
    // DOM ノードでない引数（この処理系では TypeError の代わりに DISCONNECTED 扱い）。
    Ok(Value::Number(1.0))
}

/// classList.replace(oldClass, newClass)。old があれば new に置換し true、無ければ false。
pub fn dom_classlist_replace(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_host_idx(&this, "classList:") {
        let old = arg(a, 0).to_js_string();
        let new = arg(a, 1).to_js_string();
        let mut dom = it.dom.borrow_mut();
        let had = dom.class_contains(idx, &old);
        if had {
            dom.class_remove(idx, &old);
            dom.class_add(idx, &new);
        }
        return Ok(Value::Bool(had));
    }
    Ok(Value::Bool(false))
}

pub fn dom_remove_child(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let child = arg(a, 0);
    if let (Some(p), Some(c)) = (this_dom_idx(&this), this_dom_idx(&child)) {
        // `insertBefore`/`replaceChild`と同じ理由（詳細はそちらの同種
        // コメント参照）で、`child`が`this`の子でない場合は仕様上
        // `NotFoundError`を投げるべきだが、以前は黙って何もせず成功した
        // かのように振る舞っていた。
        let is_child = it.dom.borrow().nodes.get(c).and_then(|n| n.parent) == Some(p);
        if !is_child {
            return Err(make_dom_exception(
                "NotFoundError",
                "The node to be removed is not a child of this node",
            ));
        }
        it.dom.borrow_mut().remove_child(p, c);
    }
    Ok(child)
}

/// `element.remove()`（`ChildNode.remove()`。引数無しで自身を親から取り外す）。
/// ただし`<select>`だけは`HTMLSelectElement.remove(index)`という別物の
/// オーバーロードを持ち、数値引数が渡された場合は「自身を削除」ではなく
/// 「指定インデックスのoptionを削除」という全く異なる意味になる（仕様上の
/// 別メソッドがたまたま同名なだけ）。以前はこの区別が無く、`select.remove(1)`
/// が常にselect自身を親から削除してしまう（`options`側の削除ではなく）
/// バグだった。
pub fn dom_remove(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(idx) = this_dom_idx(&this) {
        let is_select = it.dom.borrow().nodes.get(idx).map(|n| n.tag == "select").unwrap_or(false);
        if is_select {
            if let Some(v) = a.first() {
                let n = v.to_number();
                if n.is_finite() {
                    // 負のインデックスは仕様上 no-op（`as usize` は負の f64 を 0 へ
                    // 飽和させてしまい、`remove(-1)` が誤って先頭optionを削除する
                    // バグになるため明示的に弾く）。
                    if n >= 0.0 {
                        let options = it.dom.borrow().select_options(idx);
                        if let Some(&opt) = options.get(n as usize) {
                            it.dom.borrow_mut().remove_child(idx, opt);
                        }
                    }
                    return Ok(Value::Undefined);
                }
            }
        }
        it.dom.borrow_mut().remove_node(idx);
    }
    Ok(Value::Undefined)
}

/// ネイティブ関数値を作るショートカット。
pub(crate) fn nv(name: &str, f: NativeFn) -> Value {
    Value::Object(Obj::native(name, f))
}
pub(crate) fn arg(args: &[Value], i: usize) -> Value {
    args.get(i).cloned().unwrap_or(Value::Undefined)
}

/// `HTMLCollection.prototype.item(index)`（DOM Standard §4.2.1）。
pub fn html_collection_item(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let idx_num = arg(a, 0).to_number();
        if idx_num >= 0.0 && idx_num.is_finite() {
            let i = idx_num as usize;
            let borrow = o.borrow();
            if let ObjKind::Array(ref vec) = borrow.kind {
                if let Some(val) = vec.get(i) {
                    return Ok(val.clone());
                }
            }
        }
    }
    Ok(Value::Null)
}

/// `HTMLCollection.prototype.namedItem(name)`（DOM Standard §4.2.1 / HTML Standard §4.10.21）。
/// 同名/同IDのコントロールが複数ある場合は `RadioNodeList` を返す。
pub fn html_collection_named_item(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let target = arg(a, 0).to_js_string();
        if !target.is_empty() {
            let borrow = o.borrow();
            if let ObjKind::Array(ref vec) = borrow.kind {
                let dom = it.dom.borrow();
                let mut matches: Vec<Value> = Vec::new();
                let mut match_indices: Vec<usize> = Vec::new();
                for val in vec {
                    if let Value::Object(item_obj) = val {
                        if let ObjKind::DomElement(elem_idx) = item_obj.borrow().kind {
                            let id_match = dom.get_attr(elem_idx, "id").map(|id| id == target).unwrap_or(false);
                            let name_match = dom.get_attr(elem_idx, "name").map(|name| name == target).unwrap_or(false);
                            if id_match || name_match {
                                matches.push(val.clone());
                                match_indices.push(elem_idx);
                            }
                        }
                    }
                }
                if matches.len() == 1 {
                    return Ok(matches[0].clone());
                } else if matches.len() > 1 {
                    return Ok(make_radio_node_list(it, match_indices));
                }
            }
        }
    }
    Ok(Value::Null)
}

/// `RadioNodeList` オブジェクトを生成するヘルパー（HTML Standard §4.10.21.1）。
/// 配列構造に加え `.value` (getter/setter) アクセスおよび `item(index)` メソッドをサポートする。
pub fn make_radio_node_list(_it: &Interp, elements: Vec<usize>) -> Value {
    let mut arr: Vec<Value> = Vec::with_capacity(elements.len());
    for &idx in &elements {
        arr.push(Value::Object(Obj::dom(idx)));
    }
    let obj = Obj::array(arr);
    obj.borrow_mut().props.insert("_is_radio_nodelist".into(), Value::Bool(true));
    obj.borrow_mut().props.insert("item".into(), nv("item", html_collection_item));
    Value::Object(obj)
}

/// `HTMLCollection` / `HTMLFormControlsCollection` オブジェクトを生成するヘルパー。
/// 配列機能に加え、DOM Standard §4.2.1 に準拠して `item(index)` および
/// `namedItem(name)` メソッドを持つ。
pub fn make_html_collection(_it: &Interp, elements: Vec<usize>) -> Value {
    let mut arr: Vec<Value> = Vec::with_capacity(elements.len());
    for &idx in &elements {
        arr.push(Value::Object(Obj::dom(idx)));
    }
    let obj = Obj::array(arr);
    obj.borrow_mut().props.insert("item".into(), nv("item", html_collection_item));
    obj.borrow_mut().props.insert("namedItem".into(), nv("namedItem", html_collection_named_item));
    Value::Object(obj)
}

fn parsed_doc_get_root_idx(this: &Value) -> Option<usize> {
    if let Value::Object(o) = this {
        if let Some(Value::Number(n)) = o.borrow().props.get("_root_idx") {
            return Some(*n as usize);
        }
    }
    None
}

pub(crate) fn parsed_doc_get_element_by_id(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(root_idx) = parsed_doc_get_root_idx(&this) {
        let id = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        if let Some(n) = dom.nodes.get(root_idx) {
            if !n.is_text && n.id == id {
                return Ok(dom_handle(Some(root_idx)));
            }
        }
        for desc in dom.descendants_by_tag_name(root_idx, "*") {
            if let Some(n) = dom.nodes.get(desc) {
                if !n.is_text && n.id == id {
                    return Ok(dom_handle(Some(desc)));
                }
            }
        }
        return Ok(Value::Null);
    }
    document_get_element_by_id(it, this, a)
}

pub(crate) fn parsed_doc_query_selector(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(root_idx) = parsed_doc_get_root_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        for c in dom.query_all_scoped(&sel, Some(root_idx)) {
            if c == root_idx || dom.is_ancestor_of(root_idx, c) {
                return Ok(dom_handle(Some(c)));
            }
        }
        return Ok(Value::Null);
    }
    document_query_selector(it, this, a)
}

pub(crate) fn parsed_doc_query_selector_all(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(root_idx) = parsed_doc_get_root_idx(&this) {
        let sel = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        let mut items = Vec::new();
        for c in dom.query_all_scoped(&sel, Some(root_idx)) {
            if c == root_idx || dom.is_ancestor_of(root_idx, c) {
                items.push(Value::Object(Obj::dom(c)));
            }
        }
        return Ok(Value::Object(Obj::array(items)));
    }
    document_query_selector_all(it, this, a)
}

pub(crate) fn parsed_doc_get_elements_by_tag_name(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(root_idx) = parsed_doc_get_root_idx(&this) {
        let tag = arg(a, 0).to_js_string();
        let dom = it.dom.borrow();
        let mut items = Vec::new();
        let want_all = tag == "*";
        if let Some(n) = dom.nodes.get(root_idx) {
            if !n.is_text && (want_all || n.tag.eq_ignore_ascii_case(&tag)) {
                items.push(Value::Object(Obj::dom(root_idx)));
            }
        }
        for desc in dom.descendants_by_tag_name(root_idx, &tag) {
            items.push(Value::Object(Obj::dom(desc)));
        }
        return Ok(Value::Object(Obj::array(items)));
    }
    document_get_elements_by_tag_name(it, this, a)
}

/// `DOMParser.prototype.parseFromString(str, type)` （DOM Parsing and Serialization §4.1）。
/// 入力された文字列を指定された MIME タイプ（text/html, text/xml, application/xml, image/svg+xml 等）でパースし、
/// 独立した Document オブジェクト（および XML エラー時は <parsererror> 要素）を返却する。
pub fn dom_parser_parse_from_string(it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let raw_input = args.first().map(|v| v.to_js_string()).unwrap_or_default();
    let mime = args.get(1).map(|v| v.to_js_string()).unwrap_or_default();
    let mime_type = crate::os_lib::xml_parser::parse_mime_type(&mime);
    if mime_type == crate::os_lib::xml_parser::SupportedMimeType::Unsupported {
        return Err(Value::str("TypeError: Invalid or unsupported MIME type"));
    }

    let root_node = match mime_type {
        crate::os_lib::xml_parser::SupportedMimeType::Html => {
            crate::os_lib::dom::parse_html(&raw_input)
        }
        crate::os_lib::xml_parser::SupportedMimeType::Xml
        | crate::os_lib::xml_parser::SupportedMimeType::Svg
        | crate::os_lib::xml_parser::SupportedMimeType::Xhtml => {
            match crate::os_lib::xml_parser::parse_xml(&raw_input) {
                Ok(node) => node,
                Err(e) => crate::os_lib::xml_parser::create_parsererror_node(&e),
            }
        }
        crate::os_lib::xml_parser::SupportedMimeType::Unsupported => unreachable!(),
    };

    let root_idx = it.dom.borrow_mut().import_node(&root_node);
    if mime_type != crate::os_lib::xml_parser::SupportedMimeType::Html {
        it.dom.borrow_mut().mark_subtree_xml(root_idx);
    }
    let doc = Obj::host("document");
    {
        let mut d = doc.borrow_mut();
        d.props.insert("_root_idx".into(), Value::Number(root_idx as f64));
        d.props.insert("nodeType".into(), Value::Number(9.0));
        d.props.insert("nodeName".into(), Value::str("#document"));
        d.props.insert("contentType".into(), Value::str(&mime));

        let doc_elem_idx = {
            let dom = it.dom.borrow();
            if let Some(n) = dom.nodes.get(root_idx) {
                if !n.is_text && !n.tag.starts_with('#') {
                    Some(root_idx)
                } else {
                    n.children.iter().copied().find(|&c| {
                        dom.nodes.get(c).map(|cn| !cn.is_text).unwrap_or(false)
                    })
                }
            } else {
                None
            }
        };

        if let Some(de) = doc_elem_idx {
            d.props.insert("documentElement".into(), Value::Object(Obj::dom(de)));
        } else {
            d.props.insert("documentElement".into(), Value::Null);
        }

        d.props.insert(
            "getElementById".into(),
            nv("getElementById", parsed_doc_get_element_by_id),
        );
        d.props.insert(
            "querySelector".into(),
            nv("querySelector", parsed_doc_query_selector),
        );
        d.props.insert(
            "querySelectorAll".into(),
            nv("querySelectorAll", parsed_doc_query_selector_all),
        );
        d.props.insert(
            "getElementsByTagName".into(),
            nv("getElementsByTagName", parsed_doc_get_elements_by_tag_name),
        );
    }
    Ok(Value::Object(doc))
}

/// `DOMParser` コンストラクタ。
pub fn dom_parser_ctor(_it: &mut Interp, _this: Value, _args: &[Value]) -> Result<Value, Value> {
    let obj = Obj::plain();
    obj.borrow_mut().props.insert(
        "parseFromString".into(),
        nv("parseFromString", dom_parser_parse_from_string),
    );
    Ok(Value::Object(obj))
}

/// `form.reset()`（HTML5）の実装。
/// フォーム要素配下のすべての `<input>`, `<select>`, `<textarea>` のフォームライブ値を初期状態にリセットする。
pub fn dom_form_reset(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let Some(form_idx) = this_dom_idx(&this) else {
        return Ok(Value::Undefined);
    };
    let child_indices: alloc::vec::Vec<usize> = {
        let dom = it.dom.borrow();
        let mut list = alloc::vec::Vec::new();
        fn collect_descendants(dom: &crate::os_lib::js::dom_bridge::DomBridge, node_idx: usize, out: &mut alloc::vec::Vec<usize>) {
            if let Some(node) = dom.nodes.get(node_idx) {
                for &child in &node.children {
                    out.push(child);
                    collect_descendants(dom, child, out);
                }
            }
        }
        collect_descendants(&dom, form_idx, &mut list);
        list
    };

    let mut dom = it.dom.borrow_mut();
    for idx in child_indices {
        let tag = dom.nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
        match tag.as_str() {
            "input" => {
                let ty = dom.get_attr(idx, "type").unwrap_or_default().to_lowercase();
                if ty == "checkbox" || ty == "radio" {
                    let default_checked = dom.has_attr(idx, "checked");
                    dom.set_attr(idx, "_live_checked", if default_checked { "true" } else { "false" });
                } else {
                    let default_val = dom.get_attr(idx, "value").unwrap_or_default();
                    dom.set_attr(idx, "_live_value", &default_val);
                }
            }
            "textarea" => {
                let default_val = dom.get_text_content(idx);
                dom.set_attr(idx, "_live_value", &default_val);
            }
            "select" => {
                dom.remove_attr(idx, "_live_value");
            }
            _ => {}
        }
    }
    Ok(Value::Undefined)
}

/// `<canvas>` 2D context の `measureText(text)` メソッドの実装。
pub fn dom_canvas_measure_text(_it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let text = args.first().map(|v| v.to_js_string()).unwrap_or_default();
    let width = (text.len() * 8) as f64;
    let obj = Obj::plain();
    {
        let mut b = obj.borrow_mut();
        b.props.insert("width".into(), Value::Number(width));
        b.props.insert("actualBoundingBoxAscent".into(), Value::Number(10.0));
        b.props.insert("actualBoundingBoxDescent".into(), Value::Number(2.0));
        b.props.insert("fontBoundingBoxAscent".into(), Value::Number(10.0));
        b.props.insert("fontBoundingBoxDescent".into(), Value::Number(2.0));
        b.props.insert("actualBoundingBoxLeft".into(), Value::Number(0.0));
        b.props.insert("actualBoundingBoxRight".into(), Value::Number(width));
    }
    Ok(Value::Object(obj))
}

/// ImageDataSettings オブジェクトから colorSpace ("srgb" | "display-p3") を取り出す。
pub fn parse_image_data_color_space(val: Option<&Value>) -> &'static str {
    if let Some(Value::Object(obj)) = val {
        let b = obj.borrow();
        if let Some(Value::Str(s)) = b.props.get("colorSpace") {
            if s.eq_ignore_ascii_case("display-p3") {
                return "display-p3";
            }
        }
    }
    "srgb"
}

/// width, height, data, colorSpace を持つ標準 ImageData オブジェクトを構築する。
pub fn make_image_data_object(
    w: usize,
    h: usize,
    data_items: alloc::vec::Vec<Value>,
    color_space: &str,
) -> Value {
    let img = Obj::plain();
    {
        let mut b = img.borrow_mut();
        b.props.insert("width".into(), Value::Number(w as f64));
        b.props.insert("height".into(), Value::Number(h as f64));
        b.props.insert("data".into(), Value::Object(Obj::array(data_items)));
        b.props.insert("colorSpace".into(), Value::Str(alloc::rc::Rc::new(color_space.into())));
    }
    Value::Object(img)
}

/// `createImageData` は透明（全 0）の新しい `ImageData` を返す（仕様）。
///
/// 呼出形式:
/// 1. `ctx.createImageData(anotherImageData)`
/// 2. `ctx.createImageData(width, height, [settings])`
pub fn dom_canvas_create_image_data(
    _it: &mut Interp,
    _this: Value,
    args: &[Value],
) -> Result<Value, Value> {
    // パターン1: 別の ImageData オブジェクトが渡された場合
    if let Some(Value::Object(other)) = args.first() {
        let b = other.borrow();
        if let (Some(w_val), Some(h_val)) = (b.props.get("width"), b.props.get("height")) {
            let w = (w_val.to_number().abs() as usize).max(1);
            let h = (h_val.to_number().abs() as usize).max(1);
            let cs = b
                .props
                .get("colorSpace")
                .map(|v| v.to_js_string())
                .unwrap_or_else(|| "srgb".into());
            let items = alloc::vec![Value::Number(0.0); w * h * 4];
            return Ok(make_image_data_object(w, h, items, &cs));
        }
    }

    // パターン2: width, height, [settings]
    let w = args.first().map(|v| v.to_number().abs() as usize).unwrap_or(1).max(1);
    let h = args.get(1).map(|v| v.to_number().abs() as usize).unwrap_or(1).max(1);
    let cs = parse_image_data_color_space(args.get(2));
    let items = alloc::vec![Value::Number(0.0); w * h * 4];
    Ok(make_image_data_object(w, h, items, cs))
}

/// グローバル `ImageData` コンストラクタ (WHATWG HTML ImageData API)。
///
/// 呼出形式:
/// 1. `new ImageData(width, height, [settings])`
/// 2. `new ImageData(dataArray, width, [height], [settings])`
pub fn dom_image_data_ctor(
    _it: &mut Interp,
    _this: Value,
    args: &[Value],
) -> Result<Value, Value> {
    if let Some(Value::Object(arr_obj)) = args.first() {
        let b = arr_obj.borrow();
        if let ObjKind::Array(items) = &b.kind {
            let w = args.get(1).map(|v| v.to_number().abs() as usize).unwrap_or(1).max(1);
            let h = if let Some(hv) = args.get(2) {
                if let Value::Number(n) = hv {
                    (*n).abs() as usize
                } else {
                    items.len() / (w * 4)
                }
            } else {
                items.len() / (w * 4)
            }.max(1);
            let settings_arg = if args.len() > 3 { args.get(3) } else { args.get(2) };
            let cs = parse_image_data_color_space(settings_arg);
            return Ok(make_image_data_object(w, h, items.clone(), cs));
        }
    }

    // width, height, [settings]
    let w = args.first().map(|v| v.to_number().abs() as usize).unwrap_or(1).max(1);
    let h = args.get(1).map(|v| v.to_number().abs() as usize).unwrap_or(1).max(1);
    let cs = parse_image_data_color_space(args.get(2));
    let items = alloc::vec![Value::Number(0.0); w * h * 4];
    Ok(make_image_data_object(w, h, items, cs))
}

pub fn dom_canvas_is_point_in_path(_it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    let (subpaths, x, y, rule_str) = if let Some(pid) = args.first().and_then(path2d_id) {
        let subpaths = crate::os_lib::canvas2d::get_path2d_subpaths(pid).unwrap_or_default();
        let x = canvas_arg_f32(args, 1);
        let y = canvas_arg_f32(args, 2);
        let rule_str = args.get(3).map(|v| v.to_js_string());
        (subpaths, x, y, rule_str)
    } else {
        let ctx_id = canvas_ctx_id(&this);
        let subpaths = ctx_id
            .and_then(|id| crate::os_lib::canvas2d::with_context(id, |c| c.path.finish()))
            .unwrap_or_default();
        let x = canvas_arg_f32(args, 0);
        let y = canvas_arg_f32(args, 1);
        let rule_str = args.get(2).map(|v| v.to_js_string());
        (subpaths, x, y, rule_str)
    };

    let rule = if rule_str
        .as_deref()
        .map(|s| s.eq_ignore_ascii_case("evenodd"))
        .unwrap_or(false)
    {
        crate::os_lib::canvas2d::FillRule::EvenOdd
    } else {
        crate::os_lib::canvas2d::FillRule::NonZero
    };

    let inside = crate::os_lib::canvas2d::is_point_in_path(&subpaths, x, y, rule);
    Ok(Value::Bool(inside))
}

pub fn dom_canvas_is_point_in_stroke(_it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    let ctx_id = canvas_ctx_id(&this);

    let (subpaths, x, y) = if let Some(pid) = args.first().and_then(path2d_id) {
        let subpaths = crate::os_lib::canvas2d::get_path2d_subpaths(pid).unwrap_or_default();
        let x = canvas_arg_f32(args, 1);
        let y = canvas_arg_f32(args, 2);
        (subpaths, x, y)
    } else {
        let subpaths = ctx_id
            .and_then(|id| crate::os_lib::canvas2d::with_context(id, |c| c.path.finish()))
            .unwrap_or_default();
        let x = canvas_arg_f32(args, 0);
        let y = canvas_arg_f32(args, 1);
        (subpaths, x, y)
    };

    let inside = if let Some(id) = ctx_id {
        crate::os_lib::canvas2d::with_context(id, |c| {
            canvas_sync_state(&this, c);
            c.is_point_in_stroke(&subpaths, x, y)
        })
        .unwrap_or(false)
    } else {
        crate::os_lib::canvas2d::is_point_in_stroke(&subpaths, x, y, 1.0)
    };
    Ok(Value::Bool(inside))
}

pub fn dom_canvas_get_transform(it: &mut Interp, this: Value, _args: &[Value]) -> Result<Value, Value> {
    let (a, b, c, d, e, f) = canvas_ctx_id(&this)
        .and_then(|id| {
            crate::os_lib::canvas2d::with_context(id, |ctx| {
                (
                    ctx.state.transform.a,
                    ctx.state.transform.b,
                    ctx.state.transform.c,
                    ctx.state.transform.d,
                    ctx.state.transform.e,
                    ctx.state.transform.f,
                )
            })
        })
        .unwrap_or((1.0, 0.0, 0.0, 1.0, 0.0, 0.0));

    let nums = alloc::vec![
        Value::Number(a as f64),
        Value::Number(b as f64),
        Value::Number(c as f64),
        Value::Number(d as f64),
        Value::Number(e as f64),
        Value::Number(f as f64),
    ];
    let arr = Value::Object(Obj::array(nums));
    dom_matrix_ctor(it, Value::Undefined, &[arr])
}

pub fn dom_canvas_set_line_dash(_it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        let segs = args.first().cloned().unwrap_or(Value::Undefined);
        let items = this_items(&segs);
        let mut nums: alloc::vec::Vec<Value> = items.into_iter().map(|v| Value::Number(v.to_number())).collect();
        if nums.len() % 2 != 0 {
            let dup = nums.clone();
            nums.extend(dup);
        }
        o.borrow_mut().props.insert("_line_dash".into(), Value::Object(Obj::array(nums)));
    }
    Ok(Value::Undefined)
}

pub fn dom_canvas_get_line_dash(_it: &mut Interp, this: Value, _args: &[Value]) -> Result<Value, Value> {
    if let Value::Object(o) = &this {
        if let Some(Value::Object(arr)) = o.borrow().props.get("_line_dash") {
            let items = this_items(&Value::Object(arr.clone()));
            return Ok(Value::Object(Obj::array(items)));
        }
    }
    Ok(Value::Object(Obj::array(alloc::vec![])))
}

pub fn dom_canvas_round_rect(it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    canvas_round_rect(it, this, args)
}

/// `<canvas>` 2D context の `reset()` メソッド (WHATWG HTML Standard)。
pub fn dom_canvas_reset(_it: &mut Interp, this: Value, _args: &[Value]) -> Result<Value, Value> {
    if let Value::Object(ref ctx) = this {
        let mut b = ctx.borrow_mut();
        b.props.insert("fillStyle".into(), Value::str("#000000"));
        b.props.insert("strokeStyle".into(), Value::str("#000000"));
        b.props.insert("lineWidth".into(), Value::Number(1.0));
        b.props.insert("lineCap".into(), Value::str("butt"));
        b.props.insert("lineJoin".into(), Value::str("miter"));
        b.props.insert("miterLimit".into(), Value::Number(10.0));
        b.props.insert("lineDashOffset".into(), Value::Number(0.0));
        b.props.insert("font".into(), Value::str("10px sans-serif"));
        b.props.insert("textAlign".into(), Value::str("start"));
        b.props.insert("textBaseline".into(), Value::str("alphabetic"));
        b.props.insert("globalAlpha".into(), Value::Number(1.0));
        b.props.insert("globalCompositeOperation".into(), Value::str("source-over"));
        b.props.insert("shadowBlur".into(), Value::Number(0.0));
        b.props.insert("shadowColor".into(), Value::str("rgba(0, 0, 0, 0)"));
        b.props.insert("shadowOffsetX".into(), Value::Number(0.0));
        b.props.insert("shadowOffsetY".into(), Value::Number(0.0));
        b.props.insert("imageSmoothingEnabled".into(), Value::Bool(true));
        b.props.insert("direction".into(), Value::str("inherit"));
        b.props.insert("filter".into(), Value::str("none"));
        b.props.shift_remove("_line_dash");
    }
    Ok(Value::Undefined)
}

fn dom_matrix_arg_to_matrix(it: &mut Interp, val: &Value) -> Option<crate::os_lib::canvas2d::Matrix> {
    if let Value::Object(_) = val {
        let a = it.get_property(val, "a").ok().map(|v| v.to_number()).unwrap_or(1.0);
        let b = it.get_property(val, "b").ok().map(|v| v.to_number()).unwrap_or(0.0);
        let c = it.get_property(val, "c").ok().map(|v| v.to_number()).unwrap_or(0.0);
        let d = it.get_property(val, "d").ok().map(|v| v.to_number()).unwrap_or(1.0);
        let e = it.get_property(val, "e").ok().map(|v| v.to_number()).unwrap_or(0.0);
        let f = it.get_property(val, "f").ok().map(|v| v.to_number()).unwrap_or(0.0);

        if a.is_finite() && b.is_finite() && c.is_finite() && d.is_finite() && e.is_finite() && f.is_finite() {
            Some(crate::os_lib::canvas2d::Matrix {
                a: a as f32,
                b: b as f32,
                c: c as f32,
                d: d as f32,
                e: e as f32,
                f: f as f32,
            })
        } else {
            None
        }
    } else {
        None
    }
}

pub fn dom_path2d_add_path(it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        if let Some(src_arg) = args.first() {
            if let Some(src_id) = path2d_id(src_arg) {
                let transform = args.get(1).and_then(|v| dom_matrix_arg_to_matrix(it, v));
                crate::os_lib::canvas2d::add_path_to_path2d(id, src_id, transform.as_ref());
            }
        }
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_close_path(_it: &mut Interp, this: Value, _args: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        crate::os_lib::canvas2d::with_path2d(id, |p| p.close_path());
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_move_to(_it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (x, y) = (canvas_arg_f32(args, 0), canvas_arg_f32(args, 1));
        crate::os_lib::canvas2d::with_path2d(id, |p| p.move_to(&crate::os_lib::canvas2d::Matrix::identity(), x, y));
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_line_to(_it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (x, y) = (canvas_arg_f32(args, 0), canvas_arg_f32(args, 1));
        crate::os_lib::canvas2d::with_path2d(id, |p| p.line_to(&crate::os_lib::canvas2d::Matrix::identity(), x, y));
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_arc(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (cx, cy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let r = canvas_arg_f32(a, 2);
        let start = canvas_arg_f32(a, 3);
        let end = canvas_arg_f32(a, 4);
        let ccw = a.get(5).map(|v| v.truthy()).unwrap_or(false);
        crate::os_lib::canvas2d::with_path2d(id, |p| {
            p.arc(&crate::os_lib::canvas2d::Matrix::identity(), cx, cy, r, start, end, ccw);
        });
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_arc_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (x1, y1) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (x2, y2) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let radius = canvas_arg_f32(a, 4);
        crate::os_lib::canvas2d::with_path2d(id, |p| {
            p.arc_to(&crate::os_lib::canvas2d::Matrix::identity(), x1, y1, x2, y2, radius);
        });
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (x, y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (w, h) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        crate::os_lib::canvas2d::with_path2d(id, |p| {
            p.rect(&crate::os_lib::canvas2d::Matrix::identity(), x, y, w, h);
        });
    }
    Ok(Value::Undefined)
}

/// `roundRect` の `radii` 引数をパース・検証する。
/// W3C HTML Canvas 2D Context 仕様準拠:
/// - 負の半径指定時は `RangeError`
/// - 配列長が 0 または 5 以上の時は `RangeError`
/// - 1〜4 個の半径は CSS `border-radius` と同様に 4 隅へ補完
fn parse_round_rect_radii(it: &Interp, radii_val: Option<&Value>) -> Result<[f32; 4], Value> {
    match radii_val {
        None | Some(Value::Undefined) => Ok([0.0; 4]),
        Some(Value::Object(o)) => {
            let b = o.borrow();
            if let ObjKind::Array(items) = &b.kind {
                if items.is_empty() || items.len() > 4 {
                    return Err(set_error_props(
                        it,
                        Value::Undefined,
                        alloc::format!(
                            "Failed to execute 'roundRect': 1 to 4 radii expected, got {}",
                            items.len()
                        ),
                        "RangeError",
                    ));
                }
                let mut vals = alloc::vec::Vec::with_capacity(items.len());
                for item in items {
                    let n = item.to_number();
                    let f = if n.is_finite() { n as f32 } else { 0.0 };
                    if f < 0.0 {
                        return Err(set_error_props(
                            it,
                            Value::Undefined,
                            alloc::format!(
                                "Failed to execute 'roundRect': radius must be non-negative, got {f}"
                            ),
                            "RangeError",
                        ));
                    }
                    vals.push(f);
                }
                let radii = match vals.len() {
                    1 => [vals[0]; 4],
                    2 => [vals[0], vals[1], vals[0], vals[1]],
                    3 => [vals[0], vals[1], vals[2], vals[1]],
                    4 => [vals[0], vals[1], vals[2], vals[3]],
                    _ => [0.0; 4],
                };
                Ok(radii)
            } else {
                let n = radii_val.map_or(f64::NAN, |v| v.to_number());
                let f = if n.is_finite() { n as f32 } else { 0.0 };
                if f < 0.0 {
                    return Err(set_error_props(
                        it,
                        Value::Undefined,
                        alloc::format!(
                            "Failed to execute 'roundRect': radius must be non-negative, got {f}"
                        ),
                        "RangeError",
                    ));
                }
                Ok([f; 4])
            }
        }
        Some(v) => {
            let n = v.to_number();
            let f = if n.is_finite() { n as f32 } else { 0.0 };
            if f < 0.0 {
                return Err(set_error_props(
                    it,
                    Value::Undefined,
                    alloc::format!(
                        "Failed to execute 'roundRect': radius must be non-negative, got {f}"
                    ),
                    "RangeError",
                ));
            }
            Ok([f; 4])
        }
    }
}

pub fn dom_path2d_round_rect(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (x, y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (w, h) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let radii = parse_round_rect_radii(it, a.get(4))?;
        crate::os_lib::canvas2d::with_path2d(id, |p| {
            p.round_rect(&crate::os_lib::canvas2d::Matrix::identity(), x, y, w, h, radii);
        });
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_ellipse(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (cx, cy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (rx, ry) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let rot = canvas_arg_f32(a, 4);
        let start = canvas_arg_f32(a, 5);
        let end = canvas_arg_f32(a, 6);
        let ccw = a.get(7).map(|v| v.truthy()).unwrap_or(false);
        crate::os_lib::canvas2d::with_path2d(id, |p| {
            p.ellipse(&crate::os_lib::canvas2d::Matrix::identity(), cx, cy, rx, ry, rot, start, end, ccw);
        });
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_bezier_curve_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (c1x, c1y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (c2x, c2y) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let (x, y) = (canvas_arg_f32(a, 4), canvas_arg_f32(a, 5));
        crate::os_lib::canvas2d::with_path2d(id, |p| {
            p.bezier_curve_to(&crate::os_lib::canvas2d::Matrix::identity(), c1x, c1y, c2x, c2y, x, y);
        });
    }
    Ok(Value::Undefined)
}

pub fn dom_path2d_quadratic_curve_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = path2d_id(&this) {
        let (cx, cy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (x, y) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        crate::os_lib::canvas2d::with_path2d(id, |p| {
            p.quadratic_curve_to(&crate::os_lib::canvas2d::Matrix::identity(), cx, cy, x, y);
        });
    }
    Ok(Value::Undefined)
}

/// `Path2D` コンストラクタ (WHATWG HTML Canvas 2D Path2D API)。
pub fn dom_path2d_ctor(_it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let p = Obj::plain();
    let id = if let Some(arg) = args.first() {
        if let Some(src_id) = path2d_id(arg) {
            crate::os_lib::canvas2d::clone_path2d(src_id)
        } else if let Value::Str(s) = arg {
            crate::os_lib::canvas2d::create_path2d(Some(s))
        } else if !matches!(arg, Value::Undefined | Value::Null) {
            let s = arg.to_js_string();
            crate::os_lib::canvas2d::create_path2d(Some(&s))
        } else {
            crate::os_lib::canvas2d::create_path2d(None)
        }
    } else {
        crate::os_lib::canvas2d::create_path2d(None)
    };
    {
        let mut b = p.borrow_mut();
        b.props.insert("_path2d_id".into(), Value::Number(id as f64));
        b.props.insert("addPath".into(), nv("addPath", dom_path2d_add_path));
        b.props.insert("closePath".into(), nv("closePath", dom_path2d_close_path));
        b.props.insert("moveTo".into(), nv("moveTo", dom_path2d_move_to));
        b.props.insert("lineTo".into(), nv("lineTo", dom_path2d_line_to));
        b.props.insert("arc".into(), nv("arc", dom_path2d_arc));
        b.props.insert("arcTo".into(), nv("arcTo", dom_path2d_arc_to));
        b.props.insert("rect".into(), nv("rect", dom_path2d_rect));
        b.props.insert("roundRect".into(), nv("roundRect", dom_path2d_round_rect));
        b.props.insert("ellipse".into(), nv("ellipse", dom_path2d_ellipse));
        b.props.insert("bezierCurveTo".into(), nv("bezierCurveTo", dom_path2d_bezier_curve_to));
        b.props.insert("quadraticCurveTo".into(), nv("quadraticCurveTo", dom_path2d_quadratic_curve_to));
    }
    Ok(Value::Object(p))
}

/// `<canvas>` 2D context の `createLinearGradient(x0, y0, x1, y1)`。
pub fn dom_canvas_create_linear_gradient(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let x0 = canvas_arg_f32(a, 0);
    let y0 = canvas_arg_f32(a, 1);
    let x1 = canvas_arg_f32(a, 2);
    let y1 = canvas_arg_f32(a, 3);
    let id = crate::os_lib::canvas2d::create_linear_gradient(x0, y0, x1, y1);
    let grad = Obj::plain();
    {
        let mut b = grad.borrow_mut();
        b.props.insert("_gradient_id".into(), Value::Number(id as f64));
        b.props.insert("addColorStop".into(), nv("addColorStop", dom_gradient_add_color_stop));
    }
    Ok(Value::Object(grad))
}

/// `<canvas>` 2D context の `createRadialGradient(x0, y0, r0, x1, y1, r1)`。
pub fn dom_canvas_create_radial_gradient(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let x0 = canvas_arg_f32(a, 0);
    let y0 = canvas_arg_f32(a, 1);
    let r0 = canvas_arg_f32(a, 2);
    let x1 = canvas_arg_f32(a, 3);
    let y1 = canvas_arg_f32(a, 4);
    let r1 = canvas_arg_f32(a, 5);
    let id = crate::os_lib::canvas2d::create_radial_gradient(x0, y0, r0, x1, y1, r1);
    let grad = Obj::plain();
    {
        let mut b = grad.borrow_mut();
        b.props.insert("_gradient_id".into(), Value::Number(id as f64));
        b.props.insert("addColorStop".into(), nv("addColorStop", dom_gradient_add_color_stop));
    }
    Ok(Value::Object(grad))
}

/// `CanvasGradient.prototype.addColorStop(offset, color)`。
pub fn dom_gradient_add_color_stop(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let id = match &this {
        Value::Object(o) => {
            let b = o.borrow();
            b.props.get("_gradient_id").and_then(|v| match v {
                Value::Number(n) => Some(*n as u32),
                _ => None,
            })
        }
        _ => None,
    };
    let Some(id) = id else {
        return Ok(Value::Undefined);
    };
    let offset = canvas_arg_f32(a, 0);
    let color_str = a.get(1).map(|v| v.to_js_string()).unwrap_or_default();
    let color = crate::os_lib::css::parse_color(&color_str).unwrap_or(0xFF00_0000);
    crate::os_lib::canvas2d::add_color_stop_to_gradient(id, offset, color);
    Ok(Value::Undefined)
}

/// `<canvas>` 2D context の `createConicGradient(startAngle, x, y)`。
pub fn dom_canvas_create_conic_gradient(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let start_angle = canvas_arg_f32(a, 0);
    let cx = canvas_arg_f32(a, 1);
    let cy = canvas_arg_f32(a, 2);
    let id = crate::os_lib::canvas2d::create_conic_gradient(start_angle, cx, cy);
    let grad = Obj::plain();
    {
        let mut b = grad.borrow_mut();
        b.props.insert("_gradient_id".into(), Value::Number(id as f64));
        b.props.insert("addColorStop".into(), nv("addColorStop", dom_gradient_add_color_stop));
    }
    Ok(Value::Object(grad))
}

/// `createPattern` の引数（ImageData, HTMLCanvasElement, HTMLImageElement）からピクセルデータを抽出する。
fn extract_pattern_pixels(it: &mut Interp, v: &Value) -> Option<(u32, u32, alloc::vec::Vec<u32>)> {
    let Value::Object(o) = v else {
        return None;
    };

    // 1. ImageData か？ (width, height, data を持つ)
    {
        let b = o.borrow();
        if let (Some(Value::Number(w_num)), Some(Value::Number(h_num)), Some(Value::Object(data_arr))) =
            (b.props.get("width"), b.props.get("height"), b.props.get("data"))
        {
            let w = *w_num as u32;
            let h = *h_num as u32;
            if w > 0 && h > 0 {
                let ab = data_arr.borrow();
                // Uint8ClampedArray（記憶域）も受け付ける。
                let items_owned: alloc::vec::Vec<Value> = match &ab.kind {
                    ObjKind::Bytes(st) => st.values(),
                    _ => alloc::vec::Vec::new(),
                };
                let items_ref = match &ab.kind {
                    ObjKind::Array(items) => Some(items),
                    ObjKind::Bytes(_) => Some(&items_owned),
                    _ => None,
                };
                if let Some(items) = items_ref {
                    let total = (w * h) as usize;
                    let mut pixels = alloc::vec::Vec::with_capacity(total);
                    for chunk in items.chunks(4) {
                        if chunk.len() == 4 {
                            let r = chunk[0].to_number().clamp(0.0, 255.0) as u32;
                            let g = chunk[1].to_number().clamp(0.0, 255.0) as u32;
                            let b = chunk[2].to_number().clamp(0.0, 255.0) as u32;
                            let a = chunk[3].to_number().clamp(0.0, 255.0) as u32;
                            pixels.push((a << 24) | (r << 16) | (g << 8) | b);
                        } else {
                            pixels.push(0);
                        }
                    }
                    if pixels.len() == total {
                        return Some((w, h, pixels));
                    }
                }
            }
        }
    }

    // 2. DOM 要素（<img> または <canvas>）か？
    let idx = match o.borrow().kind {
        ObjKind::DomElement(i) => Some(i),
        _ => None,
    }?;
    let (tag, src, cid) = {
        let dom = it.dom.borrow();
        let tag = dom.nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
        let src = dom.get_attr(idx, "src").unwrap_or_default();
        let cid = dom
            .get_attr(idx, "_c2d_id")
            .and_then(|s| s.parse::<u32>().ok());
        (tag, src, cid)
    };

    if tag == "canvas" {
        let id = cid?;
        return crate::os_lib::canvas2d::with_context(id, |c| {
            let (w, h) = (c.surface.width, c.surface.height);
            if w == 0 || h == 0 {
                None
            } else {
                Some((w, h, c.surface.pixels.clone()))
            }
        }).flatten();
    }

    if let Some(img) = crate::os_lib::web_engine::shared_image(&src) {
        let (w, h) = (img.width, img.height);
        if w > 0 && h > 0 {
            let mut pixels = alloc::vec::Vec::with_capacity((w * h) as usize);
            for chunk in img.rgba.chunks_exact(4) {
                let r = chunk[0] as u32;
                let g = chunk[1] as u32;
                let b = chunk[2] as u32;
                let a = chunk[3] as u32;
                pixels.push((a << 24) | (r << 16) | (g << 8) | b);
            }
            return Some((w, h, pixels));
        }
    }

    None
}

/// `pattern.setTransform(matrix)`。
pub fn dom_pattern_set_transform(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Value::Object(o) = &this else {
        return Ok(Value::Undefined);
    };
    let pid = match o.borrow().props.get("_pattern_id") {
        Some(Value::Number(n)) if *n >= 0.0 => *n as u32,
        _ => return Ok(Value::Undefined),
    };
    let matrix = if let Some(arg) = a.first() {
        dom_matrix_arg_to_matrix(it, arg).unwrap_or_else(crate::os_lib::canvas2d::Matrix::identity)
    } else {
        crate::os_lib::canvas2d::Matrix::identity()
    };
    crate::os_lib::canvas2d::set_pattern_transform(pid, matrix);
    Ok(Value::Undefined)
}

/// `<canvas>` 2D context の `createPattern(image, repetition)`。
pub fn dom_canvas_create_pattern(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(image_arg) = a.first() else {
        return Ok(Value::Null);
    };
    let Some((w, h, pixels)) = extract_pattern_pixels(it, image_arg) else {
        return Ok(Value::Null);
    };
    let rep_str = a.get(1).map(|v| v.to_js_string()).unwrap_or_else(|| String::from("repeat"));
    let repetition = crate::os_lib::canvas2d::parse_repetition(&rep_str);
    let id = crate::os_lib::canvas2d::create_pattern(w, h, pixels, repetition);

    let pat = Obj::plain();
    {
        let mut b = pat.borrow_mut();
        b.props.insert("_pattern_id".into(), Value::Number(id as f64));
        b.props.insert("setTransform".into(), nv("setTransform", dom_pattern_set_transform));
    }
    Ok(Value::Object(pat))
}

/// `<canvas>` 要素の `getContext(contextId, options?)` (HTML5 Canvas 2D Context API)。
pub fn dom_canvas_get_context(_it: &mut Interp, this: Value, args: &[Value]) -> Result<Value, Value> {
    let ctx_type = args.first().map(|v| v.to_js_string()).unwrap_or_default();
    if ctx_type.eq_ignore_ascii_case("2d") {
        // 面のサイズは `<canvas width height>` 属性から取る。
        // 属性が無い場合の既定は仕様どおり 300x150。
        // `this` はこの後 props へ move されるので、その前に読む。
        let (cw, ch) = match &this {
            Value::Object(o) => {
                let kind = o.borrow().kind.clone();
                if let ObjKind::DomElement(idx) = kind {
                    let d = _it.dom.borrow();
                    let w = d
                        .get_attr(idx, "width")
                        .and_then(|s| s.trim().parse::<u32>().ok())
                        .unwrap_or(300);
                    let h = d
                        .get_attr(idx, "height")
                        .and_then(|s| s.trim().parse::<u32>().ok())
                        .unwrap_or(150);
                    (w, h)
                } else {
                    (300, 150)
                }
            }
            _ => (300, 150),
        };
        let c2d_id = crate::os_lib::canvas2d::create_context(cw, ch);
        // レイアウト側（`web_engine/layout.rs`）は `StyledNode` しか見ないので、
        // id を DOM 属性へ書いて橋渡しする。JS のオブジェクトを直接引かせると
        // 層をまたぐ依存になる。
        if let (Some(id), Value::Object(o)) = (c2d_id, &this) {
            let kind = o.borrow().kind.clone();
            if let ObjKind::DomElement(idx) = kind {
                _it.dom
                    .borrow_mut()
                    .set_attr(idx, "_c2d_id", &alloc::format!("{}", id));
            }
        }
        let ctx = Obj::plain();
        {
            let mut b = ctx.borrow_mut();
            b.props.insert("canvas".into(), this);
            b.props.insert("fillStyle".into(), Value::str("#000000"));
            b.props.insert("strokeStyle".into(), Value::str("#000000"));
            b.props.insert("lineWidth".into(), Value::Number(1.0));
            b.props.insert("lineCap".into(), Value::str("butt"));
            b.props.insert("lineJoin".into(), Value::str("miter"));
            b.props.insert("miterLimit".into(), Value::Number(10.0));
            b.props.insert("lineDashOffset".into(), Value::Number(0.0));
            b.props.insert("font".into(), Value::str("10px sans-serif"));
            b.props.insert("textAlign".into(), Value::str("start"));
            b.props.insert("textBaseline".into(), Value::str("alphabetic"));
            b.props.insert("globalAlpha".into(), Value::Number(1.0));
            b.props.insert("globalCompositeOperation".into(), Value::str("source-over"));
            b.props.insert("shadowBlur".into(), Value::Number(0.0));
            b.props.insert("shadowColor".into(), Value::str("rgba(0, 0, 0, 0)"));
            b.props.insert("shadowOffsetX".into(), Value::Number(0.0));
            b.props.insert("shadowOffsetY".into(), Value::Number(0.0));
            b.props.insert("imageSmoothingEnabled".into(), Value::Bool(true));
            b.props.insert("direction".into(), Value::str("inherit"));
            b.props.insert("filter".into(), Value::str("none"));
            // 【2026-09-03】実描画へ接続する。従来これらは全て `dom_noop` で、
            // API 表面だけが存在し canvas は一切描画されなかった。
            // 幾何・ラスタライズは `os_lib/canvas2d.rs`（試験済み）にあり、
            // ここは registry の id を持たせて各メソッドから引くだけにする。
            if let Some(id) = c2d_id {
                b.props.insert("_c2d_id".into(), Value::Number(id as f64));
            }

            // 【2026-09-03】実描画へ接続する。
            //
            // 従来これらは全て `dom_noop` で、API 表面だけが存在し
            // canvas は一切描画されなかった。`os_lib/canvas2d.rs` の
            // `Canvas2dContext`（試験済み）を registry へ作り、その id を
            // `_c2d_id` として持たせて各メソッドから引く。
            //
            b.props.insert("fillRect".into(), nv("fillRect", canvas_fill_rect));
            b.props.insert("strokeRect".into(), nv("strokeRect", canvas_stroke_rect));
            b.props.insert("clearRect".into(), nv("clearRect", canvas_clear_rect));

            b.props.insert("beginPath".into(), nv("beginPath", canvas_begin_path));
            b.props.insert("closePath".into(), nv("closePath", canvas_close_path));
            b.props.insert("moveTo".into(), nv("moveTo", canvas_move_to));
            b.props.insert("lineTo".into(), nv("lineTo", canvas_line_to));
            b.props.insert("arc".into(), nv("arc", canvas_arc));
            b.props.insert("arcTo".into(), nv("arcTo", canvas_arc_to));
            b.props.insert("bezierCurveTo".into(), nv("bezierCurveTo", canvas_bezier_curve_to));
            b.props.insert("quadraticCurveTo".into(), nv("quadraticCurveTo", canvas_quadratic_curve_to));
            b.props.insert("ellipse".into(), nv("ellipse", canvas_ellipse));
            b.props.insert("rect".into(), nv("rect", canvas_rect));
            b.props.insert("roundRect".into(), nv("roundRect", canvas_round_rect));

            b.props.insert("fill".into(), nv("fill", canvas_fill));
            b.props.insert("stroke".into(), nv("stroke", canvas_stroke));
            b.props.insert("clip".into(), nv("clip", canvas_clip));

            b.props.insert("fillText".into(), nv("fillText", canvas_fill_text));
            b.props.insert("strokeText".into(), nv("strokeText", canvas_stroke_text));
            b.props.insert("measureText".into(), nv("measureText", canvas_measure_text));

            b.props.insert("drawImage".into(), nv("drawImage", canvas_draw_image));
            b.props.insert("getImageData".into(), nv("getImageData", canvas_get_image_data));
            b.props.insert("createImageData".into(), nv("createImageData", dom_canvas_create_image_data));
            b.props.insert("putImageData".into(), nv("putImageData", canvas_put_image_data));
            b.props.insert("isPointInPath".into(), nv("isPointInPath", dom_canvas_is_point_in_path));
            b.props.insert("isPointInStroke".into(), nv("isPointInStroke", dom_canvas_is_point_in_stroke));
            b.props.insert("getTransform".into(), nv("getTransform", dom_canvas_get_transform));
            b.props.insert("setLineDash".into(), nv("setLineDash", dom_canvas_set_line_dash));
            b.props.insert("getLineDash".into(), nv("getLineDash", dom_canvas_get_line_dash));
            b.props.insert("reset".into(), nv("reset", dom_canvas_reset));

            b.props.insert("createLinearGradient".into(), nv("createLinearGradient", dom_canvas_create_linear_gradient));
            b.props.insert("createRadialGradient".into(), nv("createRadialGradient", dom_canvas_create_radial_gradient));
            b.props.insert("createConicGradient".into(), nv("createConicGradient", dom_canvas_create_conic_gradient));
            b.props.insert("createPattern".into(), nv("createPattern", dom_canvas_create_pattern));

            b.props.insert("save".into(), nv("save", canvas_save));
            b.props.insert("restore".into(), nv("restore", canvas_restore));
            b.props.insert("scale".into(), nv("scale", canvas_scale));
            b.props.insert("rotate".into(), nv("rotate", canvas_rotate));
            b.props.insert("translate".into(), nv("translate", canvas_translate));
            b.props.insert("transform".into(), nv("transform", canvas_transform));
            b.props.insert("setTransform".into(), nv("setTransform", canvas_set_transform));
            b.props.insert("resetTransform".into(), nv("resetTransform", canvas_reset_transform));
        }
        return Ok(Value::Object(ctx));
    }
    // webgl/webgl2/bitmaprenderer は未実装なので、ブラウザが対応しない場合と同じく null を返す。
    // 【2026-10-17】従来はメソッドの無い空オブジェクトを返しており、機能判定（`ctx && ctx.getExtension(...)`）
    // が「対応している」と誤認して落ちていた（YouTube player の `getDebugText`）。
    Ok(Value::Null)
}

/// `<canvas>` 要素の `toDataURL(type, quality)` (HTML5 Canvas)。
pub fn dom_canvas_to_data_url(_it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let mime = args.first().map(|v| v.to_js_string()).unwrap_or_else(|| String::from("image/png"));
    let header = if mime.eq_ignore_ascii_case("image/jpeg") {
        "data:image/jpeg;base64,"
    } else if mime.eq_ignore_ascii_case("image/webp") {
        "data:image/webp;base64,"
    } else {
        "data:image/png;base64,"
    };
    // 1x1 透明 PNG の最小限データ URL
    let dummy_base64 = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
    Ok(Value::str(alloc::format!("{}{}", header, dummy_base64)))
}

/// `<canvas>` 要素の `toBlob(callback, type, quality)` (HTML5 Canvas)。
pub fn dom_canvas_to_blob(it: &mut Interp, _this: Value, args: &[Value]) -> Result<Value, Value> {
    let cb = args.first().cloned().unwrap_or(Value::Undefined);
    let mime = args.get(1).map(|v| v.to_js_string()).unwrap_or_else(|| String::from("image/png"));
    if matches!(cb, Value::Object(_)) {
        let blob = Obj::plain();
        {
            let mut b = blob.borrow_mut();
            b.props.insert("size".into(), Value::Number(68.0));
            b.props.insert("type".into(), Value::str(mime));
        }
        it.call_value(&cb, Value::Undefined, &[Value::Object(blob)])?;
    }
    Ok(Value::Undefined)
}


// ───────────── Canvas 2D の実描画（2026-09-03 追加） ─────────────
//
// これらは以前すべて `dom_noop` に接続されており、API 表面だけが存在して
// 一切描画されなかった。幾何とラスタライズは `os_lib/canvas2d.rs`
// （純粋モジュール・試験済み）にあり、ここは「JS の値を取り出して
// コンテキストへ渡す」薄い層に徹する。

/// Path2D オブジェクトから registry の id を取り出す。
fn path2d_id(this: &Value) -> Option<u32> {
    match this {
        Value::Object(o) => match o.borrow().props.get("_path2d_id") {
            Some(Value::Number(n)) if *n >= 0.0 => Some(*n as u32),
            _ => None,
        },
        _ => None,
    }
}

/// コンテキストオブジェクトから registry の id を取り出す。
fn canvas_ctx_id(this: &Value) -> Option<u32> {
    match this {
        Value::Object(o) => match o.borrow().props.get("_c2d_id") {
            Some(Value::Number(n)) if *n >= 0.0 => Some(*n as u32),
            _ => None,
        },
        _ => None,
    }
}

/// 引数を f32 で取る。非有限値は 0 とみなす（描画系でパニックさせない）。
fn canvas_arg_f32(a: &[Value], i: usize) -> f32 {
    let v = a.get(i).map(|v| v.to_number()).unwrap_or(0.0);
    if v.is_finite() {
        v as f32
    } else {
        0.0
    }
}

/// JS 側のスタイル文字列を ARGB へ解決する。
///
/// CSS の色解析（`css::parse_color`）をそのまま使う。解釈できない値は
/// 仕様上「無視して直前の値を保つ」だが、ここでは不透明な黒へ倒す
/// （描かれないより、既定色で描かれた方が原因に気づきやすい）。
fn canvas_style_argb(this: &Value, key: &str) -> u32 {
    let s = match this {
        Value::Object(o) => o
            .borrow()
            .props
            .get(key)
            .map(|v| v.to_js_string())
            .unwrap_or_default(),
        _ => String::new(),
    };
    crate::os_lib::css::parse_color(&s).unwrap_or(0xFF00_0000)
}

/// 描画前に、JS 側で書き換えられた状態をコンテキストへ反映する。
///
/// `fillStyle` 等は JS の素のプロパティなので、代入は検知できない。
/// 各描画メソッドの入口で毎回読み直すのが確実。
fn canvas_sync_state(this: &Value, ctx: &mut crate::os_lib::canvas2d::Canvas2dContext) {
    ctx.state.fill = canvas_style_argb(this, "fillStyle");
    ctx.state.stroke = canvas_style_argb(this, "strokeStyle");
    if let Value::Object(o) = this {
        let b = o.borrow();
        if let Some(Value::Number(n)) = b.props.get("globalAlpha") {
            if n.is_finite() {
                ctx.state.global_alpha = (*n as f32).clamp(0.0, 1.0);
            }
        }
        if let Some(Value::Number(n)) = b.props.get("lineWidth") {
            if n.is_finite() && *n > 0.0 {
                ctx.state.line_width = *n as f32;
            }
        }
        // 未知の値は無視して既定を保つ（仕様どおり代入を捨てる）。
        if let Some(Value::Str(s)) = b.props.get("lineCap") {
            if let Some(v) = crate::os_lib::canvas2d::parse_line_cap(s) {
                ctx.state.line_cap = v;
            }
        }
        if let Some(Value::Str(s)) = b.props.get("lineJoin") {
            if let Some(v) = crate::os_lib::canvas2d::parse_line_join(s) {
                ctx.state.line_join = v;
            }
        }
        if let Some(Value::Number(n)) = b.props.get("miterLimit") {
            if n.is_finite() && *n > 0.0 {
                ctx.state.miter_limit = *n as f32;
            }
        }
        // `setLineDash` が入れた配列。値の検査は `normalize_dash` に任せる
        // （不正なパターンはまるごと捨てるのが仕様）。
        ctx.state.line_dash.clear();
        if let Some(Value::Object(arr)) = b.props.get("_line_dash") {
            let ab = arr.borrow();
            if let ObjKind::Array(items) = &ab.kind {
                for v in items {
                    ctx.state.line_dash.push(v.to_number() as f32);
                }
            }
        }
        if let Some(Value::Number(n)) = b.props.get("lineDashOffset") {
            if n.is_finite() {
                ctx.state.line_dash_offset = *n as f32;
            }
        }
        if let Some(Value::Str(s)) = b.props.get("fillStyle") {
            ctx.state.fill_str = (**s).clone();
            ctx.state.fill_gradient = None;
            ctx.state.fill_pattern = None;
        } else if let Some(Value::Object(style_obj)) = b.props.get("fillStyle") {
            let sb = style_obj.borrow();
            if let Some(Value::Number(gid)) = sb.props.get("_gradient_id") {
                ctx.state.fill_gradient = crate::os_lib::canvas2d::get_gradient(*gid as u32);
                ctx.state.fill_pattern = None;
            } else if let Some(Value::Number(pid)) = sb.props.get("_pattern_id") {
                ctx.state.fill_pattern = crate::os_lib::canvas2d::get_pattern(*pid as u32);
                ctx.state.fill_gradient = None;
            } else {
                ctx.state.fill_gradient = None;
                ctx.state.fill_pattern = None;
            }
        } else {
            ctx.state.fill_gradient = None;
            ctx.state.fill_pattern = None;
        }
        if let Some(Value::Str(s)) = b.props.get("strokeStyle") {
            ctx.state.stroke_str = (**s).clone();
            ctx.state.stroke_gradient = None;
            ctx.state.stroke_pattern = None;
        } else if let Some(Value::Object(style_obj)) = b.props.get("strokeStyle") {
            let sb = style_obj.borrow();
            if let Some(Value::Number(gid)) = sb.props.get("_gradient_id") {
                ctx.state.stroke_gradient = crate::os_lib::canvas2d::get_gradient(*gid as u32);
                ctx.state.stroke_pattern = None;
            } else if let Some(Value::Number(pid)) = sb.props.get("_pattern_id") {
                ctx.state.stroke_pattern = crate::os_lib::canvas2d::get_pattern(*pid as u32);
                ctx.state.stroke_gradient = None;
            } else {
                ctx.state.stroke_gradient = None;
                ctx.state.stroke_pattern = None;
            }
        } else {
            ctx.state.stroke_gradient = None;
            ctx.state.stroke_pattern = None;
        }
        if let Some(Value::Str(s)) = b.props.get("font") {
            ctx.state.font_str = (**s).clone();
        }
        if let Some(Value::Str(s)) = b.props.get("textAlign") {
            ctx.state.text_align_str = (**s).clone();
        }
        if let Some(Value::Str(s)) = b.props.get("textBaseline") {
            ctx.state.text_baseline_str = (**s).clone();
        }
        if let Some(Value::Bool(sm)) = b.props.get("imageSmoothingEnabled") {
            ctx.state.image_smoothing_enabled = *sm;
        }
        if let Some(Value::Str(s)) = b.props.get("shadowColor") {
            ctx.state.shadow_color_str = (**s).clone();
            if let Some(c) = crate::os_lib::css::parse_color(s) {
                ctx.state.shadow_color = c;
            }
        }
        if let Some(Value::Number(n)) = b.props.get("shadowBlur") {
            if n.is_finite() && *n >= 0.0 {
                ctx.state.shadow_blur = *n as f32;
            }
        }
        if let Some(Value::Number(n)) = b.props.get("shadowOffsetX") {
            if n.is_finite() {
                ctx.state.shadow_offset_x = *n as f32;
            }
        }
        if let Some(Value::Number(n)) = b.props.get("shadowOffsetY") {
            if n.is_finite() {
                ctx.state.shadow_offset_y = *n as f32;
            }
        }
        if let Some(Value::Str(s)) = b.props.get("filter") {
            ctx.state.filter = (**s).clone();
        }
        if let Some(Value::Str(s)) = b.props.get("globalCompositeOperation") {
            ctx.state.global_composite_operation_str = (**s).clone();
            if let Some(op) = crate::os_lib::canvas2d::parse_composite_operation(s) {
                ctx.state.global_composite_operation = op;
            }
        }
        if let Some(Value::Str(s)) = b.props.get("direction") {
            if let Some(dir) = crate::os_lib::canvas2d::parse_canvas_direction(s) {
                ctx.state.direction = dir;
                ctx.state.direction_str = (**s).clone();
            }
        }
    }
}

pub fn canvas_fill_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y, w, h) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
            canvas_arg_f32(a, 3),
        );
        crate::os_lib::canvas2d::with_context(id, |c| {
            canvas_sync_state(&this, c);
            c.fill_rect(x, y, w, h);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_stroke_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y, w, h) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
            canvas_arg_f32(a, 3),
        );
        crate::os_lib::canvas2d::with_context(id, |c| {
            canvas_sync_state(&this, c);
            c.stroke_rect(x, y, w, h);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_clear_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y, w, h) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
            canvas_arg_f32(a, 3),
        );
        crate::os_lib::canvas2d::with_context(id, |c| c.clear_rect(x, y, w, h));
    }
    Ok(Value::Undefined)
}

pub fn canvas_begin_path(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| c.path.begin_path());
    }
    Ok(Value::Undefined)
}

pub fn canvas_close_path(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| c.path.close_path());
    }
    Ok(Value::Undefined)
}

pub fn canvas_move_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.move_to(&m, x, y);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_line_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.line_to(&m, x, y);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_rect(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y, w, h) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
            canvas_arg_f32(a, 3),
        );
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.rect(&m, x, y, w, h);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_arc(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (cx, cy, r) = (
            canvas_arg_f32(a, 0),
            canvas_arg_f32(a, 1),
            canvas_arg_f32(a, 2),
        );
        let start = canvas_arg_f32(a, 3);
        let end = canvas_arg_f32(a, 4);
        let ccw = a.get(5).map(|v| v.truthy()).unwrap_or(false);
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.arc(&m, cx, cy, r, start, end, ccw);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_arc_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x1, y1) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (x2, y2) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let radius = canvas_arg_f32(a, 4);
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.arc_to(&m, x1, y1, x2, y2, radius);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_fill(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        if let Some(pid) = a.first().and_then(path2d_id) {
            let rule = match a.get(1).map(|v| v.to_js_string()) {
                Some(s) if s.eq_ignore_ascii_case("evenodd") => {
                    crate::os_lib::canvas2d::FillRule::EvenOdd
                }
                _ => crate::os_lib::canvas2d::FillRule::NonZero,
            };
            if let Some(subpaths) = crate::os_lib::canvas2d::get_path2d_subpaths(pid) {
                crate::os_lib::canvas2d::with_context(id, |c| {
                    canvas_sync_state(&this, c);
                    c.fill_subpaths(&subpaths, rule);
                });
            }
        } else {
            // 第 1 引数は塗りつぶし規則（省略時は nonzero）。
            let rule = match a.first().map(|v| v.to_js_string()) {
                Some(s) if s.eq_ignore_ascii_case("evenodd") => {
                    crate::os_lib::canvas2d::FillRule::EvenOdd
                }
                _ => crate::os_lib::canvas2d::FillRule::NonZero,
            };
            crate::os_lib::canvas2d::with_context(id, |c| {
                canvas_sync_state(&this, c);
                c.fill(rule);
            });
        }
    }
    Ok(Value::Undefined)
}

pub fn canvas_stroke(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        if let Some(pid) = a.first().and_then(path2d_id) {
            if let Some(subpaths) = crate::os_lib::canvas2d::get_path2d_subpaths(pid) {
                crate::os_lib::canvas2d::with_context(id, |c| {
                    canvas_sync_state(&this, c);
                    c.stroke_subpaths(&subpaths);
                });
            }
        } else {
            crate::os_lib::canvas2d::with_context(id, |c| {
                canvas_sync_state(&this, c);
                // `lineWidth` を反映する（1 以下なら 1px 線の高速路へ落ちる）。
                c.stroke_with_width();
            });
        }
    }
    Ok(Value::Undefined)
}


/// `save()` — 現在の描画状態を退避する。
pub fn canvas_save(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| {
            // JS 側で書き換えられた状態も含めて退避したいので、
            // 先に読み直してから積む。
            canvas_sync_state(&this, c);
            c.save();
        });
    }
    Ok(Value::Undefined)
}

/// `restore()` — 直近の退避状態へ戻す。
///
/// 変換だけでなく `fillStyle` 等も戻すのが仕様だが、それらは JS の素の
/// プロパティなので、Rust 側で戻した値を JS へ書き戻す必要がある。
pub fn canvas_restore(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let restored = crate::os_lib::canvas2d::with_context(id, |c| {
            c.restore();
            (
                c.state.global_alpha,
                c.state.line_width,
                c.state.fill_str.clone(),
                c.state.stroke_str.clone(),
                c.state.font_str.clone(),
                c.state.text_align_str.clone(),
                c.state.text_baseline_str.clone(),
                c.state.miter_limit,
                c.state.line_dash_offset,
                c.state.line_dash.clone(),
                c.state.image_smoothing_enabled,
                match c.state.line_cap {
                    crate::os_lib::canvas2d::LineCap::Butt => "butt",
                    crate::os_lib::canvas2d::LineCap::Round => "round",
                    crate::os_lib::canvas2d::LineCap::Square => "square",
                },
                match c.state.line_join {
                    crate::os_lib::canvas2d::LineJoin::Miter => "miter",
                    crate::os_lib::canvas2d::LineJoin::Round => "round",
                    crate::os_lib::canvas2d::LineJoin::Bevel => "bevel",
                },
                c.state.shadow_blur,
                c.state.shadow_color_str.clone(),
                c.state.shadow_offset_x,
                c.state.shadow_offset_y,
                c.state.filter.clone(),
                c.state.global_composite_operation_str.clone(),
                c.state.direction_str.clone(),
            )
        });
        if let (Some(r), Value::Object(o)) = (restored, &this) {
            let mut b = o.borrow_mut();
            b.props.insert("globalAlpha".into(), Value::Number(r.0 as f64));
            b.props.insert("lineWidth".into(), Value::Number(r.1 as f64));
            b.props.insert("fillStyle".into(), Value::str(&r.2));
            b.props.insert("strokeStyle".into(), Value::str(&r.3));
            b.props.insert("font".into(), Value::str(&r.4));
            b.props.insert("textAlign".into(), Value::str(&r.5));
            b.props.insert("textBaseline".into(), Value::str(&r.6));
            b.props.insert("miterLimit".into(), Value::Number(r.7 as f64));
            b.props.insert("lineDashOffset".into(), Value::Number(r.8 as f64));
            b.props.insert("imageSmoothingEnabled".into(), Value::Bool(r.10));
            b.props.insert("lineCap".into(), Value::str(r.11));
            b.props.insert("lineJoin".into(), Value::str(r.12));
            b.props.insert("shadowBlur".into(), Value::Number(r.13 as f64));
            b.props.insert("shadowColor".into(), Value::str(&r.14));
            b.props.insert("shadowOffsetX".into(), Value::Number(r.15 as f64));
            b.props.insert("shadowOffsetY".into(), Value::Number(r.16 as f64));
            b.props.insert("filter".into(), Value::str(&r.17));
            b.props.insert("globalCompositeOperation".into(), Value::str(&r.18));
            b.props.insert("direction".into(), Value::str(&r.19));

            let dash_objs = r.9.iter().map(|d| Value::Number(*d as f64)).collect();
            b.props.insert("_line_dash".into(), Value::Object(Obj::array(dash_objs)));
        }
    }
    Ok(Value::Undefined)
}

pub fn canvas_translate(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (tx, ty) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        crate::os_lib::canvas2d::with_context(id, |c| c.translate(tx, ty));
    }
    Ok(Value::Undefined)
}

pub fn canvas_scale(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (sx, sy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        crate::os_lib::canvas2d::with_context(id, |c| c.scale(sx, sy));
    }
    Ok(Value::Undefined)
}

pub fn canvas_rotate(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let rad = canvas_arg_f32(a, 0);
        crate::os_lib::canvas2d::with_context(id, |c| c.rotate(rad));
    }
    Ok(Value::Undefined)
}

/// `transform(a,b,c,d,e,f)` — 現在の行列へ右から掛ける。
pub fn canvas_transform(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let m = crate::os_lib::canvas2d::Matrix {
            a: canvas_arg_f32(a, 0),
            b: canvas_arg_f32(a, 1),
            c: canvas_arg_f32(a, 2),
            d: canvas_arg_f32(a, 3),
            e: canvas_arg_f32(a, 4),
            f: canvas_arg_f32(a, 5),
        };
        crate::os_lib::canvas2d::with_context(id, |ctx| {
            let cur = ctx.state.transform;
            ctx.set_transform(cur.multiply(&m));
        });
    }
    Ok(Value::Undefined)
}

/// `setTransform(a,b,c,d,e,f)` — 行列を置き換える（積まない）。
pub fn canvas_set_transform(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let m = crate::os_lib::canvas2d::Matrix {
            a: canvas_arg_f32(a, 0),
            b: canvas_arg_f32(a, 1),
            c: canvas_arg_f32(a, 2),
            d: canvas_arg_f32(a, 3),
            e: canvas_arg_f32(a, 4),
            f: canvas_arg_f32(a, 5),
        };
        crate::os_lib::canvas2d::with_context(id, |ctx| ctx.set_transform(m));
    }
    Ok(Value::Undefined)
}

pub fn canvas_reset_transform(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| c.reset_transform());
    }
    Ok(Value::Undefined)
}

pub fn canvas_bezier_curve_to(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (c1x, c1y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (c2x, c2y) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let (x, y) = (canvas_arg_f32(a, 4), canvas_arg_f32(a, 5));
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.bezier_curve_to(&m, c1x, c1y, c2x, c2y, x, y);
        });
    }
    Ok(Value::Undefined)
}

pub fn canvas_quadratic_curve_to(
    _it: &mut Interp,
    this: Value,
    a: &[Value],
) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (cx, cy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (x, y) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.quadratic_curve_to(&m, cx, cy, x, y);
        });
    }
    Ok(Value::Undefined)
}


/// `ellipse(cx, cy, rx, ry, rotation, start, end, anticlockwise)`。
pub fn canvas_ellipse(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (cx, cy) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (rx, ry) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let rot = canvas_arg_f32(a, 4);
        let start = canvas_arg_f32(a, 5);
        let end = canvas_arg_f32(a, 6);
        let ccw = a.get(7).map(|v| v.truthy()).unwrap_or(false);
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.ellipse(&m, cx, cy, rx, ry, rot, start, end, ccw);
        });
    }
    Ok(Value::Undefined)
}

/// `roundRect(x, y, w, h, radii)`。
///
/// `radii` は数値 1 個・配列（1〜4 要素）のどちらも取りうる。
/// CSS の `border-radius` と同じ補完規則（1 個なら全隅、2 個なら
/// 対角の組、3 個なら左上・対角・右下）に従う。
pub fn canvas_round_rect(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        let (x, y) = (canvas_arg_f32(a, 0), canvas_arg_f32(a, 1));
        let (w, h) = (canvas_arg_f32(a, 2), canvas_arg_f32(a, 3));
        let radii = parse_round_rect_radii(it, a.get(4))?;
        crate::os_lib::canvas2d::with_context(id, |c| {
            let m = c.state.transform;
            c.path.round_rect(&m, x, y, w, h, radii);
        });
    }
    Ok(Value::Undefined)
}


/// `clip(fillRule)` または `clip(path, fillRule)`。クリップ領域を狭める。
pub fn canvas_clip(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    if let Some(id) = canvas_ctx_id(&this) {
        if let Some(pid) = a.first().and_then(path2d_id) {
            let rule = match a.get(1).map(|v| v.to_js_string()) {
                Some(s) if s.eq_ignore_ascii_case("evenodd") => {
                    crate::os_lib::canvas2d::FillRule::EvenOdd
                }
                _ => crate::os_lib::canvas2d::FillRule::NonZero,
            };
            if let Some(subpaths) = crate::os_lib::canvas2d::get_path2d_subpaths(pid) {
                crate::os_lib::canvas2d::with_context(id, |c| {
                    c.clip_subpaths(&subpaths, rule);
                });
            }
        } else {
            let rule = match a.first().map(|v| v.to_js_string()) {
                Some(s) if s.eq_ignore_ascii_case("evenodd") => {
                    crate::os_lib::canvas2d::FillRule::EvenOdd
                }
                _ => crate::os_lib::canvas2d::FillRule::NonZero,
            };
            crate::os_lib::canvas2d::with_context(id, |c| {
                c.clip(rule);
            });
        }
    }
    Ok(Value::Undefined)
}


/// `getImageData(x, y, w, h, [settings])`。面の内容を読んで `ImageData` を返す。
pub fn canvas_get_image_data(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let (x, y) = (canvas_arg_f32(a, 0) as i32, canvas_arg_f32(a, 1) as i32);
    let w = (canvas_arg_f32(a, 2).abs() as usize).max(1);
    let h = (canvas_arg_f32(a, 3).abs() as usize).max(1);
    let cs = parse_image_data_color_space(a.get(4));

    let items = if let Some(id) = canvas_ctx_id(&this) {
        crate::os_lib::canvas2d::with_context(id, |c| {
            let bytes = crate::os_lib::canvas2d::get_image_data(&c.surface, x, y, w as i32, h as i32);
            bytes.into_iter().map(|b| Value::Number(b as f64)).collect()
        }).unwrap_or_else(|| alloc::vec![Value::Number(0.0); w * h * 4])
    } else {
        alloc::vec![Value::Number(0.0); w * h * 4]
    };

    Ok(make_image_data_object(w, h, items, cs))
}

/// `putImageData(imageData, dx, dy)`。
///
/// 合成せず上書きし、クリップも無視する（仕様。`fill` 系と意味論が違う）。
pub fn canvas_put_image_data(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(id) = canvas_ctx_id(&this) else {
        return Ok(Value::Undefined);
    };
    let Some(Value::Object(img)) = a.first() else {
        return Ok(Value::Undefined);
    };
    let (w, h, bytes) = {
        let b = img.borrow();
        let w = b
            .props
            .get("width")
            .map(|v| v.to_number() as i32)
            .unwrap_or(0);
        let h = b
            .props
            .get("height")
            .map(|v| v.to_number() as i32)
            .unwrap_or(0);
        let mut bytes: alloc::vec::Vec<u8> = alloc::vec::Vec::new();
        if let Some(Value::Object(arr)) = b.props.get("data") {
            let ab = arr.borrow();
            if let ObjKind::Bytes(st) = &ab.kind {
                bytes = st.to_vec();
            }
            if let ObjKind::Array(items) = &ab.kind {
                bytes.reserve(items.len());
                for v in items {
                    let n = v.to_number();
                    // 仕様どおり 0〜255 へ丸めて収める。
                    bytes.push(if n.is_finite() {
                        n.clamp(0.0, 255.0) as u8
                    } else {
                        0
                    });
                }
            }
        }
        (w, h, bytes)
    };
    let (dx, dy) = (canvas_arg_f32(a, 1) as i32, canvas_arg_f32(a, 2) as i32);
    crate::os_lib::canvas2d::with_context(id, |c| {
        crate::os_lib::canvas2d::put_image_data(&mut c.surface, &bytes, w, h, dx, dy);
    });
    Ok(Value::Undefined)
}


/// `drawImage` の転送元。`<img>` と別の canvas を扱う。
enum DrawSrc {
    /// デコード済み画像（`<img>`）。
    Image(alloc::sync::Arc<crate::os_lib::web_engine::DecodedImage>),
    /// 別の canvas の画素を RGBA8 へ写したもの。
    Canvas(u32, u32, alloc::vec::Vec<u8>),
}

/// 転送元の値から画素を取り出す。
///
/// `<img>` は `src` 属性で共有の置き場を引く。
/// canvas は `_c2d_id` からコンテキストを引いて画素を写す
/// （同じコンテキストを二重に借りないよう、ここで写しを作る）。
fn draw_src_from(it: &mut Interp, v: &Value) -> Option<DrawSrc> {
    let Value::Object(o) = v else {
        return None;
    };
    let idx = match o.borrow().kind {
        ObjKind::DomElement(i) => Some(i),
        _ => None,
    }?;
    let (tag, src, cid) = {
        let dom = it.dom.borrow();
        let tag = dom.nodes.get(idx).map(|n| n.tag.clone()).unwrap_or_default();
        let src = dom.get_attr(idx, "src").unwrap_or_default();
        let cid = dom
            .get_attr(idx, "_c2d_id")
            .and_then(|s| s.parse::<u32>().ok());
        (tag, src, cid)
    };
    if tag == "canvas" {
        let id = cid?;
        return crate::os_lib::canvas2d::with_context(id, |c| {
            let (w, h) = (c.surface.width, c.surface.height);
            DrawSrc::Canvas(w, h, crate::os_lib::canvas2d::get_image_data(
                &c.surface, 0, 0, w as i32, h as i32,
            ))
        });
    }
    crate::os_lib::web_engine::shared_image(&src).map(DrawSrc::Image)
}

/// `drawImage(img, dx, dy)` / `(img, dx, dy, dw, dh)` /
/// `(img, sx, sy, sw, sh, dx, dy, dw, dh)`。
pub fn canvas_draw_image(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(id) = canvas_ctx_id(&this) else {
        return Ok(Value::Undefined);
    };
    let Some(src) = a.first().and_then(|v| draw_src_from(it, v)) else {
        return Ok(Value::Undefined);
    };
    let (sw, sh, bytes): (u32, u32, &[u8]) = match &src {
        DrawSrc::Image(img) => (img.width, img.height, &img.rgba),
        DrawSrc::Canvas(w, h, b) => (*w, *h, b),
    };
    // 引数の個数で意味が変わる（仕様）。3・5・9 個のいずれか。
    let spec = match a.len() {
        0..=2 => return Ok(Value::Undefined),
        3 | 4 => crate::os_lib::canvas2d::BlitSpec {
            sx: 0.0,
            sy: 0.0,
            sw: sw as f32,
            sh: sh as f32,
            dx: canvas_arg_f32(a, 1),
            dy: canvas_arg_f32(a, 2),
            dw: sw as f32,
            dh: sh as f32,
        },
        5..=8 => crate::os_lib::canvas2d::BlitSpec {
            sx: 0.0,
            sy: 0.0,
            sw: sw as f32,
            sh: sh as f32,
            dx: canvas_arg_f32(a, 1),
            dy: canvas_arg_f32(a, 2),
            dw: canvas_arg_f32(a, 3),
            dh: canvas_arg_f32(a, 4),
        },
        _ => crate::os_lib::canvas2d::BlitSpec {
            sx: canvas_arg_f32(a, 1),
            sy: canvas_arg_f32(a, 2),
            sw: canvas_arg_f32(a, 3),
            sh: canvas_arg_f32(a, 4),
            dx: canvas_arg_f32(a, 5),
            dy: canvas_arg_f32(a, 6),
            dw: canvas_arg_f32(a, 7),
            dh: canvas_arg_f32(a, 8),
        },
    };
    let image = crate::os_lib::canvas2d::ImageSource {
        width: sw,
        height: sh,
        rgba: bytes,
    };
    crate::os_lib::canvas2d::with_context(id, |c| {
        canvas_sync_state(&this, c);
        c.sync_clip();
        let m = c.state.transform;
        let alpha = c.state.global_alpha;
        let smooth = c.state.image_smoothing_enabled;
        let filter = c.state.filter.clone();
        c.surface.draw_image_with_filter(&image, &spec, &m, alpha, smooth, &filter);
    });
    Ok(Value::Undefined)
}


/// 1 文字ぶんの字形を、フォントの錠を**持たずに**扱えるよう写したもの。
struct OwnedGlyph {
    width: u32,
    height: u32,
    x_offset: i32,
    y_offset: i32,
    advance: f32,
    alpha: alloc::vec::Vec<u8>,
}

/// 文字列ぶんの字形を取り出す。
///
/// 【重要】フォントの錠を**描画中に持ち続けない**。
/// `GLOBAL_VECTOR_FONT` は毎フレームの文字描画が使う。低優先度の側が
/// 握ったまま長く走ると、提示ループが `spin::Mutex` で回り続けて
/// 優先度逆転を起こす（`image_results_ready` で実際に踏んだ）。
/// ここで写しを作って錠を放し、描画は錠の外で行う。
fn glyphs_for(text: &str, size_px: u32) -> alloc::vec::Vec<OwnedGlyph> {
    let mut out = alloc::vec::Vec::new();
    let mut font_lock = crate::kernel::vector_font::GLOBAL_VECTOR_FONT.lock();
    let Some(font) = font_lock.as_mut() else {
        return out;
    };
    for c in text.chars() {
        if let Some(g) = font.get_glyph(c, size_px) {
            out.push(OwnedGlyph {
                width: g.width,
                height: g.height,
                x_offset: g.x_offset,
                y_offset: g.y_offset,
                advance: g.advance as f32,
                alpha: g.data.clone(),
            });
        }
    }
    out
}

/// コンテキストの `font` から文字の大きさ（px）を得る。既定は 10px。
fn canvas_font_size(this: &Value) -> f32 {
    let Value::Object(o) = this else {
        return 10.0;
    };
    let b = o.borrow();
    let Some(Value::Str(s)) = b.props.get("font") else {
        return 10.0;
    };
    crate::os_lib::canvas2d::parse_font_size(s).unwrap_or(10.0)
}

/// `fillText(text, x, y)`。
///
/// `strokeText` も同じ処理へ回す。線でなぞる形は未対応で、
/// 塗りで代用する（何も描かないよりは近い）。

fn canvas_text_layout_params(
    this: &Value,
) -> (
    crate::os_lib::canvas2d::TextAlign,
    crate::os_lib::canvas2d::TextBaseline,
    crate::os_lib::canvas2d::CanvasDirection,
) {
    let mut al = crate::os_lib::canvas2d::TextAlign::Start;
    let mut bl = crate::os_lib::canvas2d::TextBaseline::Alphabetic;
    let mut dir = crate::os_lib::canvas2d::CanvasDirection::Inherit;
    if let Value::Object(o) = this {
        let b = o.borrow();
        if let Some(Value::Str(s)) = b.props.get("textAlign") {
            if let Some(v) = crate::os_lib::canvas2d::parse_text_align(s) {
                al = v;
            }
        }
        if let Some(Value::Str(s)) = b.props.get("textBaseline") {
            if let Some(v) = crate::os_lib::canvas2d::parse_text_baseline(s) {
                bl = v;
            }
        }
        if let Some(Value::Str(s)) = b.props.get("direction") {
            if let Some(v) = crate::os_lib::canvas2d::parse_canvas_direction(s) {
                dir = v;
            }
        }
    }
    (al, bl, dir)
}

/// `strokeText(text, x, y)`。
///
/// `strokeStyle` と `lineWidth` を反映して輪郭線を描く。
pub fn canvas_stroke_text(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(id) = canvas_ctx_id(&this) else {
        return Ok(Value::Undefined);
    };
    let text = a.first().map(|v| v.to_js_string()).unwrap_or_default();
    if text.is_empty() {
        return Ok(Value::Undefined);
    }
    let (x, y) = (canvas_arg_f32(a, 1), canvas_arg_f32(a, 2));
    if !x.is_finite() || !y.is_finite() {
        return Ok(Value::Undefined);
    }
    let size = canvas_font_size(&this);
    let glyphs = glyphs_for(&text, size as u32);
    if glyphs.is_empty() {
        return Ok(Value::Undefined);
    }
    let total: f32 = glyphs.iter().map(|g| g.advance).sum();

    let (align, baseline, dir) = canvas_text_layout_params(&this);
    let x0 = x + crate::os_lib::canvas2d::align_offset_with_direction(align, total, dir);
    let y0 = y + crate::os_lib::canvas2d::baseline_offset(baseline, size);

    crate::os_lib::canvas2d::with_context(id, |c| {
        canvas_sync_state(&this, c);
        c.sync_clip();
        let stroke_color = c.apply_alpha(c.state.stroke);
        let line_width = c.state.line_width;
        let m = c.state.transform;
        if c.state.has_shadow() {
            let shadow_color = c.shadow_color_argb();
            let mut pen = x0 + c.state.shadow_offset_x;
            let sy = y0 + c.state.shadow_offset_y;
            for g in &glyphs {
                let bm = crate::os_lib::canvas2d::GlyphBitmap {
                    width: g.width,
                    height: g.height,
                    x_offset: g.x_offset,
                    y_offset: g.y_offset,
                    advance: g.advance,
                    alpha: &g.alpha,
                };
                c.surface.draw_glyph_stroke(&bm, pen, sy, shadow_color, line_width, &m);
                pen += g.advance;
            }
        }
        let mut pen = x0;
        for g in &glyphs {
            let bm = crate::os_lib::canvas2d::GlyphBitmap {
                width: g.width,
                height: g.height,
                x_offset: g.x_offset,
                y_offset: g.y_offset,
                advance: g.advance,
                alpha: &g.alpha,
            };
            c.surface.draw_glyph_stroke(&bm, pen, y0, stroke_color, line_width, &m);
            pen += g.advance;
        }
    });
    Ok(Value::Undefined)
}

pub fn canvas_fill_text(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let Some(id) = canvas_ctx_id(&this) else {
        return Ok(Value::Undefined);
    };
    let text = a.first().map(|v| v.to_js_string()).unwrap_or_default();
    if text.is_empty() {
        return Ok(Value::Undefined);
    }
    let (x, y) = (canvas_arg_f32(a, 1), canvas_arg_f32(a, 2));
    if !x.is_finite() || !y.is_finite() {
        return Ok(Value::Undefined);
    }
    let size = canvas_font_size(&this);
    let glyphs = glyphs_for(&text, size as u32);
    if glyphs.is_empty() {
        return Ok(Value::Undefined);
    }
    let total: f32 = glyphs.iter().map(|g| g.advance).sum();

    let (align, baseline, dir) = canvas_text_layout_params(&this);
    let x0 = x + crate::os_lib::canvas2d::align_offset_with_direction(align, total, dir);
    let y0 = y + crate::os_lib::canvas2d::baseline_offset(baseline, size);

    crate::os_lib::canvas2d::with_context(id, |c| {
        canvas_sync_state(&this, c);
        c.sync_clip();
        let color = c.apply_alpha(c.state.fill);
        let m = c.state.transform;
        if c.state.has_shadow() {
            let shadow_color = c.shadow_color_argb();
            let mut pen = x0 + c.state.shadow_offset_x;
            let sy = y0 + c.state.shadow_offset_y;
            for g in &glyphs {
                let bm = crate::os_lib::canvas2d::GlyphBitmap {
                    width: g.width,
                    height: g.height,
                    x_offset: g.x_offset,
                    y_offset: g.y_offset,
                    advance: g.advance,
                    alpha: &g.alpha,
                };
                c.surface.draw_glyph(&bm, pen, sy, shadow_color, &m);
                pen += g.advance;
            }
        }
        let mut pen = x0;
        for g in &glyphs {
            let bm = crate::os_lib::canvas2d::GlyphBitmap {
                width: g.width,
                height: g.height,
                x_offset: g.x_offset,
                y_offset: g.y_offset,
                advance: g.advance,
                alpha: &g.alpha,
            };
            c.surface.draw_glyph(&bm, pen, y0, color, &m);
            pen += g.advance;
        }
    });
    Ok(Value::Undefined)
}

/// `measureText(text)`。
///
/// 従来はバイト長 × 8 を返していた。日本語では実際と大きくずれ、
/// `font` の大きさも無視していた。字形の送り幅を実測する。
pub fn canvas_measure_text(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let text = a.first().map(|v| v.to_js_string()).unwrap_or_default();
    let size = canvas_font_size(&this);
    let glyphs = glyphs_for(&text, size as u32);
    if glyphs.is_empty() && !text.is_empty() {
        // フォントが無い（未初期化）ときは従来の概算へ落ちる。
        return dom_canvas_measure_text(it, this, a);
    }
    let width: f32 = glyphs.iter().map(|g| g.advance).sum();
    let obj = Obj::plain();
    {
        let mut b = obj.borrow_mut();
        b.props.insert("width".into(), Value::Number(width as f64));
        // 上下の張り出しは字形の実測から出す。
        let ascent = glyphs
            .iter()
            .map(|g| -g.y_offset)
            .max()
            .unwrap_or(0)
            .max(0) as f64;
        let descent = glyphs
            .iter()
            .map(|g| g.y_offset + g.height as i32)
            .max()
            .unwrap_or(0)
            .max(0) as f64;
        b.props
            .insert("actualBoundingBoxAscent".into(), Value::Number(ascent));
        b.props
            .insert("actualBoundingBoxDescent".into(), Value::Number(descent));
        b.props.insert(
            "fontBoundingBoxAscent".into(),
            Value::Number((size * 0.85) as f64),
        );
        b.props.insert(
            "fontBoundingBoxDescent".into(),
            Value::Number((size * 0.15) as f64),
        );
        let (align, _, dir) = canvas_text_layout_params(&this);
        let align_off = crate::os_lib::canvas2d::align_offset_with_direction(align, width, dir);
        let actual_left = -align_off;
        let actual_right = width + align_off;
        b.props
            .insert("actualBoundingBoxLeft".into(), Value::Number(actual_left as f64));
        b.props.insert(
            "actualBoundingBoxRight".into(),
            Value::Number(actual_right as f64),
        );
    }
    Ok(Value::Object(obj))
}

/// Web Components: `element.attachShadow({ mode: 'open' | 'closed' })`
pub(crate) fn dom_attach_shadow(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let host_idx = match this_dom_idx(&this) {
        Some(i) => i,
        None => return Err(it.type_error("attachShadow must be called on an Element")),
    };

    let opt = arg(a, 0);
    let mode_str = match &opt {
        Value::Object(o) => o
            .borrow()
            .props
            .get("mode")
            .map(|v| v.to_js_string())
            .unwrap_or_default(),
        _ => alloc::string::String::new(),
    };

    let mode = match crate::os_lib::shadow_dom::ShadowRootMode::from_str(&mode_str) {
        Some(m) => m,
        None => {
            return Err(it.type_error(
                "Failed to execute 'attachShadow' on 'Element': The provided value is not a valid enum value of type ShadowRootMode ('open' or 'closed')",
            ))
        }
    };

    match it.dom.borrow_mut().attach_shadow(host_idx, mode) {
        Ok(root_idx) => {
            let root_obj = Obj::dom(root_idx);
            {
                let mut ro = root_obj.borrow_mut();
                ro.props.insert("mode".into(), Value::str(mode.as_str()));
                ro.props.insert("host".into(), this.clone());
            }
            Ok(Value::Object(root_obj))
        }
        Err(crate::os_lib::shadow_dom::AttachShadowError::AlreadyHasShadowRoot) => {
            Err(make_dom_exception(
                "InvalidStateError",
                "Shadow root cannot be created on a host which already hosts a shadow tree",
            ))
        }
        Err(crate::os_lib::shadow_dom::AttachShadowError::DisallowedTag) => {
            Err(make_dom_exception(
                "NotSupportedError",
                "This element does not support attachShadow",
            ))
        }
        Err(_) => Err(make_dom_exception(
            "NotSupportedError",
            "Failed to attach shadow root",
        )),
    }
}

/// Web Components: `customElements.define(name, constructor, options)`
pub(crate) fn custom_elements_define(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let name = arg(a, 0).to_js_string();
    let ctor = arg(a, 1);

    if !crate::os_lib::custom_elements::is_valid_custom_element_name(&name) {
        return Err(it.type_error(alloc::format!("Failed to execute 'define' on 'CustomElementRegistry': \"{}\" is not a valid custom element name", name)));
    }

    if !matches!(ctor, Value::Object(_)) {
        return Err(it.type_error("Failed to execute 'define' on 'CustomElementRegistry': The referenced script is not a constructor"));
    }

    // observedAttributes をコンストラクタから取得（静的 getter もある。Polymer は
    // `static get observedAttributes()` で返す。【2026-10-20】従来は props しか見ず空だった）。
    let mut observed_attrs = alloc::vec::Vec::new();
    let obs_val = it.get_property(&ctor, "observedAttributes")?;
    if !matches!(obs_val, Value::Undefined | Value::Null) {
        for item in array_like_items(it, &obs_val) {
            observed_attrs.push(item.to_js_string());
        }
    }

    // DomBridge の custom_elements レジストリに登録
    match it.dom.borrow_mut().custom_elements.define(&name, observed_attrs) {
        Ok(()) => {}
        Err(crate::os_lib::custom_elements::DefineError::AlreadyDefined) => {
            return Err(make_dom_exception(
                "NotSupportedError",
                &alloc::format!("Failed to execute 'define' on 'CustomElementRegistry': the name \"{}\" has already been used with this registry", name),
            ));
        }
        Err(crate::os_lib::custom_elements::DefineError::InvalidName) => {
            return Err(it.type_error(alloc::format!("\"{}\" is not a valid custom element name", name)));
        }
    }

    // JS 側の this (CustomElementRegistry オブジェクト) の `_registry` にコンストラクタを保持
    if let Value::Object(reg_obj) = &this {
        if let Some(Value::Object(map)) = reg_obj.borrow().props.get("_registry") {
            map.borrow_mut().props.insert(name.clone(), ctor.clone());
        }
    }

    // 文書に接続済みの同名要素を木順に昇格する（コンストラクタ → connectedCallback）。
    // 【2026-10-20】従来は使い捨てのハンドルに原型を付けるだけで、昇格していなかった。
    let matching_indices: alloc::vec::Vec<usize> = {
        let mut dom = it.dom.borrow_mut();
        for n in dom.nodes.iter_mut().filter(|n| !n.is_text && n.tag.eq_ignore_ascii_case(&name)) {
            n.attrs.insert(alloc::string::String::from("_defined"), alloc::string::String::from("true"));
        }
        let root = 0;
        dom.subtree_elements(root)
            .into_iter()
            .filter(|&i| dom.nodes[i].tag.eq_ignore_ascii_case(&name))
            .collect()
    };
    for idx in matching_indices {
        it.ce_try_upgrade(idx, true);
    }

    Ok(Value::Undefined)
}

/// Web Components: `customElements.get(name)`
pub(crate) fn custom_elements_get(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let name = arg(a, 0).to_js_string();
    if let Value::Object(reg_obj) = this {
        if let Some(Value::Object(map)) = reg_obj.borrow().props.get("_registry") {
            if let Some(ctor) = map.borrow().props.get(&name) {
                return Ok(ctor.clone());
            }
        }
    }
    Ok(Value::Undefined)
}

/// Web Components: `customElements.whenDefined(name)`
pub(crate) fn custom_elements_when_defined(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let name = arg(a, 0).to_js_string();
    if !crate::os_lib::custom_elements::is_valid_custom_element_name(&name) {
        let err = it.type_error(alloc::format!("\"{}\" is not a valid custom element name", name));
        return Ok(rejected_promise(it, err));
    }
    let is_def = if let Value::Object(reg_obj) = &this {
        if let Some(Value::Object(map)) = reg_obj.borrow().props.get("_registry") {
            map.borrow().props.contains_key(&name)
        } else {
            false
        }
    } else {
        false
    };

    if is_def {
        Ok(resolved_promise(it, Value::Undefined))
    } else {
        Ok(resolved_promise(it, Value::Undefined))
    }
}

/// Web Components: `customElements.upgrade(root)`
pub(crate) fn custom_elements_upgrade(_it: &mut Interp, _this: Value, _a: &[Value]) -> Result<Value, Value> {
    Ok(Value::Undefined)
}



/// `new Image(width?, height?)`: `<img>` 要素を作る（`document.createElement('img')` と同じ）。
pub(crate) fn image_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let idx = it.dom.borrow_mut().create_element("img");
    for (i, name) in ["width", "height"].iter().enumerate() {
        if let Some(v) = a.get(i).filter(|v| !matches!(v, Value::Undefined)) {
            let n = v.to_number();
            if n.is_finite() {
                it.dom.borrow_mut().set_attr(idx, name, &alloc::format!("{}", n as i64));
            }
        }
    }
    Ok(Value::Object(Obj::dom(idx)))
}

/// `new Audio(src?)`: `<audio preload="auto">` 要素を作る。
pub(crate) fn audio_ctor(it: &mut Interp, _t: Value, a: &[Value]) -> Result<Value, Value> {
    let idx = it.dom.borrow_mut().create_element("audio");
    it.dom.borrow_mut().set_attr(idx, "preload", "auto");
    if let Some(v) = a.first().filter(|v| !matches!(v, Value::Undefined)) {
        let src = v.to_js_string();
        it.dom.borrow_mut().set_attr(idx, "src", &src);
    }
    Ok(Value::Object(Obj::dom(idx)))
}