atmos/os_lib/js/builtins/

mse.rs

//! W3C Media Source Extensions (MSE) の JavaScript バインディング
//!
//! `MediaSource`、`SourceBuffer`、`SourceBufferList`、`TimeRanges` のコンストラクタおよび
//! ネイティブメソッドを提供する。

use super::*;
use crate::os_lib::mse::{MediaSourceCore, SourceBufferCore, TimeRanges};

/// SourceBuffer の実体（fMP4 の解析結果）。JS オブジェクトの `_sb_id` で引く。
/// 【2026-10-17】従来の JS 側はバイト列を読まずに仮の buffered を作るだけだった。
/// 再生側（<video>）がここからサンプルを取り出す。
pub(crate) static SOURCE_BUFFERS: spin::Mutex<Vec<SourceBufferCore>> = spin::Mutex::new(Vec::new());
static NEXT_SB_ID: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(1);
static NEXT_MS_ID: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(1);

/// `URL.createObjectURL(mediaSource)` の URL と MediaSource の番号、endOfStream 済みか。
/// 再生スレッド（JS のオブジェクトに触れない）が `<video src>` から SourceBuffer を引くのに使う。
pub(crate) static MEDIA_SOURCE_URLS: spin::Mutex<Vec<(String, usize, bool)>> = spin::Mutex::new(Vec::new());

fn ms_id_of(v: &Value) -> usize {
    match v {
        Value::Object(o) => o.borrow().props.get("_ms_id").map_or(0, |x| x.to_number() as usize),
        _ => 0,
    }
}

/// `URL.createObjectURL(ms)` から呼ぶ。
pub(crate) fn register_media_source_url(url: &str, ms: &Value) {
    let id = ms_id_of(ms);
    if id != 0 {
        MEDIA_SOURCE_URLS.lock().push((String::from(url), id, false));
    }
}

/// MSE の `<video>.readyState`: 初期化セグメントのみ = 1（HAVE_METADATA）、サンプルあり = 4。
pub(crate) fn media_source_ready_state(url: &str) -> Option<u8> {
    let (id, _) = media_source_for_url(url)?;
    let list = SOURCE_BUFFERS.lock();
    let mine: Vec<&SourceBufferCore> = list.iter().filter(|b| b.owner == id).collect();
    if mine.iter().any(|b| !b.samples.is_empty()) {
        Some(4)
    } else if mine.iter().any(|b| !b.demux.tracks.is_empty()) {
        Some(1)
    } else {
        Some(0)
    }
}

/// MSE の buffered の終わり（秒。全 SourceBuffer の最大）。
pub(crate) fn media_source_buffered_end(url: &str) -> Option<f64> {
    let (id, _) = media_source_for_url(url)?;
    let list = SOURCE_BUFFERS.lock();
    list.iter()
        .filter(|b| b.owner == id)
        .filter_map(|b| b.buffered.ranges.last().map(|r| r.end))
        .reduce(f64::max)
}

/// MSE の `<video>.buffered`: サンプルを持つ全 SourceBuffer の buffered の共通部分。
pub(crate) fn media_element_buffered(url: &str) -> Option<Value> {
    let (id, _) = media_source_for_url(url)?;
    let list = SOURCE_BUFFERS.lock();
    let tr = list
        .iter()
        .filter(|b| b.owner == id && !b.buffered.is_empty())
        .map(|b| b.buffered.clone())
        .reduce(|acc, b| acc.intersect(&b))
        .unwrap_or_default();
    Some(make_time_ranges_object(&tr))
}

/// MSE の `<video>.seekable`: `[0, duration]`（長さが分からなければ空）。
pub(crate) fn media_element_seekable(duration: Option<f64>) -> Value {
    let mut tr = TimeRanges::new();
    if let Some(d) = duration {
        tr.add(0.0, d);
    }
    make_time_ranges_object(&tr)
}

/// MSE の `<video>.videoWidth` / `.videoHeight`: SourceBuffer の初期化セグメントから得られた寸法。
pub(crate) fn media_source_video_dimensions(url: &str) -> Option<(u32, u32)> {
    let (id, _) = media_source_for_url(url)?;
    let list = SOURCE_BUFFERS.lock();
    list.iter()
        .filter(|b| b.owner == id)
        .find_map(SourceBufferCore::video_dimensions)
}

/// blob URL → (MediaSource の番号, endOfStream 済みか)。
pub(crate) fn media_source_for_url(url: &str) -> Option<(usize, bool)> {
    MEDIA_SOURCE_URLS.lock().iter().find(|(u, _, _)| u == url).map(|(_, id, ended)| (*id, *ended))
}

/// `MediaSource` コンストラクタ (`new MediaSource()`)
pub(crate) fn media_source_ctor(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    let obj = match this {
        Value::Object(o) => o,
        _ => Obj::plain(),
    };

    let source_buffers = Obj::array(alloc::vec![]);
    let active_buffers = Obj::array(alloc::vec![]);

    {
        let mut m = obj.borrow_mut();
        m.props.insert("readyState".into(), Value::str("closed"));
        m.props.insert("duration".into(), Value::Number(0.0));
        m.props.insert("sourceBuffers".into(), Value::Object(source_buffers.clone()));
        m.props.insert("activeSourceBuffers".into(), Value::Object(active_buffers));
        m.props.insert("addSourceBuffer".into(), nv("MediaSource.addSourceBuffer", media_source_add_source_buffer));
        m.props.insert("removeSourceBuffer".into(), nv("MediaSource.removeSourceBuffer", media_source_remove_source_buffer));
        m.props.insert("endOfStream".into(), nv("MediaSource.endOfStream", media_source_end_of_stream));
        m.props.insert("setLiveSeekableRange".into(), nv("MediaSource.setLiveSeekableRange", media_source_set_live_seekable_range));
        m.props.insert("clearLiveSeekableRange".into(), nv("MediaSource.clearLiveSeekableRange", media_source_clear_live_seekable_range));
        m.props.insert("_listeners".into(), Value::Object(Obj::plain()));
        m.props.insert("_is_media_source".into(), Value::Bool(true));
        m.props.insert("addEventListener".into(), nv("addEventListener", event_target_add_event_listener));
        m.props.insert("removeEventListener".into(), nv("removeEventListener", event_target_remove_event_listener));
        m.props.insert("dispatchEvent".into(), nv("dispatchEvent", event_target_dispatch_event));
        m.props.insert("onsourceopen".into(), Value::Null);
        m.props.insert("onsourceended".into(), Value::Null);
        m.props.insert("onsourceclose".into(), Value::Null);
        m.props.insert("_core".into(), Value::Object(Obj::plain()));
        m.props.insert(
            "_ms_id".into(),
            Value::Number(NEXT_MS_ID.fetch_add(1, core::sync::atomic::Ordering::Relaxed) as f64),
        );
    }

    Ok(Value::Object(obj))
}

/// MediaSource を open 状態へ遷移させ、sourceopen イベントをディスパッチする
pub(crate) fn media_source_open_internal(it: &mut Interp, ms: &Value) {
    if let Value::Object(o) = ms {
        let is_already_open = {
            let b = o.borrow();
            b.props.get("readyState").map(|v| v.to_js_string()).as_deref() == Some("open")
        };
        if !is_already_open {
            o.borrow_mut().props.insert("readyState".into(), Value::str("open"));
            dispatch_mse_event(it, ms, "sourceopen");
        }
    }
}

/// MSE / SourceBuffer のイベントディスパッチ（on<type> と addEventListener の両方を実行）
pub(crate) fn dispatch_mse_event(it: &mut Interp, target: &Value, event_type: &str) {
    let ev = Obj::plain();
    {
        let mut e = ev.borrow_mut();
        e.props.insert("type".into(), Value::str(event_type));
        e.props.insert("target".into(), target.clone());
        e.props.insert("currentTarget".into(), target.clone());
    }
    let ev_val = Value::Object(ev);

    // 1. on<type> プロパティハンドラ
    let handler_key = alloc::format!("on{}", event_type);
    let handler = if let Value::Object(t) = target {
        t.borrow().props.get(&handler_key).cloned()
    } else {
        None
    };
    // `on<type>` が null / 関数以外なら呼ばない（従来は null を呼んで例外を報告していた）。
    if let Some(h) = handler.filter(|h| matches!(h, Value::Object(o) if o.borrow().is_callable())) {
        let ctx = alloc::format!("{} on-handler", event_type);
        it.call_listener(&h, target.clone(), core::slice::from_ref(&ev_val), &ctx);
    }

    // 2. addEventListener リスナー
    let _ = event_target_dispatch_event(it, target.clone(), &[ev_val]);
}

/// `MediaSource.isTypeSupported(mimeType)` 静的メソッド
pub(crate) fn media_source_is_type_supported(_it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let mime = arg(a, 0).to_js_string();
    let supported = MediaSourceCore::is_type_supported(&mime);
    Ok(Value::Bool(supported))
}

/// `ms.addSourceBuffer(mimeType)`
pub(crate) fn media_source_add_source_buffer(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let mime = arg(a, 0).to_js_string();
    if !MediaSourceCore::is_type_supported(&mime) {
        return Err(it.type_error(alloc::format!("Unsupported MIME type: {}", mime)));
    }

    if let Value::Object(ms_obj) = &this {
        let mut m = ms_obj.borrow_mut();
        // open 状態でなければ InvalidStateError
        let ready_state = m.props.get("readyState").map(|v| v.to_js_string()).unwrap_or_else(|| "closed".into());
        if ready_state != "open" {
            // 自動で open する（ブラウザで URL 割り当て時等）
            m.props.insert("readyState".into(), Value::str("open"));
        }

        let owner = m.props.get("_ms_id").map_or(0, |x| x.to_number() as usize);
        let sb_obj = make_source_buffer_object(&mime, owner);

        if let Some(Value::Object(sbl)) = m.props.get("sourceBuffers") {
            if let ObjKind::Array(ref mut vec) = sbl.borrow_mut().kind {
                vec.push(sb_obj.clone());
            }
        }

        return Ok(sb_obj);
    }

    Err(it.type_error("addSourceBuffer called on non-MediaSource"))
}

/// `ms.removeSourceBuffer(sourceBuffer)`
pub(crate) fn media_source_remove_source_buffer(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let target = arg(a, 0);
    if let Value::Object(ms_obj) = &this {
        let m = ms_obj.borrow();
        if let Some(Value::Object(sbl)) = m.props.get("sourceBuffers") {
            if let ObjKind::Array(ref mut vec) = sbl.borrow_mut().kind {
                if let Some(pos) = vec.iter().position(|v| match (v, &target) {
                    (Value::Object(o1), Value::Object(o2)) => Rc::ptr_eq(o1, o2),
                    _ => false,
                }) {
                    vec.remove(pos);
                }
            }
        }
    }
    Ok(Value::Undefined)
}

/// `ms.endOfStream(error)`
pub(crate) fn media_source_end_of_stream(_it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(ms_obj) = &this {
        ms_obj.borrow_mut().props.insert("readyState".into(), Value::str("ended"));
    }
    let id = ms_id_of(&this);
    for e in MEDIA_SOURCE_URLS.lock().iter_mut().filter(|e| e.1 == id) {
        e.2 = true;
    }
    Ok(Value::Undefined)
}

/// `ms.setLiveSeekableRange(start, end)`
pub(crate) fn media_source_set_live_seekable_range(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let start = arg(a, 0).to_number();
    let end = arg(a, 1).to_number();
    if !start.is_finite() || !end.is_finite() || start < 0.0 || start > end {
        return Err(it.type_error("Invalid live seekable range"));
    }
    if let Value::Object(ms_obj) = &this {
        let mut m = ms_obj.borrow_mut();
        let rs = m.props.get("readyState").map(|v| v.to_js_string()).unwrap_or_default();
        if rs != "open" {
            return Err(it.type_error("MediaSource is not open"));
        }
        m.props.insert("_live_seekable_start".into(), Value::Number(start));
        m.props.insert("_live_seekable_end".into(), Value::Number(end));
        return Ok(Value::Undefined);
    }
    Err(it.type_error("setLiveSeekableRange called on non-MediaSource"))
}

/// `ms.clearLiveSeekableRange()`
pub(crate) fn media_source_clear_live_seekable_range(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(ms_obj) = &this {
        let mut m = ms_obj.borrow_mut();
        let rs = m.props.get("readyState").map(|v| v.to_js_string()).unwrap_or_default();
        if rs != "open" {
            return Err(it.type_error("MediaSource is not open"));
        }
        m.props.shift_remove("_live_seekable_start");
        m.props.shift_remove("_live_seekable_end");
        return Ok(Value::Undefined);
    }
    Err(it.type_error("clearLiveSeekableRange called on non-MediaSource"))
}

/// `SourceBuffer` JS オブジェクトを構築
fn make_source_buffer_object(mime_type: &str, owner: usize) -> Value {
    let id = NEXT_SB_ID.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
    let mut core = SourceBufferCore::new(id, mime_type);
    core.owner = owner;
    SOURCE_BUFFERS.lock().push(core);
    let sb = Obj::plain();
    {
        let mut s = sb.borrow_mut();
        s.props.insert("_sb_id".into(), Value::Number(id as f64));
        s.props.insert("mode".into(), Value::str("segments"));
        s.props.insert("timestampOffset".into(), Value::Number(0.0));
        s.props.insert("appendWindowStart".into(), Value::Number(0.0));
        s.props.insert("appendWindowEnd".into(), Value::Number(f64::INFINITY));
        s.props.insert("mimeType".into(), Value::str(mime_type));
        s.props.insert("updating".into(), Value::Bool(false));
        s.props.insert("buffered".into(), make_time_ranges_object(&TimeRanges::new()));
        s.props.insert("appendBuffer".into(), nv("SourceBuffer.appendBuffer", source_buffer_append_buffer));
        s.props.insert("changeType".into(), nv("SourceBuffer.changeType", source_buffer_change_type));
        s.props.insert("abort".into(), nv("SourceBuffer.abort", source_buffer_abort));
        s.props.insert("remove".into(), nv("SourceBuffer.remove", source_buffer_remove));
        s.props.insert("_listeners".into(), Value::Object(Obj::plain()));
        s.props.insert("addEventListener".into(), nv("addEventListener", event_target_add_event_listener));
        s.props.insert("removeEventListener".into(), nv("removeEventListener", event_target_remove_event_listener));
        s.props.insert("dispatchEvent".into(), nv("dispatchEvent", event_target_dispatch_event));
        s.props.insert("onupdatestart".into(), Value::Null);
        s.props.insert("onupdate".into(), Value::Null);
        s.props.insert("onupdateend".into(), Value::Null);
        s.props.insert("onerror".into(), Value::Null);
        s.props.insert("onabort".into(), Value::Null);
        s.props.insert("_data".into(), Value::Object(Obj::array(alloc::vec![])));
    }
    Value::Object(sb)
}

/// `sb.appendBuffer(data)`
pub(crate) fn source_buffer_append_buffer(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let data_val = arg(a, 0);
    if let Value::Object(sb_obj) = &this {
        let (updating, id, mode_str, ts_offset, win_start, win_end) = {
            let s = sb_obj.borrow();
            let u = s.props.get("updating").map(|v| v.truthy()).unwrap_or(false);
            let id = s.props.get("_sb_id").map_or(0, |v| v.to_number() as usize);
            let mode = s.props.get("mode").map(|v| v.to_js_string()).unwrap_or_else(|| "segments".into());
            let tso = s.props.get("timestampOffset").map_or(0.0, |v| v.to_number());
            let ws = s.props.get("appendWindowStart").map_or(0.0, |v| v.to_number());
            let we = s.props.get("appendWindowEnd").map_or(f64::INFINITY, |v| v.to_number());
            (u, id, mode, tso, ws, we)
        };
        if updating {
            return Err(it.type_error("Cannot appendBuffer while SourceBuffer is updating"));
        }

        // バイト列の取り出し（ArrayBuffer / TypedArray / DataView / 文字列）。
        let mut raw: Vec<f64> = Vec::new();
        super::typed_array::blob_part_bytes(&data_val, &mut raw);
        let bytes: Vec<u8> = raw.iter().map(|&v| v as i64 as u8).collect();
        dispatch_mse_event(it, &this, "updatestart");
        let result = {
            let mut list = SOURCE_BUFFERS.lock();
            match list.iter_mut().find(|b| b.id == id) {
                Some(core) => {
                    let _ = core.set_mode(&mode_str);
                    let _ = core.set_timestamp_offset(ts_offset);
                    if win_end > core.append_window_start {
                        let _ = core.set_append_window_end(win_end);
                        let _ = core.set_append_window_start(win_start);
                    } else {
                        let _ = core.set_append_window_start(win_start);
                        let _ = core.set_append_window_end(win_end);
                    }
                    core.append_buffer(&bytes)
                        .map(|_| (core.buffered.clone(), core.timestamp_offset))
                }
                None => Err(crate::os_lib::mse::MseError::BufferNotFound),
            }
        };
        // 取り込みはここで済ませ、`updating` を立てたまま戻る。`update`/`updateend`（失敗なら
        // `error`/`updateend`）は次のタスクで発火する（仕様どおり非同期）。【2026-10-18】従来は
        // その場で発火しており、`updateend` のリスナが次の `appendBuffer` を呼ぶ YouTube の
        // player で再帰になりスタックが尽きた。
        let ok = match result {
            Ok((tr, new_ts_offset)) => {
                let tr_obj = make_time_ranges_object(&tr);
                let mut s = sb_obj.borrow_mut();
                s.props.insert("buffered".into(), tr_obj);
                s.props.insert("timestampOffset".into(), Value::Number(new_ts_offset));
                true
            }
            Err(e) => {
                crate::warn!("[MSE] appendBuffer failed ({} bytes): {:?}", bytes.len(), e);
                false
            }
        };
        sb_obj.borrow_mut().props.insert("updating".into(), Value::Bool(true));
        schedule_sb_completion(it, &this, ok);
        return Ok(Value::Undefined);
    }
    Err(it.type_error("appendBuffer called on non-SourceBuffer"))
}

/// SourceBuffer の更新の完了（`updating=false` と `update`/`updateend`）を次のタスクで行う。
fn schedule_sb_completion(it: &mut Interp, sb: &Value, ok: bool) {
    let cb = nv("SourceBuffer update completion", sb_completion_task);
    let _ = super::timers_gen::set_timeout(it, Value::Undefined, &[cb, Value::Number(0.0), sb.clone(), Value::Bool(ok)]);
}

fn sb_completion_task(it: &mut Interp, _this: Value, a: &[Value]) -> Result<Value, Value> {
    let sb = arg(a, 0);
    let ok = arg(a, 1).truthy();
    if let Value::Object(o) = &sb {
        o.borrow_mut().props.insert("updating".into(), Value::Bool(false));
    }
    if ok {
        dispatch_mse_event(it, &sb, "update");
    } else {
        dispatch_mse_event(it, &sb, "error");
    }
    dispatch_mse_event(it, &sb, "updateend");
    fire_media_ready_events(it);
    Ok(Value::Undefined)
}

/// MSE を src に持つ `<video>`/`<audio>` の readyState が上がったらメディアイベントを発火する
/// （HAVE_METADATA で `loadedmetadata`・`durationchange`、HAVE_ENOUGH_DATA で `loadeddata`・
/// `canplay`・`canplaythrough`）。【2026-10-18】従来は発火せず、これらを待ってから `play()` する
/// YouTube の player が再生を始めなかった。
fn fire_media_ready_events(it: &mut Interp) {
    let targets: Vec<(usize, String, u8)> = {
        let dom = it.dom.borrow();
        dom.nodes
            .iter()
            .enumerate()
            .filter(|(_, n)| n.tag == "video" || n.tag == "audio")
            .filter_map(|(i, n)| {
                let src = n.attrs.get("src")?;
                if !src.starts_with("blob:mediasource") {
                    return None;
                }
                let prev = n.attrs.get("_rs_fired").and_then(|v| v.parse::<u8>().ok()).unwrap_or(0);
                Some((i, src.clone(), prev))
            })
            .collect()
    };
    for (idx, src, prev) in targets {
        let rs = media_source_ready_state(&src).unwrap_or(0);
        if rs >= 1 && prev < 1 {
            it.dom.borrow_mut().set_attr(idx, "_rs_fired", "1");
            let _ = it.dispatch_event_in_interp(idx, "loadedmetadata", &[]);
            let _ = it.dispatch_event_in_interp(idx, "durationchange", &[]);
        }
        if rs >= 4 && prev < 4 {
            it.dom.borrow_mut().set_attr(idx, "_rs_fired", "4");
            let _ = it.dispatch_event_in_interp(idx, "loadeddata", &[]);
            let _ = it.dispatch_event_in_interp(idx, "canplay", &[]);
            let _ = it.dispatch_event_in_interp(idx, "canplaythrough", &[]);
        }
    }
}

/// `sb.changeType(type)`
pub(crate) fn source_buffer_change_type(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let mime = arg(a, 0).to_js_string();
    if mime.trim().is_empty() {
        return Err(it.type_error("changeType requires a non-empty MIME type"));
    }
    if let Value::Object(sb_obj) = &this {
        let (updating, id) = {
            let s = sb_obj.borrow();
            let u = s.props.get("updating").map(|v| v.truthy()).unwrap_or(false);
            let id = s.props.get("_sb_id").map_or(0, |v| v.to_number() as usize);
            (u, id)
        };
        if updating {
            return Err(it.type_error("Cannot changeType while SourceBuffer is updating"));
        }
        let res = {
            let mut list = SOURCE_BUFFERS.lock();
            match list.iter_mut().find(|b| b.id == id) {
                Some(core) => core.change_type(&mime),
                None => {
                    if MediaSourceCore::is_type_supported(&mime) {
                        Ok(())
                    } else {
                        Err(crate::os_lib::mse::MseError::UnsupportedType)
                    }
                }
            }
        };
        match res {
            Ok(()) => {
                sb_obj.borrow_mut().props.insert("mimeType".into(), Value::str(&mime));
                return Ok(Value::Undefined);
            }
            Err(_) => {
                return Err(it.type_error(alloc::format!("Unsupported MIME type for changeType: {}", mime)));
            }
        }
    }
    Err(it.type_error("changeType called on non-SourceBuffer"))
}

pub(crate) fn source_buffer_abort(it: &mut Interp, this: Value, _a: &[Value]) -> Result<Value, Value> {
    if let Value::Object(sb_obj) = &this {
        let (was_updating, id) = {
            let mut s = sb_obj.borrow_mut();
            let u = s.props.get("updating").map(|v| v.truthy()).unwrap_or(false);
            let id = s.props.get("_sb_id").map_or(0, |v| v.to_number() as usize);
            s.props.insert("updating".into(), Value::Bool(false));
            (u, id)
        };
        if let Some(core) = SOURCE_BUFFERS.lock().iter_mut().find(|b| b.id == id) {
            core.abort();
        }
        if was_updating {
            dispatch_mse_event(it, &this, "abort");
            dispatch_mse_event(it, &this, "updateend");
        }
    }
    Ok(Value::Undefined)
}

/// `sb.remove(start, end)`。区間内のサンプルを捨てて buffered を作り直す。
pub(crate) fn source_buffer_remove(it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let (start, end) = (arg(a, 0).to_number(), arg(a, 1).to_number());
    if let Value::Object(sb_obj) = &this {
        let id = sb_obj.borrow().props.get("_sb_id").map_or(0, |v| v.to_number() as usize);
        let tr = {
            let mut list = SOURCE_BUFFERS.lock();
            list.iter_mut().find(|b| b.id == id).map(|core| {
                core.remove_range(start, end);
                core.buffered.clone()
            })
        };
        sb_obj
            .borrow_mut()
            .props
            .insert("buffered".into(), make_time_ranges_object(&tr.unwrap_or_default()));
        // 完了イベントは appendBuffer と同じく次のタスクで。
        sb_obj.borrow_mut().props.insert("updating".into(), Value::Bool(true));
        schedule_sb_completion(it, &this, true);
    }
    Ok(Value::Undefined)
}

/// `TimeRanges` JS オブジェクトを構築
fn make_time_ranges_object(tr: &TimeRanges) -> Value {
    let obj = Obj::plain();
    let starts = Obj::array(tr.ranges.iter().map(|r| Value::Number(r.start)).collect());
    let ends = Obj::array(tr.ranges.iter().map(|r| Value::Number(r.end)).collect());
    {
        let mut o = obj.borrow_mut();
        o.props.insert("length".into(), Value::Number(tr.len() as f64));
        o.props.insert("_starts".into(), Value::Object(starts));
        o.props.insert("_ends".into(), Value::Object(ends));
        o.props.insert("start".into(), nv("TimeRanges.start", time_ranges_start));
        o.props.insert("end".into(), nv("TimeRanges.end", time_ranges_end));
    }
    Value::Object(obj)
}

pub(crate) fn time_ranges_start(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let idx = arg(a, 0).to_number() as usize;
    if let Value::Object(o) = &this {
        if let Some(Value::Object(arr)) = o.borrow().props.get("_starts") {
            if let ObjKind::Array(ref vec) = arr.borrow().kind {
                if let Some(v) = vec.get(idx) {
                    return Ok(v.clone());
                }
            }
        }
    }
    Ok(Value::Undefined)
}

pub(crate) fn time_ranges_end(_it: &mut Interp, this: Value, a: &[Value]) -> Result<Value, Value> {
    let idx = arg(a, 0).to_number() as usize;
    if let Value::Object(o) = &this {
        if let Some(Value::Object(arr)) = o.borrow().props.get("_ends") {
            if let ObjKind::Array(ref vec) = arr.borrow().kind {
                if let Some(v) = vec.get(idx) {
                    return Ok(v.clone());
                }
            }
        }
    }
    Ok(Value::Undefined)
}