Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / html / html_input_element_3.lucb

#==============================================================================================
#
#   html_input_element_3 - HTML::HTMLInputElement: the user-agent shadow trees
#
#   DESCRIPTION:
#       Port of LibWeb/HTML/HTMLInputElement.cpp (lines 1052-1493): creating the shadow tree
#       of the element's type (button label, text field with inner text, placeholder and
#       stepper buttons, color well, file button and label, range slider track, fill and
#       thumb) and updating it, the native event listeners of the stepper buttons, the file
#       button and the slider (JS::NativeFunctions whose captures are the element, or a struct
#       allocated with `new`), and the input events of user interaction.
#
#==============================================================================================

# mark: Helpers =================================================================================

## `Utf16String::formatted(fmtstr, arguments...)` with AK's format specifications.
func html_utf16_formatted(fmtstr: str, arguments: const ak.TypeErasedParameter[]) -> ak.Utf16String:
    var builder = ak.string_builder_new_mode(ak.StringBuilderMode.utf16)
    ak.vformat_arguments(&builder, ak.sv(fmtstr), arguments) else trap("MUST: Utf16String::formatted")
    return ak.string_builder_to_utf16_string(&builder)

## `MUST(String::formatted(fmtstr, arguments...))` with AK's format specifications.
func html_string_formatted(fmtstr: str, arguments: const ak.TypeErasedParameter[]) -> ak.String:
    var builder = ak.string_builder_new()
    ak.vformat_arguments(&builder, ak.sv(fmtstr), arguments) else trap("MUST: String::formatted")
    return ak.string_from_string_builder(&builder) else trap("MUST: String::formatted")

## `MUST(DOM::create_element(document, local_name, namespace_))`.
func html_input_element_create_element(this: HtmlInputElement*, local_name: ak.FlyString, namespace_: ak.FlyString) -> DomElement*:
    return dom_create_element(html_input_element_document(this), local_name, namespace_) else trap("MUST: DOM::create_element")

## `MUST(parent->append_child(child))`.
func html_append_child(parent: DomNode*, child: DomNode*):
    _ = dom_node_append_child(parent, child) else trap("MUST: append_child")

## `realm().heap().allocate<WebIDL::CallbackType>(*JS::NativeFunction::create(realm(), behaviour, 0, {}, &realm()), realm())`.
func html_input_element_native_callback(this: HtmlInputElement*, call: func(void*?, Vm*) -> JsValue!, context: void*) -> IdlCallbackType*:
    let realm = html_input_element_realm(this)
    let function = js_native_function_create(realm, JsNativeFunctionBehaviour(call = call, context = context), 0, ak.utf16_fly_string_new(), realm)
    return realm_create_idl_callback_type_realm(realm, (JsObject*)function, realm, IdlOperationReturnsPromise.no)

# mark: Creating and updating the shadow tree ===================================================

## Ported from HTMLInputElement.cpp:1052 Web::HTML::HTMLInputElement::create_shadow_tree_if_needed.
func html_input_element_create_shadow_tree_if_needed(this: HtmlInputElement*):
    if dom_element_shadow_root(this.dom_element()) != none:
        return

    match html_input_element_type_state(this):
        .hidden, .radio_button, .checkbox:
            _ = this
        .button, .submit_button, .reset_button:
            html_input_element_create_button_input_shadow_tree(this)
        .image_button:
            _ = this
        .color:
            html_input_element_create_color_input_shadow_tree(this)
        .file_upload:
            html_input_element_create_file_input_shadow_tree(this)
        .range:
            html_input_element_create_range_input_shadow_tree(this)
        # FIXME: This could be better factored. Everything except the above types becomes a text input.
        _:
            html_input_element_create_text_input_shadow_tree(this)

## Ported from HTMLInputElement.cpp:1085 Web::HTML::HTMLInputElement::update_shadow_tree.
func html_input_element_update_shadow_tree(this: HtmlInputElement*):
    match html_input_element_type_state(this):
        .color:
            html_input_element_update_color_well_element(this)
        .file_upload:
            html_input_element_update_file_input_shadow_tree(this)
        .range:
            html_input_element_update_slider_shadow_tree_elements(this)
        .button, .reset_button, .submit_button:
            html_input_element_update_button_input_shadow_tree(this)
        _:
            html_input_element_update_text_input_shadow_tree(this)

## Ported from HTMLInputElement.cpp:1108 Web::HTML::HTMLInputElement::create_button_input_shadow_tree.
func html_input_element_create_button_input_shadow_tree(this: HtmlInputElement*):
    let realm = html_input_element_realm(this)
    let document = html_input_element_document(this)
    let shadow_root = realm_create_dom_shadow_root(realm, document, this.dom_element(), BindShadowRootMode.closed)
    dom_shadow_root_set_user_agent_internal(shadow_root, true)
    dom_element_set_shadow_root(this.dom_element(), shadow_root)
    let text_container = html_input_element_create_element(this, html_tag_names_span, namespace_html)
    dom_element_set_attribute_value(text_container, html_attribute_names_style, ak.string_from_str("display: inline-block; pointer-events: none;"))

    let text_node = realm_create_dom_text_utf16_string(realm, document, html_input_element_button_label(this))
    this.m_text_node = text_node
    html_append_child(text_container.dom_node(), text_node.dom_node())
    html_append_child(shadow_root.dom_node(), text_container.dom_node())

## `static GC::Root<CSS::CSSStyleProperties> style` of the outer element in create_text_input_shadow_tree().
var html_input_element_create_text_input_shadow_tree_s_element_style: gc.Root[CssStyleProperties]

## `static GC::Root<CSS::CSSStyleProperties> style` of the inner text element in create_text_input_shadow_tree().
var html_input_element_create_text_input_shadow_tree_s_inner_text_style: gc.Root[CssStyleProperties]

## The static inline styles of the input elements' shadow trees forgotten as their VM is
## destroyed (vm_destroy): they are cells of the internal CSS realm, and C++'s statics live as long
## as the process's one VM.
func html_input_element_forget_static_styles():
    gc.root_release(&html_inner_text_style_when_visible_s_style)
    gc.root_release(&html_inner_text_style_when_hidden_s_style)
    gc.root_release(&html_stepper_button_style_when_visible_s_style)
    gc.root_release(&html_stepper_button_style_when_hidden_s_style)
    gc.root_release(&html_placeholder_style_when_visible_s_style)
    gc.root_release(&html_placeholder_style_when_hidden_s_style)
    gc.root_release(&html_input_element_create_text_input_shadow_tree_s_element_style)
    gc.root_release(&html_input_element_create_text_input_shadow_tree_s_inner_text_style)

## The mouseup listener of the stepper buttons: `[this](JS::VM&) { commit_pending_changes(); ... }`.
func html_input_element_stepper_mouseup(context: void*?, vm: Vm*) -> JsValue!:
    _ = vm
    let this = (HtmlInputElement*)(context else trap("no input element"))
    html_input_element_commit_pending_changes(this)
    return js_undefined()

## The mousedown listener of the up button.
func html_input_element_stepper_up(context: void*?, vm: Vm*) -> JsValue!:
    _ = vm
    let this = (HtmlInputElement*)(context else trap("no input element"))
    if html_input_element_type_state(this) == HtmlInputElementTypeAttributeState.number and html_input_element_is_mutable_impl(html_input_element_form_associated(this)) and html_input_element_allowed_value_step(this) != none:
        html_input_element_step_up(this) else trap("MUST: step_up")
        html_input_element_user_interaction_did_change_input_value(this)
    return js_undefined()

## The mousedown listener of the down button.
func html_input_element_stepper_down(context: void*?, vm: Vm*) -> JsValue!:
    _ = vm
    let this = (HtmlInputElement*)(context else trap("no input element"))
    if html_input_element_type_state(this) == HtmlInputElementTypeAttributeState.number and html_input_element_is_mutable_impl(html_input_element_form_associated(this)) and html_input_element_allowed_value_step(this) != none:
        html_input_element_step_down(this) else trap("MUST: step_down")
        html_input_element_user_interaction_did_change_input_value(this)
    return js_undefined()

## Ported from HTMLInputElement.cpp:1121 Web::HTML::HTMLInputElement::create_text_input_shadow_tree.
func html_input_element_create_text_input_shadow_tree(this: HtmlInputElement*):
    let realm = html_input_element_realm(this)
    let document = html_input_element_document(this)
    let shadow_root = realm_create_dom_shadow_root(realm, document, this.dom_element(), BindShadowRootMode.closed)
    dom_shadow_root_set_user_agent_internal(shadow_root, true)
    dom_element_set_shadow_root(this.dom_element(), shadow_root)

    let element = html_input_element_create_element(this, html_tag_names_div, namespace_html)
    dom_element_set_inline_style(element, html_input_element_static_style(&html_input_element_create_text_input_shadow_tree_s_element_style, "\n                display: flex;\n                height: 100%;\n                align-items: center;\n                white-space: pre;\n                border: none;\n                padding: 1px 2px;\n            "))
    html_append_child(shadow_root.dom_node(), element.dom_node())

    # https://www.w3.org/TR/css-ui-4/#input-rules
    let inner_text_element = html_input_element_create_element(this, html_tag_names_div, namespace_html)
    this.m_inner_text_element = inner_text_element
    dom_element_set_inline_style(inner_text_element, html_input_element_static_style(&html_input_element_create_text_input_shadow_tree_s_inner_text_style, "\n                width: 100%;\n                height: 1lh;\n                align-items: center;\n                overflow: auto;\n                scrollbar-width: none;\n                text-overflow: clip;\n                white-space: nowrap;\n            "))
    html_append_child(element.dom_node(), inner_text_element.dom_node())

    let text_node = realm_create_dom_text_utf16_string(realm, document, this.m_value)
    this.m_text_node = text_node
    if html_input_element_type_state(this) == HtmlInputElementTypeAttributeState.password:
        dom_text_set_is_password_input(text_node, true)
    html_input_element_handle_maxlength_attribute(this)
    html_append_child(inner_text_element.dom_node(), text_node.dom_node())

    let placeholder_element = html_input_element_create_element(this, html_tag_names_div, namespace_html)
    this.m_placeholder_element = placeholder_element
    dom_element_set_use_pseudo_element(placeholder_element, css_data.PseudoElement.placeholder)
    html_append_child(element.dom_node(), placeholder_element.dom_node())

    let placeholder = html_input_element_placeholder(this)
    let placeholder_text_node = realm_create_dom_text_utf16_string(realm, document, ak.utf16_string_from_utf8_string(&placeholder))
    this.m_placeholder_text_node = placeholder_text_node
    html_append_child(placeholder_element.dom_node(), placeholder_text_node.dom_node())

    if html_input_element_type_state(this) == HtmlInputElementTypeAttributeState.number:
        # Up button
        let up_button_element = html_input_element_create_element(this, html_tag_names_button, namespace_html)
        this.m_up_button_element = up_button_element

        let up_button_svg = html_input_element_create_element(this, svg_tag_names_svg, namespace_svg)
        dom_element_set_attribute_value(up_button_svg, html_attribute_names_style, ak.string_from_str("width: 1em; height: 1em;"))
        dom_element_set_attribute_value(up_button_svg, svg_attribute_names_xmlns, ak.fly_string_to_string_const(&namespace_svg))
        dom_element_set_attribute_value(up_button_svg, svg_attribute_names_view_box, ak.string_from_str("0 0 24 24"))
        html_append_child(up_button_element.dom_node(), up_button_svg.dom_node())

        let up_button_svg_path = html_input_element_create_element(this, svg_tag_names_path, namespace_svg)
        dom_element_set_attribute_value(up_button_svg_path, svg_attribute_names_fill, ak.string_from_str("currentColor"))
        dom_element_set_attribute_value(up_button_svg_path, svg_attribute_names_d, ak.string_from_str("M7.41,15.41L12,10.83L16.59,15.41L18,14L12,8L6,14L7.41,15.41Z"))
        html_append_child(up_button_svg.dom_node(), up_button_svg_path.dom_node())

        html_append_child(element.dom_node(), up_button_element.dom_node())

        let mouseup_callback = html_input_element_native_callback(this, html_input_element_stepper_mouseup, this)
        var mouseup_listener_options = DomAddEventListenerOptions(event_listener_options = DomEventListenerOptions(), passive = none, once = false, signal = none)
        mouseup_listener_options.once = true
        # (The options are not passed on: the listeners below are added without options, as in the C++.)
        _ = mouseup_listener_options

        let step_up_callback = html_input_element_native_callback(this, html_input_element_stepper_up, this)
        dom_event_target_add_event_listener_without_options(up_button_element.dom_event_target(), ui_events_event_names_mousedown, dom_idl_event_listener_create(realm, step_up_callback))
        dom_event_target_add_event_listener_without_options(up_button_element.dom_event_target(), ui_events_event_names_mouseup, dom_idl_event_listener_create(realm, mouseup_callback))

        # Down button
        let down_button_element = html_input_element_create_element(this, html_tag_names_button, namespace_html)
        this.m_down_button_element = down_button_element

        let down_button_svg = html_input_element_create_element(this, svg_tag_names_svg, namespace_svg)
        dom_element_set_attribute_value(down_button_svg, html_attribute_names_style, ak.string_from_str("width: 1em; height: 1em;"))
        dom_element_set_attribute_value(down_button_svg, svg_attribute_names_xmlns, ak.fly_string_to_string_const(&namespace_svg))
        dom_element_set_attribute_value(down_button_svg, svg_attribute_names_view_box, ak.string_from_str("0 0 24 24"))
        html_append_child(down_button_element.dom_node(), down_button_svg.dom_node())

        let down_button_svg_path = html_input_element_create_element(this, svg_tag_names_path, namespace_svg)
        dom_element_set_attribute_value(down_button_svg_path, svg_attribute_names_fill, ak.string_from_str("currentColor"))
        dom_element_set_attribute_value(down_button_svg_path, svg_attribute_names_d, ak.string_from_str("M7.41,8.58L12,13.17L16.59,8.58L18,10L12,16L6,10L7.41,8.58Z"))
        html_append_child(down_button_svg.dom_node(), down_button_svg_path.dom_node())

        html_append_child(element.dom_node(), down_button_element.dom_node())

        let step_down_callback = html_input_element_native_callback(this, html_input_element_stepper_down, this)
        dom_event_target_add_event_listener_without_options(down_button_element.dom_event_target(), ui_events_event_names_mousedown, dom_idl_event_listener_create(realm, step_down_callback))
        dom_event_target_add_event_listener_without_options(down_button_element.dom_event_target(), ui_events_event_names_mouseup, dom_idl_event_listener_create(realm, mouseup_callback))

    html_input_element_update_text_input_shadow_tree(this)

## Ported from HTMLInputElement.cpp:1251 Web::HTML::HTMLInputElement::create_color_input_shadow_tree.
func html_input_element_create_color_input_shadow_tree(this: HtmlInputElement*):
    let shadow_root = realm_create_dom_shadow_root(html_input_element_realm(this), html_input_element_document(this), this.dom_element(), BindShadowRootMode.closed)
    dom_shadow_root_set_user_agent_internal(shadow_root, true)

    let color = html_input_element_value_sanitization_algorithm(this, this.m_value)

    let border = dom_create_element(html_input_element_document(this), html_tag_names_div, namespace_html) else trap("FIXME: should propagate errors")
    dom_element_set_attribute_value(border, html_attribute_names_style, ak.string_from_str("\n        width: fit-content;\n        height: fit-content;\n        padding: 4px;\n        border: 1px solid ButtonBorder;\n        background-color: ButtonFace;\n"))

    let color_well_element = dom_create_element(html_input_element_document(this), html_tag_names_div, namespace_html) else trap("FIXME: should propagate errors")
    this.m_color_well_element = color_well_element
    dom_element_set_attribute_value(color_well_element, html_attribute_names_style, ak.string_from_str("\n        width: 32px;\n        height: 16px;\n        border: 1px solid ButtonBorder;\n        box-sizing: border-box;\n"))
    let color_text = ak.utf16_string_base_to_utf8_but_should_be_ported_to_utf16(&color.utf16_string_base)
    css_style_properties_set_property_property_id(dom_element_style_for_bindings(color_well_element), css_data.PropertyId.background_color, ak.string_bytes_as_string_view(&color_text), ak.sv("")) else trap("MUST: set_property")

    html_append_child(border.dom_node(), color_well_element.dom_node())
    html_append_child(shadow_root.dom_node(), border.dom_node())
    dom_element_set_shadow_root(this.dom_element(), shadow_root)

## Ported from HTMLInputElement.cpp:1281 Web::HTML::HTMLInputElement::update_color_well_element.
func html_input_element_update_color_well_element(this: HtmlInputElement*):
    let color_well_element = this.m_color_well_element else return

    let value_text = ak.utf16_string_base_to_utf8_but_should_be_ported_to_utf16(&this.m_value.utf16_string_base)
    css_style_properties_set_property_property_id(dom_element_style_for_bindings(color_well_element), css_data.PropertyId.background_color, ak.string_bytes_as_string_view(&value_text), ak.sv("")) else trap("MUST: set_property")

## The click listener of the file button: `[this](JS::VM&) { show_the_picker_if_applicable(*this); ... }`.
func html_input_element_file_button_click(context: void*?, vm: Vm*) -> JsValue!:
    _ = vm
    let this = (HtmlInputElement*)(context else trap("no input element"))
    html_show_the_picker_if_applicable(this)
    return js_undefined()

## Ported from HTMLInputElement.cpp:1289 Web::HTML::HTMLInputElement::create_file_input_shadow_tree.
func html_input_element_create_file_input_shadow_tree(this: HtmlInputElement*):
    let realm = html_input_element_realm(this)
    let document = html_input_element_document(this)

    let shadow_root = realm_create_dom_shadow_root(realm, document, this.dom_element(), BindShadowRootMode.closed)
    dom_shadow_root_set_user_agent_internal(shadow_root, true)

    let file_button = dom_create_element(document, html_tag_names_button, namespace_html) else trap("FIXME: should propagate errors")
    this.m_file_button = file_button
    dom_element_set_use_pseudo_element(file_button, css_data.PseudoElement.file_selector_button)

    let file_label = dom_create_element(document, html_tag_names_label, namespace_html) else trap("FIXME: should propagate errors")
    this.m_file_label = file_label
    dom_element_set_attribute_value(file_label, html_attribute_names_style, ak.string_from_str("padding-left: 4px;"))

    let on_button_click_callback = html_input_element_native_callback(this, html_input_element_file_button_click, this)
    dom_event_target_add_event_listener_without_options(file_button.dom_event_target(), ui_events_event_names_click, dom_idl_event_listener_create(realm, on_button_click_callback))

    html_input_element_update_file_input_shadow_tree(this)

    html_append_child(shadow_root.dom_node(), file_button.dom_node())
    html_append_child(shadow_root.dom_node(), file_label.dom_node())

    dom_element_set_shadow_root(this.dom_element(), shadow_root)

## Ported from HTMLInputElement.cpp:1319 Web::HTML::HTMLInputElement::update_file_input_shadow_tree.
func html_input_element_update_file_input_shadow_tree(this: HtmlInputElement*):
    let file_button = this.m_file_button else return
    let file_label = this.m_file_label else return

    let files_label = "files" if html_input_element_has_attribute(this, html_attribute_names_multiple) else "file"
    dom_node_string_replace_all(file_button.dom_node(), html_utf16_formatted("Select {}...", [ak.arg_str(files_label)]))

    let selected_files = this.m_selected_files
    if selected_files != none and file_api_file_list_length(selected_files else trap("unreachable")) > 0:
        let files = selected_files else trap("unreachable")
        if file_api_file_list_length(files) == 1:
            let name = file_api_file_name(file_api_file_list_item(files, 0) else trap("VERIFY: FileList::item"))
            dom_node_string_replace_all(file_label.dom_node(), ak.utf16_string_from_utf8_string(&name))
        else:
            dom_node_string_replace_all(file_label.dom_node(), html_utf16_formatted("{} files selected.", [ak.arg_u64(file_api_file_list_length(files))]))
    else:
        dom_node_string_replace_all(file_label.dom_node(), html_utf16_formatted("No {} selected.", [ak.arg_str(files_label)]))

## The keydown listener of the slider.
func html_input_element_slider_keydown(context: void*?, vm: Vm*) -> JsValue!:
    let this = (HtmlInputElement*)(context else trap("no input element"))
    if html_input_element_type_state(this) != HtmlInputElementTypeAttributeState.range:
        return js_undefined()
    if html_input_element_allowed_value_step(this) == none:
        return js_undefined()
    let key_value = js_value_get(vm_argument(vm, 0), vm, ak.utf16_fly_string_from_utf8_string_view(ak.sv("key"))) else trap("MUST: get")
    if not js_value_is_string(key_value):
        return js_undefined()
    let key = js_value_as_string_utf8_string(key_value)

    if ak.string_eq_string_view(&key, ak.sv("ArrowLeft")) or ak.string_eq_string_view(&key, ak.sv("ArrowDown")):
        html_input_element_step_down(this) else trap("MUST: step_down")
    if ak.string_eq_string_view(&key, ak.sv("PageDown")):
        html_input_element_step_down(this, 10) else trap("MUST: step_down")

    if ak.string_eq_string_view(&key, ak.sv("ArrowRight")) or ak.string_eq_string_view(&key, ak.sv("ArrowUp")):
        html_input_element_step_up(this) else trap("MUST: step_up")
    if ak.string_eq_string_view(&key, ak.sv("PageUp")):
        html_input_element_step_up(this, 10) else trap("MUST: step_up")

    html_input_element_user_interaction_did_change_input_value(this)
    return js_undefined()

## The wheel listener of the slider.
func html_input_element_slider_wheel(context: void*?, vm: Vm*) -> JsValue!:
    let this = (HtmlInputElement*)(context else trap("no input element"))
    if html_input_element_type_state(this) != HtmlInputElementTypeAttributeState.range:
        return js_undefined()
    if html_input_element_allowed_value_step(this) == none:
        return js_undefined()
    let delta_y_value = js_value_get(vm_argument(vm, 0), vm, ak.utf16_fly_string_from_utf8_string_view(ak.sv("deltaY"))) else trap("MUST: get")
    if not js_value_is_finite_number(delta_y_value):
        return js_undefined()
    if js_value_as_double(delta_y_value) > 0.0:
        html_input_element_step_down(this) else trap("MUST: step_down")
    else:
        html_input_element_step_up(this) else trap("MUST: step_up")
    html_input_element_user_interaction_did_change_input_value(this)
    return js_undefined()

## `update_slider_by_mouse`: `[this](JS::VM& vm) { ... }`.
func html_input_element_update_slider_by_mouse(this: HtmlInputElement*, vm: Vm*):
    if html_input_element_type_state(this) != HtmlInputElementTypeAttributeState.range:
        return
    let client_x_value = js_value_get(vm_argument(vm, 0), vm, ak.utf16_fly_string_from_utf8_string_view(ak.sv("clientX"))) else trap("MUST: get")
    if not js_value_is_finite_number(client_x_value):
        return
    let client_x = js_value_as_double(client_x_value)
    let rect = dom_element_get_bounding_client_rect(this.dom_element())
    if gfx.css_pixel_rect_width(&rect).to_double() <= 0.0:
        return
    let minimum = html_input_element_min(this) else trap("VERIFY: Optional::operator*")
    let maximum = html_input_element_max(this) else trap("VERIFY: Optional::operator*")
    if minimum > maximum:
        return
    # FIXME: Snap new value to input steps
    html_input_element_set_value_as_number(this, ak.clamp_f64(math.round(((client_x - gfx.css_pixel_rect_left(&rect).to_double()) / gfx.css_pixel_rect_width(&rect).to_double()) * (maximum - minimum) + minimum), minimum, maximum)) else trap("MUST: set_value_as_number")
    html_input_element_user_interaction_did_change_input_value(this)

## The window's mousemove listener while the slider is dragged: `[update_slider_by_mouse](JS::VM& vm) { ... }`.
func html_input_element_slider_mousemove(context: void*?, vm: Vm*) -> JsValue!:
    let this = (HtmlInputElement*)(context else trap("no input element"))
    html_input_element_update_slider_by_mouse(this, vm)
    return js_undefined()

## The captures of the window's mouseup listener: `[this, mousemove_listener]`.
struct HtmlInputElementSliderMouseup:
    var this: HtmlInputElement*
    var mousemove_listener: DomIdlEventListener*

## The window's mouseup listener that ends a drag of the slider.
func html_input_element_slider_mouseup(context: void*?, vm: Vm*) -> JsValue!:
    _ = vm
    let captures = (HtmlInputElementSliderMouseup*)(context else trap("no captures"))
    let window = (HtmlWindow*)html_relevant_global_object((JsObject*)captures.this)
    dom_event_target_remove_event_listener_without_options(window.dom_event_target(), ui_events_event_names_mousemove, captures.mousemove_listener)
    return js_undefined()

## The mousedown listener of the slider.
func html_input_element_slider_mousedown(context: void*?, vm: Vm*) -> JsValue!:
    let this = (HtmlInputElement*)(context else trap("no input element"))
    let realm = html_input_element_realm(this)
    html_input_element_update_slider_by_mouse(this, vm)

    let mousemove_callback = html_input_element_native_callback(this, html_input_element_slider_mousemove, this)
    let mousemove_listener = dom_idl_event_listener_create(realm, mousemove_callback)
    let window = (HtmlWindow*)html_relevant_global_object((JsObject*)this)
    dom_event_target_add_event_listener_without_options(window.dom_event_target(), ui_events_event_names_mousemove, mousemove_listener)

    let captures = new HtmlInputElementSliderMouseup(this = this, mousemove_listener = mousemove_listener) else trap("out of memory")
    let mouseup_callback = html_input_element_native_callback(this, html_input_element_slider_mouseup, captures)
    var mouseup_listener_options = DomAddEventListenerOptions(event_listener_options = DomEventListenerOptions(), passive = none, once = false, signal = none)
    mouseup_listener_options.once = true
    dom_event_target_add_event_listener(window.dom_event_target(), ui_events_event_names_mouseup, dom_idl_event_listener_create(realm, mouseup_callback), .dom_add_event_listener_options(mouseup_listener_options))

    return js_undefined()

## Ported from HTMLInputElement.cpp:1337 Web::HTML::HTMLInputElement::create_range_input_shadow_tree.
func html_input_element_create_range_input_shadow_tree(this: HtmlInputElement*):
    let realm = html_input_element_realm(this)
    let shadow_root = realm_create_dom_shadow_root(realm, html_input_element_document(this), this.dom_element(), BindShadowRootMode.closed)
    dom_shadow_root_set_user_agent_internal(shadow_root, true)
    dom_element_set_shadow_root(this.dom_element(), shadow_root)

    let slider_runnable_track = html_input_element_create_element(this, html_tag_names_div, namespace_html)
    this.m_slider_runnable_track = slider_runnable_track
    dom_element_set_use_pseudo_element(slider_runnable_track, css_data.PseudoElement.slider_track)
    html_append_child(shadow_root.dom_node(), slider_runnable_track.dom_node())

    let slider_progress_element = html_input_element_create_element(this, html_tag_names_div, namespace_html)
    this.m_slider_progress_element = slider_progress_element
    dom_element_set_use_pseudo_element(slider_progress_element, css_data.PseudoElement.slider_fill)
    html_append_child(slider_runnable_track.dom_node(), slider_progress_element.dom_node())

    let slider_thumb = html_input_element_create_element(this, html_tag_names_div, namespace_html)
    this.m_slider_thumb = slider_thumb
    dom_element_set_use_pseudo_element(slider_thumb, css_data.PseudoElement.slider_thumb)
    html_append_child(slider_runnable_track.dom_node(), slider_thumb.dom_node())

    html_input_element_update_slider_shadow_tree_elements(this)

    let keydown_callback = html_input_element_native_callback(this, html_input_element_slider_keydown, this)
    dom_event_target_add_event_listener_without_options(this.dom_event_target(), ui_events_event_names_keydown, dom_idl_event_listener_create(realm, keydown_callback))

    let wheel_callback = html_input_element_native_callback(this, html_input_element_slider_wheel, this)
    dom_event_target_add_event_listener_without_options(this.dom_event_target(), ui_events_event_names_wheel, dom_idl_event_listener_create(realm, wheel_callback))

    let mousedown_callback = html_input_element_native_callback(this, html_input_element_slider_mousedown, this)
    dom_event_target_add_event_listener_without_options(this.dom_event_target(), ui_events_event_names_mousedown, dom_idl_event_listener_create(realm, mousedown_callback))

# mark: User interaction and the slider =========================================================

## The captures of user_interaction_did_change_input_value's element task: `[this, input_type, data]`.
struct HtmlInputElementUserInteractionTask:
    var this: HtmlInputElement*
    var input_type: ak.FlyString
    var data: ak.Utf16String?

## user_interaction_did_change_input_value's element task: fire an input event.
func html_input_element_user_interaction_task(context: void*?):
    let captures = (HtmlInputElementUserInteractionTask*)(context else trap("no captures"))
    let this = captures.this
    # https://w3c.github.io/uievents/#event-type-input
    var input_event_init: UiEventsInputEventInit = ---
    ui_events_input_event_init_init_fields(&input_event_init)
    input_event_init.ui_event_init.event_init.bubbles = true
    input_event_init.ui_event_init.event_init.composed = true
    input_event_init.input_type = captures.input_type
    input_event_init.data = captures.data
    let input_event = ui_events_input_event_create_from_platform_event(html_input_element_realm(this), html_event_names_input, input_event_init)
    # (InputEvent is opaque until phase 4; it is a DOM::Event first.)
    _ = html_input_element_dispatch_event(this, (DomEvent*)input_event)

## Ported from HTMLInputElement.cpp:1459 Web::HTML::HTMLInputElement::user_interaction_did_change_input_value.
func html_input_element_user_interaction_did_change_input_value(this: HtmlInputElement*, input_type: ak.FlyString = ak.FlyString(), data: ak.Utf16String? = none):
    # https://html.spec.whatwg.org/multipage/input.html#common-input-element-events
    # For input elements without a defined input activation behavior, but to which these events apply,
    # and for which the user interface involves both interactive manipulation and an explicit commit action,
    # then when the user changes the element's value, the user agent must queue an element task on the user interaction task source
    # given the input element to fire an event named input at the input element, with the bubbles and composed attributes initialized to true
    let captures = new HtmlInputElementUserInteractionTask(this = this, input_type = input_type, data = data) else trap("out of memory")
    _ = dom_element_queue_an_element_task(this.dom_element(), HtmlTaskSource.user_interaction, ak.Function0[unit](call = html_input_element_user_interaction_task, context = captures))
    # and any time the user commits the change, the user agent must queue an element task on the user interaction task source given the input
    # element to set its user validity to true and fire an event named change at the input element, with the bubbles attribute initialized to true.
    # NOTE: This is done manually as needed

## Ported from HTMLInputElement.cpp:1481 Web::HTML::HTMLInputElement::update_slider_shadow_tree_elements.
func html_input_element_update_slider_shadow_tree_elements(this: HtmlInputElement*):
    let value = html_input_element_convert_string_to_number_utf16_string(this, html_input_element_value_sanitization_algorithm(this, this.m_value)) else 0.0
    let minimum = html_input_element_min(this) else trap("VERIFY: Optional::operator*")
    let maximum = html_input_element_max(this) else trap("VERIFY: Optional::operator*")
    let position = (value - minimum) / (maximum - minimum) * 100.0

    if let slider_progress_element = this.m_slider_progress_element:
        let width = html_string_formatted("{}%", [ak.arg_f64(position)])
        css_style_properties_set_property_property_id(dom_element_style_for_bindings(slider_progress_element), css_data.PropertyId.width, ak.string_bytes_as_string_view(&width), ak.sv("")) else trap("MUST: set_property")

    if let slider_thumb = this.m_slider_thumb:
        let margin_left = html_string_formatted("{}%", [ak.arg_f64(position)])
        css_style_properties_set_property_property_id(dom_element_style_for_bindings(slider_thumb), css_data.PropertyId.margin_left, ak.string_bytes_as_string_view(&margin_left), ak.sv("")) else trap("MUST: set_property")