script/dom/execcommand/

contenteditable.rs

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */

use std::cmp::Ordering;
use std::ops::Deref;

use html5ever::local_name;
use script_bindings::inheritance::Castable;
use style::attr::AttrValue;
use style::computed_values::white_space_collapse::T as WhiteSpaceCollapse;
use style::properties::PropertyDeclarationId;
use style::properties::generated::{LonghandId, PropertyDeclaration};
use style::values::specified::box_::DisplayOutside;
use style::values::specified::text::TextDecorationLine;

use crate::dom::abstractrange::bp_position;
use crate::dom::bindings::cell::Ref;
use crate::dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
use crate::dom::bindings::codegen::Bindings::DocumentBinding::{
    DocumentMethods, ElementCreationOptions,
};
use crate::dom::bindings::codegen::Bindings::HTMLElementBinding::HTMLElementMethods;
use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
use crate::dom::bindings::codegen::Bindings::RangeBinding::RangeMethods;
use crate::dom::bindings::codegen::Bindings::SelectionBinding::SelectionMethods;
use crate::dom::bindings::codegen::Bindings::TextBinding::TextMethods;
use crate::dom::bindings::codegen::UnionTypes::StringOrElementCreationOptions;
use crate::dom::bindings::error::Fallible;
use crate::dom::bindings::inheritance::{ElementTypeId, HTMLElementTypeId, NodeTypeId};
use crate::dom::bindings::root::{DomRoot, DomSlice};
use crate::dom::bindings::str::DOMString;
use crate::dom::characterdata::CharacterData;
use crate::dom::document::Document;
use crate::dom::element::Element;
use crate::dom::execcommand::basecommand::{CommandName, CssPropertyName};
use crate::dom::execcommand::commands::fontsize::{font_size_to_css_font, legacy_font_size_for};
use crate::dom::html::htmlanchorelement::HTMLAnchorElement;
use crate::dom::html::htmlbrelement::HTMLBRElement;
use crate::dom::html::htmlelement::HTMLElement;
use crate::dom::html::htmlfontelement::HTMLFontElement;
use crate::dom::html::htmlimageelement::HTMLImageElement;
use crate::dom::html::htmllielement::HTMLLIElement;
use crate::dom::html::htmltablecellelement::HTMLTableCellElement;
use crate::dom::html::htmltablerowelement::HTMLTableRowElement;
use crate::dom::html::htmltablesectionelement::HTMLTableSectionElement;
use crate::dom::node::{Node, NodeTraits, ShadowIncluding};
use crate::dom::range::Range;
use crate::dom::selection::Selection;
use crate::dom::text::Text;
use crate::script_runtime::CanGc;

impl Text {
    /// <https://dom.spec.whatwg.org/#concept-cd-data>
    fn data(&self) -> Ref<'_, String> {
        self.upcast::<CharacterData>().data()
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#whitespace-node>
    fn is_whitespace_node(&self) -> bool {
        // > A whitespace node is either a Text node whose data is the empty string;
        let data = self.data();
        if data.is_empty() {
            return true;
        }
        // > or a Text node whose data consists only of one or more tabs (0x0009), line feeds (0x000A),
        // > carriage returns (0x000D), and/or spaces (0x0020),
        // > and whose parent is an Element whose resolved value for "white-space" is "normal" or "nowrap";
        let Some(parent) = self.upcast::<Node>().GetParentElement() else {
            return false;
        };
        // TODO: Optimize the below to only do a traversal once and in the match handle the expected collapse value
        let Some(style) = parent.style() else {
            return false;
        };
        let white_space_collapse = style.get_inherited_text().white_space_collapse;
        if data
            .bytes()
            .all(|byte| matches!(byte, b'\t' | b'\n' | b'\r' | b' ')) &&
            // Note that for "normal" and "nowrap", the longhand "white-space-collapse: collapse" applies
            // https://www.w3.org/TR/css-text-4/#white-space-property
            white_space_collapse == WhiteSpaceCollapse::Collapse
        {
            return true;
        }
        // > or a Text node whose data consists only of one or more tabs (0x0009), carriage returns (0x000D),
        // > and/or spaces (0x0020), and whose parent is an Element whose resolved value for "white-space" is "pre-line".
        data.bytes()
            .all(|byte| matches!(byte, b'\t' | b'\r' | b' ')) &&
            // Note that for "pre-line", the longhand "white-space-collapse: preserve-breaks" applies
            // https://www.w3.org/TR/css-text-4/#white-space-property
            white_space_collapse == WhiteSpaceCollapse::PreserveBreaks
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#collapsed-whitespace-node>
    fn is_collapsed_whitespace_node(&self) -> bool {
        // Step 1. If node is not a whitespace node, return false.
        if !self.is_whitespace_node() {
            return false;
        }
        // Step 2. If node's data is the empty string, return true.
        if self.data().is_empty() {
            return true;
        }
        // Step 3. Let ancestor be node's parent.
        let node = self.upcast::<Node>();
        let Some(ancestor) = node.GetParentNode() else {
            // Step 4. If ancestor is null, return true.
            return true;
        };
        let mut resolved_ancestor = ancestor.clone();
        for parent in ancestor.ancestors() {
            // Step 5. If the "display" property of some ancestor of node has resolved value "none", return true.
            if parent
                .downcast::<Element>()
                .is_some_and(Element::is_display_none)
            {
                return true;
            }
            // Step 6. While ancestor is not a block node and its parent is not null, set ancestor to its parent.
            //
            // Note that the spec is written as "while not". Since this is the end-condition, we need to invert
            // the condition to decide when to stop.
            if parent.is_block_node() {
                break;
            }
            resolved_ancestor = parent;
        }
        // Step 7. Let reference be node.
        // Step 8. While reference is a descendant of ancestor:
        // Step 8.1. Let reference be the node before it in tree order.
        for reference in node.preceding_nodes(&resolved_ancestor) {
            // Step 8.2. If reference is a block node or a br, return true.
            if reference.is_block_node() || reference.is::<HTMLBRElement>() {
                return true;
            }
            // Step 8.3. If reference is a Text node that is not a whitespace node, or is an img, break from this loop.
            if reference
                .downcast::<Text>()
                .is_some_and(|text| !text.is_whitespace_node()) ||
                reference.is::<HTMLImageElement>()
            {
                break;
            }
        }
        // Step 9. Let reference be node.
        // Step 10. While reference is a descendant of ancestor:
        // Step 10.1. Let reference be the node after it in tree order, or null if there is no such node.
        for reference in node.following_nodes(&resolved_ancestor) {
            // Step 10.2. If reference is a block node or a br, return true.
            if reference.is_block_node() || reference.is::<HTMLBRElement>() {
                return true;
            }
            // Step 10.3. If reference is a Text node that is not a whitespace node, or is an img, break from this loop.
            if reference
                .downcast::<Text>()
                .is_some_and(|text| !text.is_whitespace_node()) ||
                reference.is::<HTMLImageElement>()
            {
                break;
            }
        }
        // Step 11. Return false.
        false
    }

    /// Part of <https://w3c.github.io/editing/docs/execCommand/#canonicalize-whitespace>
    /// and deduplicated here, since we need to do this for both start and end nodes
    fn has_whitespace_and_has_parent_with_whitespace_preserve(
        &self,
        offset: u32,
        space_characters: &'static [&'static char],
    ) -> bool {
        // if node is a Text node and its parent's resolved value for "white-space" is neither "pre" nor "pre-wrap"
        // and start offset is not zero and the (start offset − 1)st code unit of start node's data is a space (0x0020) or
        // non-breaking space (0x00A0)
        let has_preserve_space = self
            .upcast::<Node>()
            .GetParentNode()
            .and_then(|parent_node| parent_node.downcast::<Element>().and_then(Element::style))
            .is_some_and(|style| {
                // Note that for "pre" and "pre-wrap", the longhand "white-space-collapse: preserve" applies
                // https://www.w3.org/TR/css-text-4/#white-space-property
                style.get_inherited_text().white_space_collapse != WhiteSpaceCollapse::Preserve
            });
        let has_space_character = self
            .data()
            .chars()
            .nth(offset as usize)
            .is_some_and(|c| space_characters.contains(&&c));
        has_preserve_space && has_space_character
    }
}

impl HTMLBRElement {
    /// <https://w3c.github.io/editing/docs/execCommand/#extraneous-line-break>
    fn is_extraneous_line_break(&self) -> bool {
        let node = self.upcast::<Node>();
        // > An extraneous line break is a br that has no visual effect, in that removing it from the DOM would not change layout,
        // except that a br that is the sole child of an li is not extraneous.
        if node
            .GetParentNode()
            .filter(|parent| parent.is::<HTMLLIElement>())
            .is_some_and(|li| li.children_count() == 1)
        {
            return false;
        }
        // TODO: Figure out what this actually makes it have no visual effect
        !node.is_block_node()
    }
}

impl Document {
    pub(crate) fn create_element(
        &self,
        cx: &mut js::context::JSContext,
        name: &str,
    ) -> DomRoot<Element> {
        let element_options =
            StringOrElementCreationOptions::ElementCreationOptions(ElementCreationOptions {
                is: None,
            });
        self.CreateElement(cx, name.into(), element_options)
            .expect("Must always be able to create element")
    }
}

impl HTMLElement {
    fn local_name(&self) -> &str {
        self.upcast::<Element>().local_name()
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#clear-the-value>
    fn clear_the_value(&self, cx: &mut js::context::JSContext, command: &CommandName) {
        // Step 1. Let command be the current command.
        //
        // Passed in as argument

        let node = self.upcast::<Node>();
        let element = self.upcast::<Element>();

        // Step 2. If element is not editable, return the empty list.
        if !node.is_editable() {
            return;
        }
        // Step 3. If element's specified command value for command is null,
        // return the empty list.
        if element.specified_command_value(command).is_none() {
            return;
        }
        // Step 4. If element is a simple modifiable element:
        if element.is_simple_modifiable_element() {
            // Step 4.1. Let children be the children of element.
            // Step 4.2. For each child in children, insert child into element's parent immediately before element, preserving ranges.
            let element_parent = node.GetParentNode().expect("Must always have a parent");
            for child in node.children() {
                if element_parent.InsertBefore(cx, &child, Some(node)).is_err() {
                    unreachable!("Must always be able to insert");
                }
            }
            // Step 4.3. Remove element from its parent.
            node.remove_self(cx);
            // Step 4.4. Return children.
            return;
        }
        match command {
            // Step 5. If command is "strikethrough", and element has a style attribute
            // that sets "text-decoration" to some value containing "line-through",
            // delete "line-through" from the value.
            CommandName::Strikethrough => {
                let property = CssPropertyName::TextDecorationLine;
                if property.value_for_element(cx, self) == "line-through" {
                    // TODO: Only remove line-through
                    property.remove_from_element(cx, self);
                }
            },
            // Step 6. If command is "underline", and element has a style attribute that
            // sets "text-decoration" to some value containing "underline", delete "underline" from the value.
            CommandName::Underline => {
                let property = CssPropertyName::TextDecorationLine;
                if property.value_for_element(cx, self) == "underline" {
                    // TODO: Only remove underline
                    property.remove_from_element(cx, self);
                }
            },
            _ => {},
        }
        // Step 7. If the relevant CSS property for command is not null,
        // unset that property of element.
        if let Some(property) = command.relevant_css_property() {
            property.remove_from_element(cx, self);
        }
        // Step 8. If element is a font element:
        if self.is::<HTMLFontElement>() {
            match command {
                // Step 8.1. If command is "foreColor", unset element's color attribute, if set.
                CommandName::ForeColor => {
                    element.remove_attribute_by_name(&local_name!("color"), CanGc::from_cx(cx));
                },
                // Step 8.2. If command is "fontName", unset element's face attribute, if set.
                CommandName::FontName => {
                    element.remove_attribute_by_name(&local_name!("face"), CanGc::from_cx(cx));
                },
                // Step 8.3. If command is "fontSize", unset element's size attribute, if set.
                CommandName::FontSize => {
                    element.remove_attribute_by_name(&local_name!("size"), CanGc::from_cx(cx));
                },
                _ => {},
            }
        }
        // Step 9. If element is an a element and command is "createLink" or "unlink",
        // unset the href property of element.
        if self.is::<HTMLAnchorElement>() &&
            matches!(command, CommandName::CreateLink | CommandName::Unlink)
        {
            element.remove_attribute_by_name(&local_name!("href"), CanGc::from_cx(cx));
        }
        // Step 10. If element's specified command value for command is null,
        // return the empty list.
        if element.specified_command_value(command).is_none() {
            // TODO
        }
        // Step 11. Set the tag name of element to "span",
        // and return the one-node list consisting of the result.
        // TODO
    }
}

impl Element {
    fn resolved_display_value(&self) -> Option<DisplayOutside> {
        self.style().map(|style| style.get_box().display.outside())
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#specified-command-value>
    pub(crate) fn specified_command_value(&self, command: &CommandName) -> Option<DOMString> {
        match command {
            // Step 1. If command is "backColor" or "hiliteColor" and the Element's display property does not have resolved value "inline", return null.
            CommandName::BackColor | CommandName::HiliteColor => {
                // TODO
            },
            // Step 2. If command is "createLink" or "unlink":
            CommandName::CreateLink | CommandName::Unlink => {
                // TODO
            },
            // Step 3. If command is "subscript" or "superscript":
            CommandName::Subscript | CommandName::Superscript => {
                // TODO
            },
            CommandName::Strikethrough => {
                // Step 4. If command is "strikethrough", and element has a style attribute set, and that attribute sets "text-decoration":
                // TODO
                // Step 5. If command is "strikethrough" and element is an s or strike element, return "line-through".
                // TODO
            },
            CommandName::Underline => {
                // Step 6. If command is "underline", and element has a style attribute set, and that attribute sets "text-decoration":
                // TODO
                // Step 7. If command is "underline" and element is a u element, return "underline".
                // TODO
            },
            _ => {},
        };
        // Step 8. Let property be the relevant CSS property for command.
        // Step 9. If property is null, return null.
        let property = command.relevant_css_property()?;
        // Step 10. If element has a style attribute set, and that attribute has the effect of setting property,
        // return the value that it sets property to.
        if let Some(value) = property.value_set_for_style(self) {
            return Some(value);
        }
        // Step 11. If element is a font element that has an attribute whose effect is to create a presentational hint for property,
        // return the value that the hint sets property to. (For a size of 7, this will be the non-CSS value "xxx-large".)
        if self.is::<HTMLFontElement>() {
            if let Some(font_size) = self.get_attribute(&local_name!("size")) {
                if let AttrValue::UInt(_, value) = *font_size.value() {
                    return Some(font_size_to_css_font(&value).into());
                }
            }
        }

        // Step 12. If element is in the following list, and property is equal to the CSS property name listed for it,
        // return the string listed for it.
        let element_name = self.local_name();
        match property {
            CssPropertyName::FontWeight
                if element_name == &local_name!("b") || element_name == &local_name!("strong") =>
            {
                Some("bold".into())
            },
            CssPropertyName::FontStyle
                if element_name == &local_name!("i") || element_name == &local_name!("em") =>
            {
                Some("italic".into())
            },
            // Step 13. Return null.
            _ => None,
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#simple-modifiable-element>
    fn is_simple_modifiable_element(&self) -> bool {
        let attrs = self.attrs();
        let attr_count = attrs.len();
        let type_id = self.upcast::<Node>().type_id();

        if matches!(
            type_id,
            NodeTypeId::Element(ElementTypeId::HTMLElement(
                HTMLElementTypeId::HTMLAnchorElement,
            )) | NodeTypeId::Element(ElementTypeId::HTMLElement(
                HTMLElementTypeId::HTMLFontElement,
            )) | NodeTypeId::Element(ElementTypeId::HTMLElement(
                HTMLElementTypeId::HTMLSpanElement,
            ))
        ) {
            // > It is an a, b, em, font, i, s, span, strike, strong, sub, sup, or u element with no attributes.
            //
            // TODO: All elements that are HTMLElement rather than a specific one
            if attr_count == 0 {
                return true;
            }

            // > It is an a, b, em, font, i, s, span, strike, strong, sub, sup, or u element
            // > with exactly one attribute, which is style,
            // > which sets no CSS properties (including invalid or unrecognized properties).
            if attr_count == 1 &&
                self.attrs().first().expect("Size is 1").local_name() == &local_name!("style")
            {
                let style_attribute = self.style_attribute().borrow();
                if style_attribute.as_ref().is_some_and(|declarations| {
                    let document = self.owner_document();
                    let shared_lock = document.style_shared_lock();
                    let read_lock = shared_lock.read();
                    let style = declarations.read_with(&read_lock);

                    style.is_empty()
                }) {
                    return true;
                }
            }
        }

        if attr_count != 1 {
            return false;
        }

        let only_attribute = attrs.first().expect("Size is 1").local_name();

        // > It is an a element with exactly one attribute, which is href.
        if matches!(
            type_id,
            NodeTypeId::Element(ElementTypeId::HTMLElement(
                HTMLElementTypeId::HTMLAnchorElement,
            ))
        ) {
            return only_attribute == &local_name!("href");
        }

        // > It is a font element with exactly one attribute, which is either color, face, or size.
        if matches!(
            type_id,
            NodeTypeId::Element(ElementTypeId::HTMLElement(
                HTMLElementTypeId::HTMLFontElement,
            ))
        ) {
            return only_attribute == &local_name!("color") ||
                only_attribute == &local_name!("face") ||
                only_attribute == &local_name!("size");
        }

        // > It is a b or strong element with exactly one attribute, which is style,
        // > and the style attribute sets exactly one CSS property
        // > (including invalid or unrecognized properties), which is "font-weight".
        // TODO

        // > It is an i or em element with exactly one attribute, which is style,
        // > and the style attribute sets exactly one CSS property (including invalid or unrecognized properties),
        // > which is "font-style".
        // TODO

        // > It is an a, font, or span element with exactly one attribute, which is style,
        // > and the style attribute sets exactly one CSS property (including invalid or unrecognized properties),
        // > and that property is not "text-decoration".
        if matches!(
            type_id,
            NodeTypeId::Element(ElementTypeId::HTMLElement(
                HTMLElementTypeId::HTMLAnchorElement,
            )) | NodeTypeId::Element(ElementTypeId::HTMLElement(
                HTMLElementTypeId::HTMLFontElement,
            )) | NodeTypeId::Element(ElementTypeId::HTMLElement(
                HTMLElementTypeId::HTMLSpanElement,
            ))
        ) {
            if only_attribute != &local_name!("style") {
                return false;
            }
            let style_attribute = self.style_attribute().borrow();
            let Some(declarations) = style_attribute.as_ref() else {
                return false;
            };
            let document = self.owner_document();
            let shared_lock = document.style_shared_lock();
            let read_lock = shared_lock.read();
            let style = declarations.read_with(&read_lock);

            if style.len() == 1 {
                if let Some((text_decoration, _)) = style.get(PropertyDeclarationId::Longhand(
                    LonghandId::TextDecorationLine,
                )) {
                    // > It is an a, font, s, span, strike, or u element with exactly one attribute,
                    // > which is style, and the style attribute sets exactly one CSS property
                    // > (including invalid or unrecognized properties), which is "text-decoration",
                    // > which is set to "line-through" or "underline" or "overline" or "none".
                    //
                    // TODO: Also the other element types
                    return matches!(
                        text_decoration,
                        PropertyDeclaration::TextDecorationLine(
                            TextDecorationLine::LINE_THROUGH |
                                TextDecorationLine::UNDERLINE |
                                TextDecorationLine::OVERLINE |
                                TextDecorationLine::NONE
                        )
                    );
                } else {
                    // > It is an a, font, or span element with exactly one attribute, which is style,
                    // > and the style attribute sets exactly one CSS property (including invalid or unrecognized properties),
                    // > and that property is not "text-decoration".
                    return true;
                }
            }
        }

        false
    }
}

pub(crate) enum NodeOrString {
    String(String),
    Node(DomRoot<Node>),
}

impl NodeOrString {
    fn name(&self) -> &str {
        match self {
            NodeOrString::String(str_) => str_,
            NodeOrString::Node(node) => node
                .downcast::<Element>()
                .map(|element| element.local_name().as_ref())
                .unwrap_or_default(),
        }
    }

    fn as_node(&self) -> Option<DomRoot<Node>> {
        match self {
            NodeOrString::String(_) => None,
            NodeOrString::Node(node) => Some(node.clone()),
        }
    }
}

/// <https://w3c.github.io/editing/docs/execCommand/#prohibited-paragraph-child-name>
const PROHIBITED_PARAGRAPH_CHILD_NAMES: [&str; 47] = [
    "address",
    "article",
    "aside",
    "blockquote",
    "caption",
    "center",
    "col",
    "colgroup",
    "dd",
    "details",
    "dir",
    "div",
    "dl",
    "dt",
    "fieldset",
    "figcaption",
    "figure",
    "footer",
    "form",
    "h1",
    "h2",
    "h3",
    "h4",
    "h5",
    "h6",
    "header",
    "hgroup",
    "hr",
    "li",
    "listing",
    "menu",
    "nav",
    "ol",
    "p",
    "plaintext",
    "pre",
    "section",
    "summary",
    "table",
    "tbody",
    "td",
    "tfoot",
    "th",
    "thead",
    "tr",
    "ul",
    "xmp",
];
/// <https://w3c.github.io/editing/docs/execCommand/#name-of-an-element-with-inline-contents>
const NAME_OF_AN_ELEMENT_WITH_INLINE_CONTENTS: [&str; 43] = [
    "a", "abbr", "b", "bdi", "bdo", "cite", "code", "dfn", "em", "h1", "h2", "h3", "h4", "h5",
    "h6", "i", "kbd", "mark", "p", "pre", "q", "rp", "rt", "ruby", "s", "samp", "small", "span",
    "strong", "sub", "sup", "u", "var", "acronym", "listing", "strike", "xmp", "big", "blink",
    "font", "marquee", "nobr", "tt",
];

/// <https://w3c.github.io/editing/docs/execCommand/#element-with-inline-contents>
fn is_element_with_inline_contents(element: &Node) -> bool {
    // > An element with inline contents is an HTML element whose local name is a name of an element with inline contents.
    let Some(html_element) = element.downcast::<HTMLElement>() else {
        return false;
    };
    NAME_OF_AN_ELEMENT_WITH_INLINE_CONTENTS.contains(&html_element.local_name())
}

/// <https://w3c.github.io/editing/docs/execCommand/#preserving-ranges>
fn move_preserving_ranges<Move>(cx: &mut js::context::JSContext, node: &Node, mut move_: Move)
where
    Move: FnMut(&mut js::context::JSContext) -> Fallible<DomRoot<Node>>,
{
    // Step 1. Let node be the moved node, old parent and old index be the old parent
    // (which may be null) and index, and new parent and new index be the new parent and index.
    let old_parent = node.GetParentNode();
    let old_index = node.index();

    if move_(cx).is_err() {
        unreachable!("Must always be able to move");
    }

    let Some(selection) = node.owner_document().GetSelection(CanGc::from_cx(cx)) else {
        return;
    };
    let Some(active_range) = selection.active_range() else {
        return;
    };

    let new_parent = node.GetParentNode().expect("Must always have a new parent");
    let new_index = node.index();

    let mut start_node = active_range.start_container();
    let mut start_offset = active_range.start_offset();
    let mut end_node = active_range.end_container();
    let mut end_offset = active_range.end_offset();

    // Step 2. If a boundary point's node is the same as or a descendant of node, leave it unchanged, so it moves to the new location.
    //
    // From the spec:
    // > This is actually implicit, but I state it anyway for completeness.

    // Step 3. If a boundary point's node is new parent and its offset is greater than new index, add one to its offset.
    if start_node == new_parent && start_offset > new_index {
        start_offset += 1;
    }
    if end_node == new_parent && end_offset > new_index {
        end_offset += 1;
    }

    if let Some(old_parent) = old_parent {
        // Step 4. If a boundary point's node is old parent and its offset is old index or old index + 1,
        // set its node to new parent and add new index − old index to its offset.
        if start_node == old_parent && (start_offset == old_index || start_offset == old_index + 1)
        {
            start_node = new_parent.clone();
            start_offset += new_index;
            start_offset -= old_index;
        }
        if end_node == old_parent && (end_offset == old_index || end_offset == old_index + 1) {
            end_node = new_parent;
            end_offset += new_index;
            end_offset -= old_index;
        }

        // Step 5. If a boundary point's node is old parent and its offset is greater than old index + 1,
        // subtract one from its offset.
        if start_node == old_parent && (start_offset > old_index + 1) {
            start_offset -= 1;
        }
        if end_node == old_parent && (end_offset > old_index + 1) {
            end_offset -= 1;
        }
    }

    active_range.set_start(&start_node, start_offset);
    active_range.set_end(&end_node, end_offset);
}

/// <https://w3c.github.io/editing/docs/execCommand/#allowed-child>
fn is_allowed_child(child: NodeOrString, parent: NodeOrString) -> bool {
    // Step 1. If parent is "colgroup", "table", "tbody", "tfoot", "thead", "tr",
    // or an HTML element with local name equal to one of those,
    // and child is a Text node whose data does not consist solely of space characters, return false.
    if matches!(
        parent.name(),
        "colgroup" | "table" | "tbody" | "tfoot" | "thead" | "tr"
    ) && child.as_node().is_some_and(|node| {
        // Note: cannot use `.and_then` here, since `downcast` would outlive its reference
        node.downcast::<Text>()
            .is_some_and(|text| !text.data().bytes().all(|byte| byte == b' '))
    }) {
        return false;
    }
    // Step 2. If parent is "script", "style", "plaintext", or "xmp",
    // or an HTML element with local name equal to one of those, and child is not a Text node, return false.
    if matches!(parent.name(), "script" | "style" | "plaintext" | "xmp") &&
        child.as_node().is_none_or(|node| !node.is::<Text>())
    {
        return false;
    }
    // Step 3. If child is a document, DocumentFragment, or DocumentType, return false.
    if let NodeOrString::Node(ref node) = child {
        if matches!(
            node.type_id(),
            NodeTypeId::Document(_) | NodeTypeId::DocumentFragment(_) | NodeTypeId::DocumentType
        ) {
            return false;
        }
    }
    // Step 4. If child is an HTML element, set child to the local name of child.
    let child_name = match child {
        NodeOrString::String(str_) => str_,
        NodeOrString::Node(node) => match node.downcast::<HTMLElement>() {
            // Step 5. If child is not a string, return true.
            None => return true,
            Some(html_element) => html_element.local_name().to_owned(),
        },
    };
    let child = child_name.as_str();
    let parent_name = match parent {
        NodeOrString::String(str_) => str_,
        NodeOrString::Node(parent) => {
            // Step 6. If parent is an HTML element:
            if let Some(parent_element) = parent.downcast::<HTMLElement>() {
                // Step 6.1. If child is "a", and parent or some ancestor of parent is an a, return false.
                if child == "a" &&
                    parent
                        .inclusive_ancestors(ShadowIncluding::No)
                        .any(|node| node.is::<HTMLAnchorElement>())
                {
                    return false;
                }
                // Step 6.2. If child is a prohibited paragraph child name and parent or some ancestor of parent
                // is an element with inline contents, return false.
                if PROHIBITED_PARAGRAPH_CHILD_NAMES.contains(&child) &&
                    parent
                        .inclusive_ancestors(ShadowIncluding::No)
                        .any(|node| is_element_with_inline_contents(&node))
                {
                    return false;
                }
                // Step 6.3. If child is "h1", "h2", "h3", "h4", "h5", or "h6",
                // and parent or some ancestor of parent is an HTML element with local name
                // "h1", "h2", "h3", "h4", "h5", or "h6", return false.
                if matches!(child, "h1" | "h2" | "h3" | "h4" | "h5" | "h6") &&
                    parent.inclusive_ancestors(ShadowIncluding::No).any(|node| {
                        node.downcast::<HTMLElement>().is_some_and(|html_element| {
                            matches!(
                                html_element.local_name(),
                                "h1" | "h2" | "h3" | "h4" | "h5" | "h6"
                            )
                        })
                    })
                {
                    return false;
                }
                // Step 6.4. Let parent be the local name of parent.
                parent_element.local_name().to_owned()
            } else {
                // Step 7. If parent is an Element or DocumentFragment, return true.
                // Step 8. If parent is not a string, return false.
                return matches!(
                    parent.type_id(),
                    NodeTypeId::DocumentFragment(_) | NodeTypeId::Element(_)
                );
            }
        },
    };
    let parent = parent_name.as_str();
    // Step 9. If parent is on the left-hand side of an entry on the following list,
    // then return true if child is listed on the right-hand side of that entry, and false otherwise.
    match parent {
        "colgroup" => return child == "col",
        "table" => {
            return matches!(
                child,
                "caption" | "col" | "colgroup" | "tbody" | "td" | "tfoot" | "th" | "thead" | "tr"
            );
        },
        "tbody" | "tfoot" | "thead" => return matches!(child, "td" | "th" | "tr"),
        "tr" => return matches!(child, "td" | "th"),
        "dl" => return matches!(child, "dt" | "dd"),
        "dir" | "ol" | "ul" => return matches!(child, "dir" | "li" | "ol" | "ul"),
        "hgroup" => return matches!(child, "h1" | "h2" | "h3" | "h4" | "h5" | "h6"),
        _ => {},
    };
    // Step 10. If child is "body", "caption", "col", "colgroup", "frame", "frameset", "head",
    // "html", "tbody", "td", "tfoot", "th", "thead", or "tr", return false.
    if matches!(
        child,
        "body" |
            "caption" |
            "col" |
            "colgroup" |
            "frame" |
            "frameset" |
            "head" |
            "html" |
            "tbody" |
            "td" |
            "tfoot" |
            "th" |
            "thead" |
            "tr"
    ) {
        return false;
    }
    // Step 11. If child is "dd" or "dt" and parent is not "dl", return false.
    if matches!(child, "dd" | "dt") && parent != "dl" {
        return false;
    }
    // Step 12. If child is "li" and parent is not "ol" or "ul", return false.
    if child == "li" && !matches!(parent, "ol" | "ul") {
        return false;
    }
    // Step 13. If parent is on the left-hand side of an entry on the following list
    // and child is listed on the right-hand side of that entry, return false.
    if match parent {
        "a" => child == "a",
        "dd" | "dt" => matches!(child, "dd" | "dt"),
        "h1" | "h2" | "h3" | "h4" | "h5" | "h6" => {
            matches!(child, "h1" | "h2" | "h3" | "h4" | "h5" | "h6")
        },
        "li" => child == "li",
        "nobr" => child == "nobr",
        "td" | "th" => {
            matches!(
                child,
                "caption" | "col" | "colgroup" | "tbody" | "td" | "tfoot" | "th" | "thead" | "tr"
            )
        },
        _ if NAME_OF_AN_ELEMENT_WITH_INLINE_CONTENTS.contains(&parent) => {
            PROHIBITED_PARAGRAPH_CHILD_NAMES.contains(&child)
        },
        _ => false,
    } {
        return false;
    }
    // Step 14. Return true.
    true
}

/// <https://w3c.github.io/editing/docs/execCommand/#split-the-parent>
pub(crate) fn split_the_parent<'a>(cx: &mut js::context::JSContext, node_list: &'a [&'a Node]) {
    assert!(!node_list.is_empty());
    // Step 1. Let original parent be the parent of the first member of node list.
    let Some(original_parent) = node_list.first().and_then(|first| first.GetParentNode()) else {
        return;
    };
    let context_object = original_parent.owner_document();
    // Step 2. If original parent is not editable or its parent is null, do nothing and abort these steps.
    if !original_parent.is_editable() {
        return;
    }
    let Some(parent_of_original_parent) = original_parent.GetParentNode() else {
        return;
    };
    // Step 3. If the first child of original parent is in node list, remove extraneous line breaks before original parent.
    if original_parent
        .children()
        .next()
        .is_some_and(|first_child| node_list.contains(&first_child.deref()))
    {
        original_parent.remove_extraneous_line_breaks_before(cx);
    }
    // Step 4. If the first child of original parent is in node list, and original parent follows a line break,
    // set follows line break to true. Otherwise, set follows line break to false.
    let first_child_is_in_node_list = original_parent
        .children()
        .next()
        .is_some_and(|first_child| node_list.contains(&first_child.deref()));
    let follows_line_break = first_child_is_in_node_list && original_parent.follows_a_line_break();
    // Step 5. If the last child of original parent is in node list, and original parent precedes a line break,
    // set precedes line break to true. Otherwise, set precedes line break to false.
    let last_child_is_in_node_list = original_parent
        .children()
        .last()
        .is_some_and(|last_child| node_list.contains(&last_child.deref()));
    let precedes_line_break = last_child_is_in_node_list && original_parent.precedes_a_line_break();
    // Step 6. If the first child of original parent is not in node list, but its last child is:
    if !first_child_is_in_node_list && last_child_is_in_node_list {
        // Step 6.1. For each node in node list, in reverse order,
        // insert node into the parent of original parent immediately after original parent, preserving ranges.
        let next_of_original_parent = original_parent.GetNextSibling();
        for node in node_list.iter().rev() {
            move_preserving_ranges(cx, node, |cx| {
                parent_of_original_parent.InsertBefore(cx, node, next_of_original_parent.as_deref())
            });
        }
        // Step 6.2. If precedes line break is true, and the last member of node list does not precede a line break,
        // call createElement("br") on the context object and insert the result immediately after the last member of node list.
        if precedes_line_break {
            if let Some(last) = node_list.last() {
                if !last.precedes_a_line_break() {
                    let br = context_object.create_element(cx, "br");
                    if last
                        .GetParentNode()
                        .expect("Must always have a parent")
                        .InsertBefore(cx, br.upcast(), last.GetNextSibling().as_deref())
                        .is_err()
                    {
                        unreachable!("Must always be able to append");
                    }
                }
            }
        }
        // Step 6.3. Remove extraneous line breaks at the end of original parent.
        original_parent.remove_extraneous_line_breaks_at_the_end_of(cx);
        // Step 6.4. Abort these steps.
        return;
    }
    // Step 7. If the first child of original parent is not in node list:
    if first_child_is_in_node_list {
        // Step 7.1. Let cloned parent be the result of calling cloneNode(false) on original parent.
        let Ok(cloned_parent) = original_parent.CloneNode(cx, false) else {
            unreachable!("Must always be able to clone node");
        };
        // Step 7.2. If original parent has an id attribute, unset it.
        if let Some(element) = original_parent.downcast::<Element>() {
            element.remove_attribute_by_name(&local_name!("id"), CanGc::from_cx(cx));
        }
        // Step 7.3. Insert cloned parent into the parent of original parent immediately before original parent.
        if parent_of_original_parent
            .InsertBefore(cx, &cloned_parent, Some(&original_parent))
            .is_err()
        {
            unreachable!("Must always have a parent");
        }
        // Step 7.4. While the previousSibling of the first member of node list is not null,
        // append the first child of original parent as the last child of cloned parent, preserving ranges.
        loop {
            if node_list
                .first()
                .and_then(|first| first.GetPreviousSibling())
                .is_some()
            {
                if let Some(first_of_original) = original_parent.children().next() {
                    move_preserving_ranges(cx, &first_of_original, |cx| {
                        cloned_parent.AppendChild(cx, &first_of_original)
                    });
                    continue;
                }
            }
            break;
        }
    }
    // Step 8. For each node in node list, insert node into the parent of original parent immediately before original parent, preserving ranges.
    for node in node_list.iter() {
        move_preserving_ranges(cx, node, |cx| {
            parent_of_original_parent.InsertBefore(cx, node, Some(&original_parent))
        });
    }
    // Step 9. If follows line break is true, and the first member of node list does not follow a line break,
    // call createElement("br") on the context object and insert the result immediately before the first member of node list.
    if follows_line_break {
        if let Some(first) = node_list.first() {
            if !first.follows_a_line_break() {
                let br = context_object.create_element(cx, "br");
                if first
                    .GetParentNode()
                    .expect("Must always have a parent")
                    .InsertBefore(cx, br.upcast(), Some(first))
                    .is_err()
                {
                    unreachable!("Must always be able to insert");
                }
            }
        }
    }
    // Step 10. If the last member of node list is an inline node other than a br,
    // and the first child of original parent is a br, and original parent is not an inline node,
    // remove the first child of original parent from original parent.
    if node_list
        .last()
        .is_some_and(|last| last.is_inline_node() && !last.is::<HTMLBRElement>()) &&
        !original_parent.is_inline_node()
    {
        if let Some(first_of_original) = original_parent.children().next() {
            if first_of_original.is::<HTMLBRElement>() {
                assert!(first_of_original.has_parent());
                first_of_original.remove_self(cx);
            }
        }
    }
    // Step 11. If original parent has no children:
    if original_parent.children_count() == 0 {
        // Step 11.1. Remove original parent from its parent.
        assert!(original_parent.has_parent());
        original_parent.remove_self(cx);
        // Step 11.2. If precedes line break is true, and the last member of node list does not precede a line break,
        // call createElement("br") on the context object and insert the result immediately after the last member of node list.
        if precedes_line_break {
            if let Some(last) = node_list.last() {
                if !last.precedes_a_line_break() {
                    let br = context_object.create_element(cx, "br");
                    if last
                        .GetParentNode()
                        .expect("Must always have a parent")
                        .InsertBefore(cx, br.upcast(), last.GetNextSibling().as_deref())
                        .is_err()
                    {
                        unreachable!("Must always be able to insert");
                    }
                }
            }
        }
    } else {
        // Step 12. Otherwise, remove extraneous line breaks before original parent.
        original_parent.remove_extraneous_line_breaks_before(cx);
    }
    // Step 13. If node list's last member's nextSibling is null, but its parent is not null,
    // remove extraneous line breaks at the end of node list's last member's parent.
    if let Some(last) = node_list.last() {
        if last.GetNextSibling().is_none() {
            if let Some(parent_of_last) = last.GetParentNode() {
                parent_of_last.remove_extraneous_line_breaks_at_the_end_of(cx);
            }
        }
    }
}

/// <https://w3c.github.io/editing/docs/execCommand/#wrap>
fn wrap_node_list<SiblingCriteria, NewParentInstructions>(
    cx: &mut js::context::JSContext,
    node_list: Vec<DomRoot<Node>>,
    sibling_criteria: SiblingCriteria,
    new_parent_instructions: NewParentInstructions,
) -> Option<DomRoot<Node>>
where
    SiblingCriteria: Fn(&Node) -> bool,
    NewParentInstructions: Fn() -> Option<DomRoot<Node>>,
{
    // Step 1. If every member of node list is invisible,
    // and none is a br, return null and abort these steps.
    if node_list
        .iter()
        .all(|node| node.is_invisible() && !node.is::<HTMLBRElement>())
    {
        return None;
    }
    // Step 2. If node list's first member's parent is null, return null and abort these steps.
    node_list.first().and_then(|first| first.GetParentNode())?;
    // Step 3. If node list's last member is an inline node that's not a br,
    // and node list's last member's nextSibling is a br, append that br to node list.
    let mut node_list = node_list;
    if let Some(last) = node_list.last() {
        if last.is_inline_node() && !last.is::<HTMLBRElement>() {
            if let Some(next_of_last) = last.GetNextSibling() {
                if next_of_last.is::<HTMLBRElement>() {
                    node_list.push(next_of_last);
                }
            }
        }
    }
    // Step 4. While node list's first member's previousSibling is invisible, prepend it to node list.
    while let Some(previous_of_first) = node_list.first().and_then(|last| last.GetPreviousSibling())
    {
        if previous_of_first.is_invisible() {
            node_list.insert(0, previous_of_first);
            continue;
        }
        break;
    }
    // Step 5. While node list's last member's nextSibling is invisible, append it to node list.
    while let Some(next_of_last) = node_list.last().and_then(|last| last.GetNextSibling()) {
        if next_of_last.is_invisible() {
            node_list.push(next_of_last);
            continue;
        }
        break;
    }
    // Step 6. If the previousSibling of the first member of node list is editable
    // and running sibling criteria on it returns true,
    // let new parent be the previousSibling of the first member of node list.
    let new_parent = node_list
        .first()
        .and_then(|first| first.GetPreviousSibling())
        .filter(|previous_of_first| {
            previous_of_first.is_editable() && sibling_criteria(previous_of_first)
        });
    // Step 7. Otherwise, if the nextSibling of the last member of node list is editable
    // and running sibling criteria on it returns true,
    // let new parent be the nextSibling of the last member of node list.
    let new_parent = new_parent.or_else(|| {
        node_list
            .last()
            .and_then(|first| first.GetNextSibling())
            .filter(|next_of_last| next_of_last.is_editable() && sibling_criteria(next_of_last))
    });
    // Step 8. Otherwise, run new parent instructions, and let new parent be the result.
    // Step 9. If new parent is null, abort these steps and return null.
    let new_parent = new_parent.or_else(new_parent_instructions)?;
    // Step 11. Let original parent be the parent of the first member of node list.
    let first_in_node_list = node_list
        .first()
        .expect("Must always have at least one node");
    let original_parent = first_in_node_list
        .GetParentNode()
        .expect("First node must have a parent");
    // Step 10. If new parent's parent is null:
    if new_parent.GetParentNode().is_none() {
        // Step 10.1. Insert new parent into the parent of the first member
        // of node list immediately before the first member of node list.
        if original_parent
            .InsertBefore(cx, &new_parent, Some(first_in_node_list))
            .is_err()
        {
            unreachable!("Must always be able to insert");
        }
        // Step 10.2. If any range has a boundary point with node equal
        // to the parent of new parent and offset equal to the index of new parent,
        // add one to that boundary point's offset.
        if let Some(range) = first_in_node_list
            .owner_document()
            .GetSelection(CanGc::from_cx(cx))
            .and_then(|selection| selection.active_range())
        {
            let parent_of_new_parent = new_parent.GetParentNode().expect("Must have a parent");
            let start_container = range.start_container();
            let start_offset = range.start_offset();

            if start_container == parent_of_new_parent && start_offset == new_parent.index() {
                range.set_start(&start_container, start_offset + 1);
            }

            let end_container = range.end_container();
            let end_offset = range.end_offset();

            if end_container == parent_of_new_parent && end_offset == new_parent.index() {
                range.set_start(&end_container, end_offset + 1);
            }
        }
    }
    // Step 12. If new parent is before the first member of node list in tree order:
    if new_parent.is_before(first_in_node_list) {
        // Step 12.1. If new parent is not an inline node, but the last visible child of new parent
        // and the first visible member of node list are both inline nodes,
        // and the last child of new parent is not a br,
        // call createElement("br") on the ownerDocument of new parent
        // and append the result as the last child of new parent.
        // TODO
        // Step 12.2. For each node in node list, append node as the last child of new parent, preserving ranges.
        for node in node_list {
            move_preserving_ranges(cx, &node, |cx| new_parent.AppendChild(cx, &node));
        }
    } else {
        // Step 13. Otherwise:
        // Step 13.1. If new parent is not an inline node, but the first visible child of new parent
        // and the last visible member of node list are both inline nodes,
        // and the last member of node list is not a br,
        // call createElement("br") on the ownerDocument of new parent
        // and insert the result as the first child of new parent.
        // TODO
        // Step 13.2. For each node in node list, in reverse order,
        // insert node as the first child of new parent, preserving ranges.
        let mut before = new_parent.GetFirstChild();
        for node in node_list.iter().rev() {
            move_preserving_ranges(cx, node, |cx| {
                new_parent.InsertBefore(cx, node, before.as_deref())
            });
            before = Some(DomRoot::from_ref(node));
        }
    }
    // Step 14. If original parent is editable and has no children, remove it from its parent.
    if original_parent.is_editable() && original_parent.children_count() == 0 {
        original_parent.remove_self(cx);
    }
    // Step 15. If new parent's nextSibling is editable and running sibling criteria on it returns true:
    if let Some(next_of_new_parent) = new_parent.GetNextSibling() {
        if next_of_new_parent.is_editable() && sibling_criteria(&next_of_new_parent) {
            // Step 15.1. If new parent is not an inline node,
            // but new parent's last child and new parent's nextSibling's first child are both inline nodes,
            // and new parent's last child is not a br, call createElement("br") on the ownerDocument
            // of new parent and append the result as the last child of new parent.
            if !new_parent.is_inline_node() {
                if let Some(last_child_of_new_parent) = new_parent.children().last() {
                    if last_child_of_new_parent.is_inline_node() &&
                        !last_child_of_new_parent.is::<HTMLBRElement>() &&
                        next_of_new_parent
                            .children()
                            .next()
                            .is_some_and(|first| first.is_inline_node())
                    {
                        let new_br_element = new_parent.owner_document().create_element(cx, "br");
                        if new_parent.AppendChild(cx, new_br_element.upcast()).is_err() {
                            unreachable!("Must always be able to append");
                        }
                    }
                }
            }
            // Step 15.2. While new parent's nextSibling has children,
            // append its first child as the last child of new parent, preserving ranges.
            while let Some(first_of_next) = next_of_new_parent.children().next() {
                move_preserving_ranges(cx, &first_of_next, |cx| {
                    new_parent.AppendChild(cx, &first_of_next)
                });
            }
            // Step 15.3. Remove new parent's nextSibling from its parent.
            next_of_new_parent.remove_self(cx);
        }
    }
    // Step 16. Remove extraneous line breaks from new parent.
    new_parent.remove_extraneous_line_breaks_from(cx);
    // Step 17. Return new parent.
    Some(new_parent)
}

impl Node {
    /// <https://w3c.github.io/editing/docs/execCommand/#push-down-values>
    fn push_down_values(
        &self,
        cx: &mut js::context::JSContext,
        command: &CommandName,
        new_value: Option<DOMString>,
    ) {
        // Step 1. Let command be the current command.
        //
        // Passed in as argument

        // Step 4. Let current ancestor be node's parent.
        let mut current_ancestor = self.GetParentElement();
        // Step 2. If node's parent is not an Element, abort this algorithm.
        if current_ancestor.is_none() {
            return;
        };
        // Step 3. If the effective command value of command is loosely equivalent to new value on node,
        // abort this algorithm.
        if command.are_loosely_equivalent_values(
            self.effective_command_value(command).as_ref(),
            new_value.as_ref(),
        ) {
            return;
        }
        // Step 5. Let ancestor list be a list of nodes, initially empty.
        rooted_vec!(let mut ancestor_list);
        // Step 6. While current ancestor is an editable Element and
        // the effective command value of command is not loosely equivalent to new value on it,
        // append current ancestor to ancestor list, then set current ancestor to its parent.
        while let Some(ancestor) = current_ancestor {
            let ancestor_node = ancestor.upcast::<Node>();
            if ancestor_node.is_editable() &&
                !command.are_loosely_equivalent_values(
                    ancestor_node.effective_command_value(command).as_ref(),
                    new_value.as_ref(),
                )
            {
                ancestor_list.push(ancestor.clone());
                current_ancestor = ancestor_node.GetParentElement();
                continue;
            }
            break;
        }
        let Some(last_ancestor) = ancestor_list.last() else {
            // Step 7. If ancestor list is empty, abort this algorithm.
            return;
        };
        // Step 8. Let propagated value be the specified command value of command on the last member of ancestor list.
        let mut propagated_value = last_ancestor.specified_command_value(command);
        // Step 9. If propagated value is null and is not equal to new value, abort this algorithm.
        if propagated_value.is_none() && new_value.is_some() {
            return;
        }
        // Step 10. If the effective command value of command is not loosely equivalent to new value on the parent
        // of the last member of ancestor list, and new value is not null, abort this algorithm.
        if new_value.is_some() &&
            !last_ancestor
                .upcast::<Node>()
                .GetParentNode()
                .is_some_and(|last_ancestor| {
                    command.are_loosely_equivalent_values(
                        last_ancestor.effective_command_value(command).as_ref(),
                        new_value.as_ref(),
                    )
                })
        {
            return;
        }
        // Step 11. While ancestor list is not empty:
        let mut ancestor_list_iter = ancestor_list.iter().rev().peekable();
        while let Some(current_ancestor) = ancestor_list_iter.next() {
            let current_ancestor_node = current_ancestor.upcast::<Node>();
            // Step 11.1. Let current ancestor be the last member of ancestor list.
            // Step 11.2. Remove the last member from ancestor list.
            //
            // Both of these steps done by iterating and reversing the iterator

            // Step 11.3. If the specified command value of current ancestor for command is not null, set propagated value to that value.
            let command_value = current_ancestor.specified_command_value(command);
            let has_command_value = command_value.is_some();
            propagated_value = command_value.or(propagated_value);
            // Step 11.4. Let children be the children of current ancestor.
            let children = current_ancestor_node.children();
            // Step 11.5. If the specified command value of current ancestor for command is not null, clear the value of current ancestor.
            if has_command_value {
                if let Some(html_element) = current_ancestor.downcast::<HTMLElement>() {
                    html_element.clear_the_value(cx, command);
                }
            }
            // Step 11.6. For every child in children:
            for child in children {
                // Step 11.6.1. If child is node, continue with the next child.
                if *child == *self {
                    continue;
                }
                // Step 11.6.2. If child is an Element whose specified command value for command is neither null
                // nor equivalent to propagated value, continue with the next child.
                if let Some(child_element) = child.downcast::<Element>() {
                    let specified_value = child_element.specified_command_value(command);
                    if specified_value.is_some() &&
                        !command.are_equivalent_values(
                            specified_value.as_ref(),
                            propagated_value.as_ref(),
                        )
                    {
                        continue;
                    }
                }

                // Step 11.6.3. If child is the last member of ancestor list, continue with the next child.
                //
                // Since we had to remove the last member in step 11.2, if we now peek at the next possible
                // value, we essentially have the "last member after removal"
                if ancestor_list_iter
                    .peek()
                    .is_some_and(|ancestor| *ancestor.upcast::<Node>() == *child)
                {
                    continue;
                }
                // step 11.6.4. Force the value of child, with command as in this algorithm and new value equal to propagated value.
                child.force_the_value(cx, command, propagated_value.as_ref());
            }
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#force-the-value>
    pub(crate) fn force_the_value(
        &self,
        cx: &mut js::context::JSContext,
        command: &CommandName,
        new_value: Option<&DOMString>,
    ) {
        // Step 1. Let command be the current command.
        //
        // That's command

        // Step 2. If node's parent is null, abort this algorithm.
        if self.GetParentNode().is_none() {
            return;
        }
        // Step 3. If new value is null, abort this algorithm.
        let Some(new_value) = new_value else {
            return;
        };
        // Step 4. If node is an allowed child of "span":
        if is_allowed_child(
            NodeOrString::Node(DomRoot::from_ref(self)),
            NodeOrString::String("span".to_owned()),
        ) {
            // Step 4.1. Reorder modifiable descendants of node's previousSibling.
            // TODO
            // Step 4.2. Reorder modifiable descendants of node's nextSibling.
            // TODO
            // Step 4.3. Wrap the one-node list consisting of node,
            // with sibling criteria returning true for a simple modifiable element whose
            // specified command value is equivalent to new value and whose effective command value
            // is loosely equivalent to new value and false otherwise,
            // and with new parent instructions returning null.
            wrap_node_list(
                cx,
                vec![DomRoot::from_ref(self)],
                |sibling| {
                    sibling
                        .downcast::<Element>()
                        .is_some_and(|sibling_element| {
                            sibling_element.is_simple_modifiable_element() &&
                                command.are_equivalent_values(
                                    sibling_element.specified_command_value(command).as_ref(),
                                    Some(new_value),
                                ) &&
                                command.are_loosely_equivalent_values(
                                    sibling.effective_command_value(command).as_ref(),
                                    Some(new_value),
                                )
                        })
                },
                || None,
            );
        }
        // Step 5. If node is invisible, abort this algorithm.
        if self.is_invisible() {
            return;
        }
        // Step 6. If the effective command value of command is loosely equivalent to new value on node, abort this algorithm.
        if command.are_loosely_equivalent_values(
            self.effective_command_value(command).as_ref(),
            Some(new_value),
        ) {
            return;
        }
        // Step 7. If node is not an allowed child of "span":
        if !is_allowed_child(
            NodeOrString::Node(DomRoot::from_ref(self)),
            NodeOrString::String("span".to_owned()),
        ) {
            for child in self.children() {
                // Step 7.1. Let children be all children of node, omitting any that are Elements whose
                // specified command value for command is neither null nor equivalent to new value.
                if let Some(child_element) = child.downcast::<Element>() {
                    let specified_value = child_element.specified_command_value(command);
                    if specified_value.is_some() &&
                        !command.are_equivalent_values(specified_value.as_ref(), Some(new_value))
                    {
                        continue;
                    }
                }
                // Step 7.2. Force the value of each node in children,
                // with command and new value as in this invocation of the algorithm.
                child.force_the_value(cx, command, Some(new_value));
            }
            // Step 7.3. Abort this algorithm.
            return;
        }
        // Step 8. If the effective command value of command is loosely equivalent to new value on node, abort this algorithm.
        if command.are_loosely_equivalent_values(
            self.effective_command_value(command).as_ref(),
            Some(new_value),
        ) {
            return;
        }
        // Step 9. Let new parent be null.
        let mut new_parent = None;
        let document = self.owner_document();
        let css_styling_flag = document.css_styling_flag();
        // Step 10. If the CSS styling flag is false:
        // TODO
        match command {
            // Step 11. If command is "createLink" or "unlink":
            // TODO
            // Step 12. If command is "fontSize"; and new value is one of
            // "x-small", "small", "medium", "large", "x-large", "xx-large", or "xxx-large";
            // and either the CSS styling flag is false, or new value is "xxx-large":
            // let new parent be the result of calling createElement("font") on the ownerDocument of node,
            // then set the size attribute of new parent to the number from the following table based on new value:
            CommandName::FontSize => {
                if !css_styling_flag || new_value == "xxx-large" {
                    let size = match &*new_value.str() {
                        "x-small" => 1,
                        "small" => 2,
                        "medium" => 3,
                        "large" => 4,
                        "x-large" => 5,
                        "xx-large" => 6,
                        "xxx-large" => 7,
                        _ => 0,
                    };

                    if size > 0 {
                        let new_font_element = document.create_element(cx, "font");
                        new_font_element.set_int_attribute(
                            &local_name!("size"),
                            size,
                            CanGc::from_cx(cx),
                        );
                        new_parent = Some(new_font_element);
                    }
                }
            },
            CommandName::Subscript | CommandName::Superscript => {
                // Step 13. If command is "subscript" or "superscript" and new value is "subscript",
                // let new parent be the result of calling createElement("sub") on the ownerDocument of node.
                if new_value == "subscript" {
                    new_parent = Some(document.create_element(cx, "sub"));
                }
                // Step 14. If command is "subscript" or "superscript" and new value is "superscript",
                // let new parent be the result of calling createElement("sup") on the ownerDocument of node.
                if new_value == "superscript" {
                    new_parent = Some(document.create_element(cx, "sup"));
                }
            },
            _ => {},
        }
        // Step 15. If new parent is null, let new parent be the result of calling createElement("span") on the ownerDocument of node.
        let new_parent = new_parent.unwrap_or_else(|| document.create_element(cx, "span"));
        // Step 16. Insert new parent in node's parent before node.
        if self
            .GetParentNode()
            .expect("Must always have a parent")
            .InsertBefore(cx, new_parent.upcast(), Some(self))
            .is_err()
        {
            unreachable!("Must always be able to insert");
        }
        // Step 17. If the effective command value of command for new parent is not loosely equivalent to new value,
        // and the relevant CSS property for command is not null,
        // set that CSS property of new parent to new value (if the new value would be valid).
        if !command.are_loosely_equivalent_values(
            new_parent
                .upcast::<Node>()
                .effective_command_value(command)
                .as_ref(),
            Some(new_value),
        ) {
            if let Some(css_property) = command.relevant_css_property() {
                css_property.set_for_element(
                    cx,
                    new_parent
                        .downcast::<HTMLElement>()
                        .expect("Must always create a HTML element"),
                    new_value.clone(),
                );
            }
        }
        // Step 18. If command is "strikethrough", and new value is "line-through",
        // and the effective command value of "strikethrough" for new parent is not "line-through",
        // set the "text-decoration" property of new parent to "line-through".
        // TODO
        // Step 19. If command is "underline", and new value is "underline",
        // and the effective command value of "underline" for new parent is not "underline",
        // set the "text-decoration" property of new parent to "underline".
        // TODO
        // Step 20. Append node to new parent as its last child, preserving ranges.
        let new_parent = new_parent.upcast::<Node>();
        move_preserving_ranges(cx, self, |cx| new_parent.AppendChild(cx, self));
        // Step 21. If node is an Element and the effective command value of command for node is not loosely equivalent to new value:
        if self.is::<Element>() &&
            !command.are_loosely_equivalent_values(
                self.effective_command_value(command).as_ref(),
                Some(new_value),
            )
        {
            // Step 21.1. Insert node into the parent of new parent before new parent, preserving ranges.
            let parent_of_new_parent = new_parent.GetParentNode().expect("Must have a parent");
            move_preserving_ranges(cx, self, |cx| {
                parent_of_new_parent.InsertBefore(cx, self, Some(new_parent))
            });
            // Step 21.2. Remove new parent from its parent.
            new_parent.remove_self(cx);
            // Step 21.3. Let children be all children of node,
            // omitting any that are Elements whose specified command value for command is neither null nor equivalent to new value.
            for child in self.children() {
                if child.downcast::<Element>().is_some_and(|child_element| {
                    let specified_command_value = child_element.specified_command_value(command);
                    specified_command_value.is_some() &&
                        !command.are_equivalent_values(
                            specified_command_value.as_ref(),
                            Some(new_value),
                        )
                }) {
                    continue;
                }
                // Step 21.4. Force the value of each node in children,
                // with command and new value as in this invocation of the algorithm.
                child.force_the_value(cx, command, Some(new_value));
            }
        }
    }
}

pub(crate) trait NodeExecCommandSupport {
    fn same_editing_host(&self, other: &Node) -> bool;
    fn is_block_node(&self) -> bool;
    fn is_inline_node(&self) -> bool;
    fn block_node_of(&self) -> Option<DomRoot<Node>>;
    fn is_visible(&self) -> bool;
    fn is_invisible(&self) -> bool;
    fn is_formattable(&self) -> bool;
    fn is_block_start_point(&self, offset: usize) -> bool;
    fn is_block_end_point(&self, offset: u32) -> bool;
    fn is_block_boundary_point(&self, offset: u32) -> bool;
    fn is_collapsed_block_prop(&self) -> bool;
    fn follows_a_line_break(&self) -> bool;
    fn precedes_a_line_break(&self) -> bool;
    fn canonical_space_sequence(
        n: usize,
        non_breaking_start: bool,
        non_breaking_end: bool,
    ) -> String;
    fn canonicalize_whitespace(&self, offset: u32, fix_collapsed_space: bool);
    fn remove_extraneous_line_breaks_before(&self, cx: &mut js::context::JSContext);
    fn remove_extraneous_line_breaks_at_the_end_of(&self, cx: &mut js::context::JSContext);
    fn remove_extraneous_line_breaks_from(&self, cx: &mut js::context::JSContext);
    fn remove_preserving_its_descendants(&self, cx: &mut js::context::JSContext);
    fn effective_command_value(&self, command: &CommandName) -> Option<DOMString>;
}

impl NodeExecCommandSupport for Node {
    /// <https://w3c.github.io/editing/docs/execCommand/#in-the-same-editing-host>
    fn same_editing_host(&self, other: &Node) -> bool {
        // > Two nodes are in the same editing host if the editing host of the first is non-null and the same as the editing host of the second.
        self.editing_host_of()
            .is_some_and(|editing_host| other.editing_host_of() == Some(editing_host))
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#block-node>
    fn is_block_node(&self) -> bool {
        // > A block node is either an Element whose "display" property does not have resolved value "inline" or "inline-block" or "inline-table" or "none",
        if self
            .downcast::<Element>()
            .and_then(Element::resolved_display_value)
            .is_some_and(|display| {
                display != DisplayOutside::Inline && display != DisplayOutside::None
            })
        {
            return true;
        }
        // > or a document, or a DocumentFragment.
        matches!(
            self.type_id(),
            NodeTypeId::Document(_) | NodeTypeId::DocumentFragment(_)
        )
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#inline-node>
    fn is_inline_node(&self) -> bool {
        // > An inline node is a node that is not a block node.
        !self.is_block_node()
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#block-node-of>
    fn block_node_of(&self) -> Option<DomRoot<Node>> {
        let mut node = DomRoot::from_ref(self);

        loop {
            // Step 1. While node is an inline node, set node to its parent.
            if node.is_inline_node() {
                node = node.GetParentNode()?;
                continue;
            }
            // Step 2. Return node.
            return Some(node);
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#visible>
    fn is_visible(&self) -> bool {
        for parent in self.inclusive_ancestors(ShadowIncluding::No) {
            // > excluding any node with an inclusive ancestor Element whose "display" property has resolved value "none".
            if parent
                .downcast::<Element>()
                .and_then(Element::resolved_display_value)
                .is_some_and(|display| display == DisplayOutside::None)
            {
                return false;
            }
        }
        // > Something is visible if it is a node that either is a block node,
        if self.is_block_node() {
            return true;
        }
        // > or a Text node that is not a collapsed whitespace node,
        if self
            .downcast::<Text>()
            .is_some_and(|text| !text.is_collapsed_whitespace_node())
        {
            return true;
        }
        // > or an img, or a br that is not an extraneous line break, or any node with a visible descendant;
        if self.is::<HTMLImageElement>() {
            return true;
        }
        if self
            .downcast::<HTMLBRElement>()
            .is_some_and(|br| !br.is_extraneous_line_break())
        {
            return true;
        }
        for child in self.children() {
            if child.is_visible() {
                return true;
            }
        }
        false
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#invisible>
    fn is_invisible(&self) -> bool {
        // > Something is invisible if it is a node that is not visible.
        !self.is_visible()
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#formattable-node>
    fn is_formattable(&self) -> bool {
        // > A formattable node is an editable visible node that is either a Text node, an img, or a br.
        self.is_editable() &&
            self.is_visible() &&
            (self.is::<Text>() || self.is::<HTMLImageElement>() || self.is::<HTMLBRElement>())
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#block-start-point>
    fn is_block_start_point(&self, offset: usize) -> bool {
        // > A boundary point (node, offset) is a block start point if either node's parent is null and offset is zero;
        if offset == 0 {
            return self.GetParentNode().is_none();
        }
        // > or node has a child with index offset − 1, and that child is either a visible block node or a visible br.
        self.children().nth(offset - 1).is_some_and(|child| {
            child.is_visible() && (child.is_block_node() || child.is::<HTMLBRElement>())
        })
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#block-end-point>
    fn is_block_end_point(&self, offset: u32) -> bool {
        // > A boundary point (node, offset) is a block end point if either node's parent is null and offset is node's length;
        if self.GetParentNode().is_none() && offset == self.len() {
            return true;
        }
        // > or node has a child with index offset, and that child is a visible block node.
        self.children()
            .nth(offset as usize)
            .is_some_and(|child| child.is_visible() && child.is_block_node())
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#block-boundary-point>
    fn is_block_boundary_point(&self, offset: u32) -> bool {
        // > A boundary point is a block boundary point if it is either a block start point or a block end point.
        self.is_block_start_point(offset as usize) || self.is_block_end_point(offset)
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#collapsed-block-prop>
    fn is_collapsed_block_prop(&self) -> bool {
        // > A collapsed block prop is either a collapsed line break that is not an extraneous line break,

        // TODO: Check for collapsed line break
        if self
            .downcast::<HTMLBRElement>()
            .is_some_and(|br| !br.is_extraneous_line_break())
        {
            return true;
        }
        // > or an Element that is an inline node and whose children are all either invisible or collapsed block props
        if !self.is::<Element>() {
            return false;
        };
        if !self.is_inline_node() {
            return false;
        }
        let mut at_least_one_collapsed_block_prop = false;
        for child in self.children() {
            if child.is_collapsed_block_prop() {
                at_least_one_collapsed_block_prop = true;
                continue;
            }
            if child.is_invisible() {
                continue;
            }

            return false;
        }
        // > and that has at least one child that is a collapsed block prop.
        at_least_one_collapsed_block_prop
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#follows-a-line-break>
    fn follows_a_line_break(&self) -> bool {
        // Step 1. Let offset be zero.
        let mut offset = 0;
        // Step 2. While (node, offset) is not a block boundary point:
        let mut node = DomRoot::from_ref(self);
        while !node.is_block_boundary_point(offset) {
            // Step 2.2. If offset is zero or node has no children, set offset to node's index, then set node to its parent.
            if offset == 0 || node.children_count() == 0 {
                offset = node.index();
                node = node.GetParentNode().expect("Must always have a parent");
                continue;
            }
            // Step 2.1. If node has a visible child with index offset minus one, return false.
            let child = node.children().nth(offset as usize - 1);
            let Some(child) = child else {
                return false;
            };
            if child.is_visible() {
                return false;
            }
            // Step 2.3. Otherwise, set node to its child with index offset minus one, then set offset to node's length.
            node = child;
            offset = node.len();
        }
        // Step 3. Return true.
        true
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#precedes-a-line-break>
    fn precedes_a_line_break(&self) -> bool {
        let mut node = DomRoot::from_ref(self);
        // Step 1. Let offset be node's length.
        let mut offset = node.len();
        // Step 2. While (node, offset) is not a block boundary point:
        while !node.is_block_boundary_point(offset) {
            // Step 2.1. If node has a visible child with index offset, return false.
            if node
                .children()
                .nth(offset as usize)
                .is_some_and(|child| child.is_visible())
            {
                return false;
            }
            // Step 2.2. If offset is node's length or node has no children, set offset to one plus node's index, then set node to its parent.
            if offset == node.len() || node.children_count() == 0 {
                offset = 1 + node.index();
                node = node.GetParentNode().expect("Must always have a parent");
                continue;
            }
            // Step 2.3. Otherwise, set node to its child with index offset and set offset to zero.
            let child = node.children().nth(offset as usize);
            node = match child {
                None => return false,
                Some(child) => child,
            };
            offset = 0;
        }
        // Step 3. Return true.
        true
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#canonical-space-sequence>
    fn canonical_space_sequence(
        n: usize,
        non_breaking_start: bool,
        non_breaking_end: bool,
    ) -> String {
        let mut n = n;
        // Step 1. If n is zero, return the empty string.
        if n == 0 {
            return String::new();
        }
        // Step 2. If n is one and both non-breaking start and non-breaking end are false, return a single space (U+0020).
        if n == 1 {
            if !non_breaking_start && !non_breaking_end {
                return "\u{0020}".to_owned();
            }
            // Step 3. If n is one, return a single non-breaking space (U+00A0).
            return "\u{00A0}".to_owned();
        }
        // Step 4. Let buffer be the empty string.
        let mut buffer = String::new();
        // Step 5. If non-breaking start is true, let repeated pair be U+00A0 U+0020. Otherwise, let it be U+0020 U+00A0.
        let repeated_pair = if non_breaking_start {
            "\u{00A0}\u{0020}"
        } else {
            "\u{0020}\u{00A0}"
        };
        // Step 6. While n is greater than three, append repeated pair to buffer and subtract two from n.
        while n > 3 {
            buffer.push_str(repeated_pair);
            n -= 2;
        }
        // Step 7. If n is three, append a three-code unit string to buffer depending on non-breaking start and non-breaking end:
        if n == 3 {
            buffer.push_str(match (non_breaking_start, non_breaking_end) {
                (false, false) => "\u{0020}\u{00A0}\u{0020}",
                (true, false) => "\u{00A0}\u{00A0}\u{0020}",
                (false, true) => "\u{0020}\u{00A0}\u{00A0}",
                (true, true) => "\u{00A0}\u{0020}\u{00A0}",
            });
        } else {
            // Step 8. Otherwise, append a two-code unit string to buffer depending on non-breaking start and non-breaking end:
            buffer.push_str(match (non_breaking_start, non_breaking_end) {
                (false, false) | (true, false) => "\u{00A0}\u{0020}",
                (false, true) => "\u{0020}\u{00A0}",
                (true, true) => "\u{00A0}\u{00A0}",
            });
        }
        // Step 9. Return buffer.
        buffer
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#canonicalize-whitespace>
    fn canonicalize_whitespace(&self, offset: u32, fix_collapsed_space: bool) {
        // Step 1. If node is neither editable nor an editing host, abort these steps.
        if !self.is_editable_or_editing_host() {
            return;
        }
        // Step 2. Let start node equal node and let start offset equal offset.
        let mut start_node = DomRoot::from_ref(self);
        let mut start_offset = offset;
        // Step 3. Repeat the following steps:
        loop {
            // Step 3.1. If start node has a child in the same editing host with index start offset minus one,
            // set start node to that child, then set start offset to start node's length.
            if start_offset > 0 {
                let child = start_node.children().nth(start_offset as usize - 1);
                if let Some(child) = child {
                    if start_node.same_editing_host(&child) {
                        start_node = child;
                        start_offset = start_node.len();
                        continue;
                    }
                };
            }
            // Step 3.2. Otherwise, if start offset is zero and start node does not follow a line break
            // and start node's parent is in the same editing host, set start offset to start node's index,
            // then set start node to its parent.
            if start_offset == 0 && !start_node.follows_a_line_break() {
                if let Some(parent) = start_node.GetParentNode() {
                    if parent.same_editing_host(&start_node) {
                        start_offset = start_node.index();
                        start_node = parent;
                    }
                }
            }
            // Step 3.3. Otherwise, if start node is a Text node and its parent's resolved
            // value for "white-space" is neither "pre" nor "pre-wrap" and start offset is not zero
            // and the (start offset − 1)st code unit of start node's data is a space (0x0020) or
            // non-breaking space (0x00A0), subtract one from start offset.
            if start_offset != 0 &&
                start_node.downcast::<Text>().is_some_and(|text| {
                    text.has_whitespace_and_has_parent_with_whitespace_preserve(
                        start_offset - 1,
                        &[&'\u{0020}', &'\u{00A0}'],
                    )
                })
            {
                start_offset -= 1;
            }
            // Step 3.4. Otherwise, break from this loop.
            break;
        }
        // Step 4. Let end node equal start node and end offset equal start offset.
        let mut end_node = start_node.clone();
        let mut end_offset = start_offset;
        // Step 5. Let length equal zero.
        let mut length = 0;
        // Step 6. Let collapse spaces be true if start offset is zero and start node follows a line break, otherwise false.
        let mut collapse_spaces = start_offset == 0 && start_node.follows_a_line_break();
        // Step 7. Repeat the following steps:
        loop {
            // Step 7.1. If end node has a child in the same editing host with index end offset,
            // set end node to that child, then set end offset to zero.
            if let Some(child) = end_node.children().nth(end_offset as usize) {
                if child.same_editing_host(&end_node) {
                    end_node = child;
                    end_offset = 0;
                    continue;
                }
            }
            // Step 7.2. Otherwise, if end offset is end node's length
            // and end node does not precede a line break
            // and end node's parent is in the same editing host,
            // set end offset to one plus end node's index, then set end node to its parent.
            if end_offset == end_node.len() && !end_node.precedes_a_line_break() {
                if let Some(parent) = end_node.GetParentNode() {
                    if parent.same_editing_host(&end_node) {
                        end_offset = 1 + end_node.index();
                        end_node = parent;
                    }
                }
                continue;
            }
            // Step 7.3. Otherwise, if end node is a Text node and its parent's resolved value for "white-space"
            // is neither "pre" nor "pre-wrap"
            // and end offset is not end node's length and the end offsetth code unit of end node's data
            // is a space (0x0020) or non-breaking space (0x00A0):
            if let Some(text) = end_node.downcast::<Text>() {
                if text.has_whitespace_and_has_parent_with_whitespace_preserve(
                    end_offset,
                    &[&'\u{0020}', &'\u{00A0}'],
                ) {
                    // Step 7.3.1. If fix collapsed space is true, and collapse spaces is true,
                    // and the end offsetth code unit of end node's data is a space (0x0020):
                    // call deleteData(end offset, 1) on end node, then continue this loop from the beginning.
                    let has_space_at_offset = text
                        .data()
                        .chars()
                        .nth(end_offset as usize)
                        .is_some_and(|c| c == '\u{0020}');
                    if fix_collapsed_space && collapse_spaces && has_space_at_offset {
                        if text
                            .upcast::<CharacterData>()
                            .DeleteData(end_offset, 1)
                            .is_err()
                        {
                            unreachable!("Invalid deletion for character at end offset");
                        }
                        continue;
                    }
                    // Step 7.3.2. Set collapse spaces to true if the end offsetth code unit of
                    // end node's data is a space (0x0020), false otherwise.
                    collapse_spaces = text
                        .data()
                        .chars()
                        .nth(end_offset as usize)
                        .is_some_and(|c| c == '\u{0020}');
                    // Step 7.3.3. Add one to end offset.
                    end_offset += 1;
                    // Step 7.3.4. Add one to length.
                    length += 1;
                    continue;
                }
            }
            // Step 7.4. Otherwise, break from this loop.
            break;
        }
        // Step 8. If fix collapsed space is true, then while (start node, start offset)
        // is before (end node, end offset):
        if fix_collapsed_space {
            while bp_position(&start_node, start_offset, &end_node, end_offset) ==
                Some(Ordering::Less)
            {
                // Step 8.1. If end node has a child in the same editing host with index end offset − 1,
                // set end node to that child, then set end offset to end node's length.
                if end_offset > 0 {
                    if let Some(child) = end_node.children().nth(end_offset as usize - 1) {
                        if child.same_editing_host(&end_node) {
                            end_node = child;
                            end_offset = end_node.len();
                            continue;
                        }
                    }
                }
                // Step 8.2. Otherwise, if end offset is zero and end node's parent is in the same editing host,
                // set end offset to end node's index, then set end node to its parent.
                if let Some(parent) = end_node.GetParentNode() {
                    if end_offset == 0 && parent.same_editing_host(&end_node) {
                        end_offset = end_node.index();
                        end_node = parent;
                        continue;
                    }
                }
                // Step 8.3. Otherwise, if end node is a Text node and its parent's resolved value for "white-space"
                // is neither "pre" nor "pre-wrap"
                // and end offset is end node's length and the last code unit of end node's data
                // is a space (0x0020) and end node precedes a line break:
                if let Some(text) = end_node.downcast::<Text>() {
                    if text.has_whitespace_and_has_parent_with_whitespace_preserve(
                        text.data().len() as u32,
                        &[&'\u{0020}'],
                    ) && end_node.precedes_a_line_break()
                    {
                        // Step 8.3.1. Subtract one from end offset.
                        end_offset -= 1;
                        // Step 8.3.2. Subtract one from length.
                        length -= 1;
                        // Step 8.3.3. Call deleteData(end offset, 1) on end node.
                        if text
                            .upcast::<CharacterData>()
                            .DeleteData(end_offset, 1)
                            .is_err()
                        {
                            unreachable!("Invalid deletion for character at end offset");
                        }
                        continue;
                    }
                }
                // Step 8.4. Otherwise, break from this loop.
                break;
            }
        }
        // Step 9. Let replacement whitespace be the canonical space sequence of length length.
        // non-breaking start is true if start offset is zero and start node follows a line break, and false otherwise.
        // non-breaking end is true if end offset is end node's length and end node precedes a line break, and false otherwise.
        let replacement_whitespace = Node::canonical_space_sequence(
            length,
            start_offset == 0 && start_node.follows_a_line_break(),
            end_offset == end_node.len() && end_node.precedes_a_line_break(),
        );
        let mut replacement_whitespace_chars = replacement_whitespace.chars();
        // Step 10. While (start node, start offset) is before (end node, end offset):
        while bp_position(&start_node, start_offset, &end_node, end_offset) == Some(Ordering::Less)
        {
            // Step 10.1. If start node has a child with index start offset, set start node to that child, then set start offset to zero.
            if let Some(child) = start_node.children().nth(start_offset as usize) {
                start_node = child;
                start_offset = 0;
                continue;
            }
            // Step 10.2. Otherwise, if start node is not a Text node or if start offset is start node's length,
            // set start offset to one plus start node's index, then set start node to its parent.
            let start_node_as_text = start_node.downcast::<Text>();
            if start_node_as_text.is_none() || start_offset == start_node.len() {
                start_offset = 1 + start_node.index();
                start_node = start_node
                    .GetParentNode()
                    .expect("Must always have a parent");
                continue;
            }
            let start_node_as_text =
                start_node_as_text.expect("Already verified none in previous statement");
            // Step 10.3. Otherwise:
            // Step 10.3.1. Remove the first code unit from replacement whitespace, and let element be that code unit.
            if let Some(element) = replacement_whitespace_chars.next() {
                // Step 10.3.2. If element is not the same as the start offsetth code unit of start node's data:
                if start_node_as_text.data().chars().nth(start_offset as usize) != Some(element) {
                    let character_data = start_node_as_text.upcast::<CharacterData>();
                    // Step 10.3.2.1. Call insertData(start offset, element) on start node.
                    if character_data
                        .InsertData(start_offset, element.to_string().into())
                        .is_err()
                    {
                        unreachable!("Invalid insertion for character at start offset");
                    }
                    // Step 10.3.2.2. Call deleteData(start offset + 1, 1) on start node.
                    if character_data.DeleteData(start_offset + 1, 1).is_err() {
                        unreachable!("Invalid deletion for character at start offset + 1");
                    }
                }
            }
            // Step 10.3.3. Add one to start offset.
            start_offset += 1;
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#remove-extraneous-line-breaks-before>
    fn remove_extraneous_line_breaks_before(&self, cx: &mut js::context::JSContext) {
        let parent = self.GetParentNode();
        // Step 1. Let ref be the previousSibling of node.
        let Some(mut ref_) = self.GetPreviousSibling() else {
            // Step 2. If ref is null, abort these steps.
            return;
        };
        // Step 3. While ref has children, set ref to its lastChild.
        while let Some(last_child) = ref_.children().last() {
            ref_ = last_child;
        }
        // Step 4. While ref is invisible but not an extraneous line break,
        // and ref does not equal node's parent, set ref to the node before it in tree order.
        loop {
            if ref_.is_invisible() &&
                ref_.downcast::<HTMLBRElement>()
                    .is_none_or(|br| !br.is_extraneous_line_break())
            {
                if let Some(parent) = parent.as_ref() {
                    if ref_ != *parent {
                        ref_ = match ref_.preceding_nodes(parent).nth(0) {
                            None => break,
                            Some(node) => node,
                        };
                        continue;
                    }
                }
            }
            break;
        }
        // Step 5. If ref is an editable extraneous line break, remove it from its parent.
        if ref_.is_editable() &&
            ref_.downcast::<HTMLBRElement>()
                .is_some_and(|br| br.is_extraneous_line_break())
        {
            assert!(ref_.has_parent());
            ref_.remove_self(cx);
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#remove-extraneous-line-breaks-at-the-end-of>
    fn remove_extraneous_line_breaks_at_the_end_of(&self, cx: &mut js::context::JSContext) {
        // Step 1. Let ref be node.
        let mut ref_ = DomRoot::from_ref(self);
        // Step 2. While ref has children, set ref to its lastChild.
        while let Some(last_child) = ref_.children().last() {
            ref_ = last_child;
        }
        // Step 3. While ref is invisible but not an extraneous line break, and ref does not equal node,
        // set ref to the node before it in tree order.
        loop {
            if ref_.is_invisible() &&
                *ref_ != *self &&
                ref_.downcast::<HTMLBRElement>()
                    .is_none_or(|br| !br.is_extraneous_line_break())
            {
                if let Some(parent_of_ref) = ref_.GetParentNode() {
                    ref_ = match ref_.preceding_nodes(&parent_of_ref).nth(0) {
                        None => break,
                        Some(node) => node,
                    };
                    continue;
                }
            }
            break;
        }
        // Step 4. If ref is an editable extraneous line break:
        if ref_.is_editable() &&
            ref_.downcast::<HTMLBRElement>()
                .is_some_and(|br| br.is_extraneous_line_break())
        {
            // Step 4.1. While ref's parent is editable and invisible, set ref to its parent.
            loop {
                if let Some(parent) = ref_.GetParentNode() {
                    if parent.is_editable() && parent.is_invisible() {
                        ref_ = parent;
                        continue;
                    }
                }
                break;
            }
            // Step 4.2. Remove ref from its parent.
            assert!(ref_.has_parent());
            ref_.remove_self(cx);
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#remove-extraneous-line-breaks-from>
    fn remove_extraneous_line_breaks_from(&self, cx: &mut js::context::JSContext) {
        // > To remove extraneous line breaks from a node, first remove extraneous line breaks before it,
        // > then remove extraneous line breaks at the end of it.
        self.remove_extraneous_line_breaks_before(cx);
        self.remove_extraneous_line_breaks_at_the_end_of(cx);
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#preserving-its-descendants>
    fn remove_preserving_its_descendants(&self, cx: &mut js::context::JSContext) {
        // > To remove a node node while preserving its descendants,
        // > split the parent of node's children if it has any.
        // > If it has no children, instead remove it from its parent.
        if self.children_count() == 0 {
            assert!(self.has_parent());
            self.remove_self(cx);
        } else {
            rooted_vec!(let children <- self.children().map(|child| DomRoot::as_traced(&child)));
            split_the_parent(cx, children.r());
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#effective-command-value>
    fn effective_command_value(&self, command: &CommandName) -> Option<DOMString> {
        // Step 1. If neither node nor its parent is an Element, return null.
        // Step 2. If node is not an Element, return the effective command value of its parent for command.
        let Some(element) = self.downcast::<Element>() else {
            return self
                .GetParentElement()
                .and_then(|parent| parent.upcast::<Node>().effective_command_value(command));
        };
        match command {
            // Step 3. If command is "createLink" or "unlink":
            CommandName::CreateLink | CommandName::Unlink => {
                // Step 3.1. While node is not null, and is not an a element that has an href attribute, set node to its parent.
                let mut current_node = Some(DomRoot::from_ref(self));
                while let Some(node) = current_node {
                    if let Some(anchor_value) =
                        node.downcast::<HTMLAnchorElement>().and_then(|anchor| {
                            anchor
                                .upcast::<Element>()
                                .get_attribute(&local_name!("href"))
                        })
                    {
                        // Step 3.3. Return the value of node's href attribute.
                        return Some(DOMString::from(&**anchor_value.value()));
                    }
                    current_node = node.GetParentNode();
                }
                // Step 3.2. If node is null, return null.
                None
            },
            // Step 4. If command is "backColor" or "hiliteColor":
            CommandName::BackColor | CommandName::HiliteColor => {
                // Step 4.1. While the resolved value of "background-color" on node is any fully transparent value,
                // and node's parent is an Element, set node to its parent.
                // TODO
                // Step 4.2. Return the resolved value of "background-color" for node.
                // TODO
                None
            },
            // Step 5. If command is "subscript" or "superscript":
            CommandName::Subscript | CommandName::Superscript => {
                // Step 5.1. Let affected by subscript and affected by superscript be two boolean variables,
                // both initially false.
                let mut affected_by_subscript = false;
                let mut affected_by_superscript = false;
                // Step 5.2. While node is an inline node:
                let mut current_node = Some(DomRoot::from_ref(self));
                while let Some(node) = current_node {
                    if !node.is_inline_node() {
                        break;
                    }
                    // Step 5.2.1. If node is a sub, set affected by subscript to true.
                    if *element.local_name() == local_name!("sub") {
                        affected_by_subscript = true;
                    } else if *element.local_name() == local_name!("sup") {
                        // Step 5.2.2. Otherwise, if node is a sup, set affected by superscript to true.
                        affected_by_superscript = true;
                    }
                    // Step 5.2.3. Set node to its parent.
                    current_node = node.GetParentNode();
                }
                Some(match (affected_by_subscript, affected_by_superscript) {
                    // Step 5.3. If affected by subscript and affected by superscript are both true,
                    // return the string "mixed".
                    (true, true) => "mixed".into(),
                    // Step 5.4. If affected by subscript is true, return "subscript".
                    (true, false) => "subscript".into(),
                    // Step 5.5. If affected by superscript is true, return "superscript".
                    (false, true) => "superscript".into(),
                    // Step 5.6. Return null.
                    (false, false) => return None,
                })
            },
            // Step 6. If command is "strikethrough",
            // and the "text-decoration" property of node or any of its ancestors has resolved value containing "line-through",
            // return "line-through". Otherwise, return null.
            // TODO
            CommandName::Strikethrough => None,
            // Step 7. If command is "underline",
            // and the "text-decoration" property of node or any of its ancestors has resolved value containing "underline",
            // return "underline". Otherwise, return null.
            // TODO
            CommandName::Underline => None,
            // Step 8. Return the resolved value for node of the relevant CSS property for command.
            _ => command.resolved_value_for_node(element),
        }
    }
}

pub(crate) trait ContentEditableRange {
    fn handle_focus_state_for_contenteditable(&self, can_gc: CanGc);
}

impl ContentEditableRange for HTMLElement {
    /// There is no specification for this implementation. Instead, it is
    /// reverse-engineered based on the WPT test
    /// /selection/contenteditable/initial-selection-on-focus.tentative.html
    fn handle_focus_state_for_contenteditable(&self, can_gc: CanGc) {
        if !self.is_editing_host() {
            return;
        }
        let document = self.owner_document();
        let Some(selection) = document.GetSelection(can_gc) else {
            return;
        };
        let range = self
            .upcast::<Element>()
            .ensure_contenteditable_selection_range(&document, can_gc);
        // If the current range is already associated with this contenteditable
        // element, then we shouldn't do anything. This is important when focus
        // is lost and regained, but selection was changed beforehand. In that
        // case, we should maintain the selection as it were, by not creating
        // a new range.
        if selection
            .active_range()
            .is_some_and(|active| active == range)
        {
            return;
        }
        let node = self.upcast::<Node>();
        let mut selected_node = DomRoot::from_ref(node);
        let mut previous_eligible_node = DomRoot::from_ref(node);
        let mut previous_node = DomRoot::from_ref(node);
        let mut selected_offset = 0;
        for child in node.traverse_preorder(ShadowIncluding::Yes) {
            if let Some(text) = child.downcast::<Text>() {
                // Note that to consider it whitespace, it needs to take more
                // into account than simply "it has a non-whitespace" character.
                // Therefore, we need to first check if it is not a whitespace
                // node and only then can we find what the relevant character is.
                if !text.is_whitespace_node() {
                    // A node with "white-space: pre" set must select its first
                    // character, regardless if that's a whitespace character or not.
                    let is_pre_formatted_text_node = child
                        .GetParentElement()
                        .and_then(|parent| parent.style())
                        .is_some_and(|style| {
                            style.get_inherited_text().white_space_collapse ==
                                WhiteSpaceCollapse::Preserve
                        });
                    if !is_pre_formatted_text_node {
                        // If it isn't pre-formatted, then we should instead select the
                        // first non-whitespace character.
                        selected_offset = text
                            .data()
                            .find(|c: char| !c.is_whitespace())
                            .unwrap_or_default() as u32;
                    }
                    selected_node = child;
                    break;
                }
            }
            // For <input>, <textarea>, <hr> and <br> elements, we should select the previous
            // node, regardless if it was a block node or not
            if matches!(
                child.type_id(),
                NodeTypeId::Element(ElementTypeId::HTMLElement(
                    HTMLElementTypeId::HTMLInputElement,
                )) | NodeTypeId::Element(ElementTypeId::HTMLElement(
                    HTMLElementTypeId::HTMLTextAreaElement,
                )) | NodeTypeId::Element(ElementTypeId::HTMLElement(
                    HTMLElementTypeId::HTMLHRElement,
                )) | NodeTypeId::Element(ElementTypeId::HTMLElement(
                    HTMLElementTypeId::HTMLBRElement,
                ))
            ) {
                selected_node = previous_node;
                break;
            }
            // When we encounter a non-contenteditable element, we should select the previous
            // eligible node
            if child
                .downcast::<HTMLElement>()
                .is_some_and(|el| el.ContentEditable().str() == "false")
            {
                selected_node = previous_eligible_node;
                break;
            }
            // We can only select block nodes as eligible nodes for the case of non-conenteditable
            // nodes
            if child.is_block_node() {
                previous_eligible_node = child.clone();
            }
            previous_node = child;
        }
        range.set_start(&selected_node, selected_offset);
        range.set_end(&selected_node, selected_offset);
        selection.AddRange(&range);
    }
}

trait EquivalentPoint {
    fn previous_equivalent_point(&self) -> Option<(DomRoot<Node>, u32)>;
    fn next_equivalent_point(&self) -> Option<(DomRoot<Node>, u32)>;
    fn first_equivalent_point(self) -> (DomRoot<Node>, u32);
    fn last_equivalent_point(self) -> (DomRoot<Node>, u32);
}

impl EquivalentPoint for (DomRoot<Node>, u32) {
    /// <https://w3c.github.io/editing/docs/execCommand/#previous-equivalent-point>
    fn previous_equivalent_point(&self) -> Option<(DomRoot<Node>, u32)> {
        let (node, offset) = self;
        // Step 1. If node's length is zero, return null.
        let len = node.len();
        if len == 0 {
            return None;
        }
        // Step 2. If offset is 0, and node's parent is not null, and node is an inline node,
        // return (node's parent, node's index).
        if *offset == 0 && node.is_inline_node() {
            if let Some(parent) = node.GetParentNode() {
                return Some((parent, node.index()));
            }
        }
        // Step 3. If node has a child with index offset − 1, and that child's length is not zero,
        // and that child is an inline node, return (that child, that child's length).
        if *offset > 0 {
            if let Some(child) = node.children().nth(*offset as usize - 1) {
                if !child.is_empty() && child.is_inline_node() {
                    let len = child.len();
                    return Some((child, len));
                }
            }
        }

        // Step 4. Return null.
        None
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#next-equivalent-point>
    fn next_equivalent_point(&self) -> Option<(DomRoot<Node>, u32)> {
        let (node, offset) = self;
        // Step 1. If node's length is zero, return null.
        let len = node.len();
        if len == 0 {
            return None;
        }

        // Step 2.
        //
        // This step does not exist in the spec

        // Step 3. If offset is node's length, and node's parent is not null, and node is an inline node,
        // return (node's parent, 1 + node's index).
        if *offset == len && node.is_inline_node() {
            if let Some(parent) = node.GetParentNode() {
                return Some((parent, node.index() + 1));
            }
        }

        // Step 4.
        //
        // This step does not exist in the spec

        // Step 5. If node has a child with index offset, and that child's length is not zero,
        // and that child is an inline node, return (that child, 0).
        if let Some(child) = node.children().nth(*offset as usize) {
            if !child.is_empty() && child.is_inline_node() {
                return Some((child, 0));
            }
        }

        // Step 6.
        //
        // This step does not exist in the spec

        // Step 7. Return null.
        None
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#first-equivalent-point>
    fn first_equivalent_point(self) -> (DomRoot<Node>, u32) {
        let mut previous_equivalent_point = self;
        // Step 1. While (node, offset)'s previous equivalent point is not null, set (node, offset) to its previous equivalent point.
        loop {
            if let Some(next) = previous_equivalent_point.previous_equivalent_point() {
                previous_equivalent_point = next;
            } else {
                // Step 2. Return (node, offset).
                return previous_equivalent_point;
            }
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#last-equivalent-point>
    fn last_equivalent_point(self) -> (DomRoot<Node>, u32) {
        let mut next_equivalent_point = self;
        // Step 1. While (node, offset)'s next equivalent point is not null, set (node, offset) to its next equivalent point.
        loop {
            if let Some(next) = next_equivalent_point.next_equivalent_point() {
                next_equivalent_point = next;
            } else {
                // Step 2. Return (node, offset).
                return next_equivalent_point;
            }
        }
    }
}

enum BoolOrOptionalString {
    Bool(bool),
    OptionalString(Option<DOMString>),
}

impl From<Option<DOMString>> for BoolOrOptionalString {
    fn from(optional_string: Option<DOMString>) -> Self {
        Self::OptionalString(optional_string)
    }
}

impl From<bool> for BoolOrOptionalString {
    fn from(bool_: bool) -> Self {
        Self::Bool(bool_)
    }
}

struct RecordedStateOfNode {
    command: CommandName,
    value: BoolOrOptionalString,
}

impl RecordedStateOfNode {
    fn for_command_node(command: CommandName, node: &Node) -> Self {
        let value = node.effective_command_value(&command).into();
        Self { command, value }
    }
}

impl Range {
    /// <https://w3c.github.io/editing/docs/execCommand/#effectively-contained>
    fn is_effectively_contained_node(&self, node: &Node) -> bool {
        // > A node node is effectively contained in a range range if range is not collapsed,
        if self.collapsed() {
            return false;
        }
        // > and at least one of the following holds:
        // > node is range's start node, it is a Text node, and its length is different from range's start offset.
        let start_container = self.start_container();
        if *start_container == *node && node.is::<Text>() && node.len() != self.start_offset() {
            return true;
        }
        // > node is range's end node, it is a Text node, and range's end offset is not 0.
        let end_container = self.end_container();
        if *end_container == *node && node.is::<Text>() && self.end_offset() != 0 {
            return true;
        }
        // > node is contained in range.
        if self.contains(node) {
            return true;
        }
        // > node has at least one child; and all its children are effectively contained in range;
        node.children_count() > 0 && node.children().all(|child| self.is_effectively_contained_node(&child))
        // > and either range's start node is not a descendant of node or is not a Text node or range's start offset is zero;
        && (!node.is_ancestor_of(&start_container) || !start_container.is::<Text>() || self.start_offset() == 0)
        // > and either range's end node is not a descendant of node or is not a Text node or range's end offset is its end node's length.
        && (!node.is_ancestor_of(&end_container) || !end_container.is::<Text>() || self.end_offset() == end_container.len())
    }

    pub(crate) fn first_formattable_contained_node(&self) -> Option<DomRoot<Node>> {
        if self.collapsed() {
            return None;
        }

        self.CommonAncestorContainer()
            .traverse_preorder(ShadowIncluding::No)
            .find(|child| child.is_formattable() && self.is_effectively_contained_node(child))
    }

    fn for_each_effectively_contained_child<Callback: FnMut(&Node)>(&self, mut callback: Callback) {
        if self.collapsed() {
            return;
        }

        for child in self
            .CommonAncestorContainer()
            .traverse_preorder(ShadowIncluding::No)
        {
            if self.is_effectively_contained_node(&child) {
                callback(&child);
            }
        }
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#record-current-states-and-values>
    fn record_current_states_and_values(&self) -> Vec<RecordedStateOfNode> {
        // Step 1. Let overrides be a list of (string, string or boolean) ordered pairs, initially empty.
        //
        // We return the vec in one go for the relevant values

        // Step 2. Let node be the first formattable node effectively contained in the active range,
        // or null if there is none.
        let Some(node) = self.first_formattable_contained_node() else {
            // Step 3. If node is null, return overrides.
            return vec![];
        };
        // Step 8. Return overrides.
        vec![
            // Step 4. Add ("createLink", node's effective command value for "createLink") to overrides.
            RecordedStateOfNode::for_command_node(CommandName::CreateLink, &node),
            // Step 5. For each command in the list
            // "bold", "italic", "strikethrough", "subscript", "superscript", "underline", in order:
            // if node's effective command value for command is one of its inline command activated values,
            // add (command, true) to overrides, and otherwise add (command, false) to overrides.
            // TODO

            // Step 6. For each command in the list "fontName", "foreColor", "hiliteColor", in order:
            // add (command, command's value) to overrides.
            // TODO

            // Step 7. Add ("fontSize", node's effective command value for "fontSize") to overrides.
            RecordedStateOfNode::for_command_node(CommandName::FontSize, &node),
        ]
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#restore-states-and-values>
    fn restore_states_and_values(
        &self,
        cx: &mut js::context::JSContext,
        selection: &Selection,
        context_object: &Document,
        overrides: Vec<RecordedStateOfNode>,
    ) {
        // Step 1. Let node be the first formattable node effectively contained in the active range,
        // or null if there is none.
        let mut first_formattable_contained_node = self.first_formattable_contained_node();
        for override_state in overrides {
            // Step 2. If node is not null, then for each (command, override) pair in overrides, in order:
            if let Some(ref node) = first_formattable_contained_node {
                match override_state.value {
                    // Step 2.1. If override is a boolean, and queryCommandState(command)
                    // returns something different from override, take the action for command,
                    // with value equal to the empty string.
                    BoolOrOptionalString::Bool(bool_)
                        if override_state
                            .command
                            .current_state(context_object)
                            .is_some_and(|value| value != bool_) =>
                    {
                        override_state
                            .command
                            .execute(cx, context_object, selection, "".into());
                    },
                    BoolOrOptionalString::OptionalString(optional_string) => {
                        match override_state.command {
                            // Step 2.3. Otherwise, if override is a string; and command is "createLink";
                            // and either there is a value override for "createLink" that is not equal to override,
                            // or there is no value override for "createLink" and node's effective command value
                            // for "createLink" is not equal to override: take the action for "createLink", with value equal to override.
                            CommandName::CreateLink => {
                                let value_override =
                                    context_object.value_override(&CommandName::CreateLink);
                                if value_override != optional_string {
                                    CommandName::CreateLink.execute(
                                        cx,
                                        context_object,
                                        selection,
                                        optional_string.unwrap_or_default(),
                                    );
                                }
                            },
                            // Step 2.4. Otherwise, if override is a string; and command is "fontSize";
                            // and either there is a value override for "fontSize" that is not equal to override,
                            // or there is no value override for "fontSize" and node's effective command value for "fontSize"
                            // is not loosely equivalent to override:
                            CommandName::FontSize => {
                                let value_override =
                                    context_object.value_override(&CommandName::FontSize);
                                if value_override != optional_string ||
                                    (value_override.is_none() &&
                                        !CommandName::FontSize.are_loosely_equivalent_values(
                                            node.effective_command_value(&CommandName::FontSize)
                                                .as_ref(),
                                            optional_string.as_ref(),
                                        ))
                                {
                                    // Step 2.5. Convert override to an integer number of pixels,
                                    // and set override to the legacy font size for the result.
                                    let pixels = optional_string
                                        .and_then(|value| value.parse::<i32>().ok())
                                        .map(|value| {
                                            legacy_font_size_for(value as f32, context_object)
                                        })
                                        .unwrap_or("7".into());
                                    // Step 2.6. Take the action for "fontSize", with value equal to override.
                                    CommandName::FontSize.execute(
                                        cx,
                                        context_object,
                                        selection,
                                        pixels,
                                    );
                                }
                            },
                            // Step 2.2. Otherwise, if override is a string, and command is neither "createLink" nor "fontSize",
                            // and queryCommandValue(command) returns something not equivalent to override,
                            // take the action for command, with value equal to override.
                            command
                                if command.current_value(cx, context_object) != optional_string =>
                            {
                                command.execute(
                                    cx,
                                    context_object,
                                    selection,
                                    optional_string.unwrap_or_default(),
                                );
                            },
                            // Step 2.5. Otherwise, continue this loop from the beginning.
                            _ => {
                                continue;
                            },
                        }
                    },
                    // Step 2.5. Otherwise, continue this loop from the beginning.
                    _ => {
                        continue;
                    },
                }
                // Step 2.6. Set node to the first formattable node effectively contained in the active range, if there is one.
                first_formattable_contained_node = self.first_formattable_contained_node();
            } else {
                // Step 3. Otherwise, for each (command, override) pair in overrides, in order:
                // Step 3.1. If override is a boolean, set the state override for command to override.
                match override_state.value {
                    BoolOrOptionalString::Bool(bool_) => {
                        context_object.set_state_override(override_state.command, Some(bool_))
                    },
                    // Step 3.2. If override is a string, set the value override for command to override.
                    BoolOrOptionalString::OptionalString(optional_string) => {
                        context_object.set_value_override(override_state.command, optional_string)
                    },
                }
            }
        }
    }
}

#[derive(Default, PartialEq)]
pub(crate) enum SelectionDeletionBlockMerging {
    #[default]
    Merge,
    Skip,
}

#[derive(Default, PartialEq)]
pub(crate) enum SelectionDeletionStripWrappers {
    #[default]
    Strip,
}

#[derive(Default, PartialEq)]
pub(crate) enum SelectionDeleteDirection {
    #[default]
    Forward,
    Backward,
}

pub(crate) trait SelectionExecCommandSupport {
    fn delete_the_selection(
        &self,
        cx: &mut js::context::JSContext,
        context_object: &Document,
        block_merging: SelectionDeletionBlockMerging,
        strip_wrappers: SelectionDeletionStripWrappers,
        direction: SelectionDeleteDirection,
    );
    fn set_the_selection_value(
        &self,
        cx: &mut js::context::JSContext,
        new_value: Option<DOMString>,
        command: CommandName,
        context_object: &Document,
    );
}

impl SelectionExecCommandSupport for Selection {
    /// <https://w3c.github.io/editing/docs/execCommand/#delete-the-selection>
    fn delete_the_selection(
        &self,
        cx: &mut js::context::JSContext,
        context_object: &Document,
        block_merging: SelectionDeletionBlockMerging,
        strip_wrappers: SelectionDeletionStripWrappers,
        direction: SelectionDeleteDirection,
    ) {
        // Step 1. If the active range is null, abort these steps and do nothing.
        let Some(active_range) = self.active_range() else {
            return;
        };

        // Step 2. Canonicalize whitespace at the active range's start.
        active_range
            .start_container()
            .canonicalize_whitespace(active_range.start_offset(), true);

        // Step 3. Canonicalize whitespace at the active range's end.
        active_range
            .end_container()
            .canonicalize_whitespace(active_range.end_offset(), true);

        // Step 4. Let (start node, start offset) be the last equivalent point for the active range's start.
        let (mut start_node, mut start_offset) =
            (active_range.start_container(), active_range.start_offset()).last_equivalent_point();

        // Step 5. Let (end node, end offset) be the first equivalent point for the active range's end.
        let (mut end_node, mut end_offset) =
            (active_range.end_container(), active_range.end_offset()).first_equivalent_point();

        // Step 6. If (end node, end offset) is not after (start node, start offset):
        if bp_position(&end_node, end_offset, &start_node, start_offset) != Some(Ordering::Greater)
        {
            // Step 6.1. If direction is "forward", call collapseToStart() on the context object's selection.
            if direction == SelectionDeleteDirection::Forward {
                if self.CollapseToStart(CanGc::from_cx(cx)).is_err() {
                    unreachable!("Should be able to collapse to start");
                }
            } else {
                // Step 6.2. Otherwise, call collapseToEnd() on the context object's selection.
                if self.CollapseToEnd(CanGc::from_cx(cx)).is_err() {
                    unreachable!("Should be able to collapse to end");
                }
            }
            // Step 6.3. Abort these steps.
            return;
        }

        // Step 7. If start node is a Text node and start offset is 0, set start offset to the index of start node,
        // then set start node to its parent.
        if start_node.is::<Text>() && start_offset == 0 {
            start_offset = start_node.index();
            start_node = start_node
                .GetParentNode()
                .expect("Must always have a parent");
        }

        // Step 8. If end node is a Text node and end offset is its length, set end offset to one plus the index of end node,
        // then set end node to its parent.
        if end_node.is::<Text>() && end_offset == end_node.len() {
            end_offset = end_node.index() + 1;
            end_node = end_node.GetParentNode().expect("Must always have a parent");
        }

        // Step 9. Call collapse(start node, start offset) on the context object's selection.
        if self
            .Collapse(Some(&start_node), start_offset, CanGc::from_cx(cx))
            .is_err()
        {
            unreachable!("Must always be able to collapse");
        }

        // Step 10. Call extend(end node, end offset) on the context object's selection.
        if self
            .Extend(&end_node, end_offset, CanGc::from_cx(cx))
            .is_err()
        {
            unreachable!("Must always be able to extend");
        }

        // Step 11.
        //
        // This step does not exist in the spec

        // Step 12. Let start block be the active range's start node.
        let Some(active_range) = self.active_range() else {
            return;
        };
        let mut start_block = active_range.start_container();

        // Step 13. While start block's parent is in the same editing host and start block is an inline node,
        // set start block to its parent.
        loop {
            if start_block.is_inline_node() {
                if let Some(parent) = start_block.GetParentNode() {
                    if parent.same_editing_host(&start_node) {
                        start_block = parent;
                        continue;
                    }
                }
            }
            break;
        }

        // Step 14. If start block is neither a block node nor an editing host,
        // or "span" is not an allowed child of start block,
        // or start block is a td or th, set start block to null.
        let start_block = if (!start_block.is_block_node() && !start_block.is_editing_host()) ||
            !is_allowed_child(
                NodeOrString::String("span".to_owned()),
                NodeOrString::Node(start_block.clone()),
            ) ||
            start_block.is::<HTMLTableCellElement>()
        {
            None
        } else {
            Some(start_block)
        };

        // Step 15. Let end block be the active range's end node.
        let mut end_block = active_range.end_container();

        // Step 16. While end block's parent is in the same editing host and end block is an inline node, set end block to its parent.
        loop {
            if end_block.is_inline_node() {
                if let Some(parent) = end_block.GetParentNode() {
                    if parent.same_editing_host(&end_block) {
                        end_block = parent;
                        continue;
                    }
                }
            }
            break;
        }

        // Step 17. If end block is neither a block node nor an editing host, or "span" is not an allowed child of end block,
        // or end block is a td or th, set end block to null.
        let end_block = if (!end_block.is_block_node() && !end_block.is_editing_host()) ||
            !is_allowed_child(
                NodeOrString::String("span".to_owned()),
                NodeOrString::Node(end_block.clone()),
            ) ||
            end_block.is::<HTMLTableCellElement>()
        {
            None
        } else {
            Some(end_block)
        };

        // Step 18.
        //
        // This step does not exist in the spec

        // Step 19. Record current states and values, and let overrides be the result.
        let overrides = active_range.record_current_states_and_values();

        // Step 20.
        //
        // This step does not exist in the spec

        // Step 21. If start node and end node are the same, and start node is an editable Text node:
        if start_node == end_node && start_node.is_editable() {
            if let Some(start_text) = start_node.downcast::<Text>() {
                // Step 21.1. Call deleteData(start offset, end offset − start offset) on start node.
                if start_text
                    .upcast::<CharacterData>()
                    .DeleteData(start_offset, end_offset - start_offset)
                    .is_err()
                {
                    unreachable!("Must always be able to delete");
                }
                // Step 21.2. Canonicalize whitespace at (start node, start offset), with fix collapsed space false.
                start_node.canonicalize_whitespace(start_offset, false);
                // Step 21.3. If direction is "forward", call collapseToStart() on the context object's selection.
                if direction == SelectionDeleteDirection::Forward {
                    if self.CollapseToStart(CanGc::from_cx(cx)).is_err() {
                        unreachable!("Should be able to collapse to start");
                    }
                } else {
                    // Step 21.4. Otherwise, call collapseToEnd() on the context object's selection.
                    if self.CollapseToEnd(CanGc::from_cx(cx)).is_err() {
                        unreachable!("Should be able to collapse to end");
                    }
                }
                // Step 21.5. Restore states and values from overrides.
                active_range.restore_states_and_values(cx, self, context_object, overrides);

                // Step 21.6. Abort these steps.
                return;
            }
        }

        // Step 22. If start node is an editable Text node, call deleteData() on it, with start offset as
        // the first argument and (length of start node − start offset) as the second argument.
        if start_node.is_editable() {
            if let Some(start_text) = start_node.downcast::<Text>() {
                if start_text
                    .upcast::<CharacterData>()
                    .DeleteData(start_offset, start_node.len() - start_offset)
                    .is_err()
                {
                    unreachable!("Must always be able to delete");
                }
            }
        }

        // Step 23. Let node list be a list of nodes, initially empty.
        rooted_vec!(let mut node_list);

        // Step 24. For each node contained in the active range, append node to node list if the
        // last member of node list (if any) is not an ancestor of node; node is editable;
        // and node is not a thead, tbody, tfoot, tr, th, or td.
        let Ok(contained_children) = active_range.contained_children() else {
            unreachable!("Must always have contained children");
        };
        for node in contained_children.contained_children {
            // This type is only used to tell the compiler how to handle the type of `node_list.last()`.
            // It is not allowed to add a `& DomRoot<Node>` annotation, as test-tidy disallows that.
            // However, if we omit the type, the compiler doesn't know what it is, since we also
            // aren't allowed to add a type annotation to `node_list` itself, as that is handled
            // by the `rooted_vec` macro. Lastly, we also can't make it `&Node`, since then the compiler
            // thinks that the contents of the `RootedVec` is `Node`, whereas it is should be
            // `RootedVec<DomRoot<Node>>`. The type alias here doesn't upset test-tidy,
            // while also providing the necessary information to the compiler to work.
            type DomRootNode = DomRoot<Node>;
            if node.is_editable() &&
                !(node.is::<HTMLTableSectionElement>() ||
                    node.is::<HTMLTableRowElement>() ||
                    node.is::<HTMLTableCellElement>()) &&
                node_list
                    .last()
                    .is_none_or(|last: &DomRootNode| !last.is_ancestor_of(&node))
            {
                node_list.push(node);
            }
        }

        // Step 25. For each node in node list:
        for node in node_list.iter() {
            // Step 25.1. Let parent be the parent of node.
            let parent = node.GetParentNode().expect("Must always have a parent");
            // Step 25.2. Remove node from parent.
            assert!(node.has_parent());
            node.remove_self(cx);
            // Step 25.3. If the block node of parent has no visible children, and parent is editable or an editing host,
            // call createElement("br") on the context object and append the result as the last child of parent.
            if parent
                .block_node_of()
                .is_some_and(|block_node| block_node.children().all(|child| child.is_invisible())) &&
                parent.is_editable_or_editing_host()
            {
                let br = context_object.create_element(cx, "br");
                if parent.AppendChild(cx, br.upcast()).is_err() {
                    unreachable!("Must always be able to append");
                }
            }
            // Step 25.4. If strip wrappers is true or parent is not an inclusive ancestor of start node,
            // while parent is an editable inline node with length 0, let grandparent be the parent of parent,
            // then remove parent from grandparent, then set parent to grandparent.
            if strip_wrappers == SelectionDeletionStripWrappers::Strip ||
                !parent.is_inclusive_ancestor_of(&start_node)
            {
                let mut parent = parent;
                loop {
                    if parent.is_editable() && parent.is_inline_node() && parent.is_empty() {
                        let grand_parent =
                            parent.GetParentNode().expect("Must always have a parent");
                        assert!(parent.has_parent());
                        parent.remove_self(cx);
                        parent = grand_parent;
                        continue;
                    }
                    break;
                }
            }
        }

        // Step 26. If end node is an editable Text node, call deleteData(0, end offset) on it.
        if end_node.is_editable() {
            if let Some(end_text) = end_node.downcast::<Text>() {
                if end_text
                    .upcast::<CharacterData>()
                    .DeleteData(0, end_offset)
                    .is_err()
                {
                    unreachable!("Must always be able to delete");
                }
            }
        }

        // Step 27. Canonicalize whitespace at the active range's start, with fix collapsed space false.
        active_range
            .start_container()
            .canonicalize_whitespace(active_range.start_offset(), false);

        // Step 28. Canonicalize whitespace at the active range's end, with fix collapsed space false.
        active_range
            .end_container()
            .canonicalize_whitespace(active_range.end_offset(), false);

        // Step 29.
        //
        // This step does not exist in the spec

        // Step 30. If block merging is false, or start block or end block is null, or start block is not
        // in the same editing host as end block, or start block and end block are the same:
        if block_merging == SelectionDeletionBlockMerging::Skip ||
            start_block.as_ref().zip(end_block.as_ref()).is_none_or(
                |(start_block, end_block)| {
                    start_block == end_block || !start_block.same_editing_host(end_block)
                },
            )
        {
            // Step 30.1. If direction is "forward", call collapseToStart() on the context object's selection.
            if direction == SelectionDeleteDirection::Forward {
                if self.CollapseToStart(CanGc::from_cx(cx)).is_err() {
                    unreachable!("Should be able to collapse to start");
                }
            } else {
                // Step 30.2. Otherwise, call collapseToEnd() on the context object's selection.
                if self.CollapseToEnd(CanGc::from_cx(cx)).is_err() {
                    unreachable!("Should be able to collapse to end");
                }
            }
            // Step 30.3. Restore states and values from overrides.
            active_range.restore_states_and_values(cx, self, context_object, overrides);

            // Step 30.4. Abort these steps.
            return;
        }
        let start_block = start_block.expect("Already checked for None in previous statement");
        let end_block = end_block.expect("Already checked for None in previous statement");

        // Step 31. If start block has one child, which is a collapsed block prop, remove its child from it.
        if start_block.children_count() == 1 {
            let Some(child) = start_block.children().nth(0) else {
                unreachable!("Must always have a single child");
            };
            if child.is_collapsed_block_prop() {
                assert!(child.has_parent());
                child.remove_self(cx);
            }
        }

        // Step 32. If start block is an ancestor of end block:
        if start_block.is_ancestor_of(&end_block) {
            // Step 32.1. Let reference node be end block.
            let mut reference_node = end_block.clone();
            // Step 32.2. While reference node is not a child of start block, set reference node to its parent.
            loop {
                if start_block.children().all(|child| child != reference_node) {
                    reference_node = reference_node
                        .GetParentNode()
                        .expect("Must always have a parent, at least start_block");
                    continue;
                }
                break;
            }
            // Step 32.3. Call collapse() on the context object's selection,
            // with first argument start block and second argument the index of reference node.
            if self
                .Collapse(
                    Some(&start_block),
                    reference_node.index(),
                    CanGc::from_cx(cx),
                )
                .is_err()
            {
                unreachable!("Must always be able to collapse");
            }
            // Step 32.4. If end block has no children:
            if end_block.children_count() == 0 {
                let mut end_block = end_block;
                // Step 32.4.1. While end block is editable and is the only child of its parent and is not a child of start block,
                // let parent equal end block, then remove end block from parent, then set end block to parent.
                loop {
                    if end_block.is_editable() &&
                        start_block.children().all(|child| child != end_block)
                    {
                        if let Some(parent) = end_block.GetParentNode() {
                            if parent.children_count() == 1 {
                                assert!(end_block.has_parent());
                                end_block.remove_self(cx);
                                end_block = parent;
                                continue;
                            }
                        }
                    }
                    break;
                }
                // Step 32.4.2. If end block is editable and is not an inline node,
                // and its previousSibling and nextSibling are both inline nodes,
                // call createElement("br") on the context object and insert it into end block's parent immediately after end block.
                if end_block.is_editable() &&
                    !end_block.is_inline_node() &&
                    end_block
                        .GetPreviousSibling()
                        .is_some_and(|previous| previous.is_inline_node())
                {
                    if let Some(next_of_end_block) = end_block.GetNextSibling() {
                        if next_of_end_block.is_inline_node() {
                            let br = context_object.create_element(cx, "br");
                            let parent = end_block
                                .GetParentNode()
                                .expect("Must always have a parent");
                            if parent
                                .InsertBefore(cx, br.upcast(), Some(&next_of_end_block))
                                .is_err()
                            {
                                unreachable!("Must always be able to insert into parent");
                            }
                        }
                    }
                }
                // Step 32.4.3. If end block is editable, remove it from its parent.
                if end_block.is_editable() {
                    assert!(end_block.has_parent());
                    end_block.remove_self(cx);
                }
                // Step 32.4.4. Restore states and values from overrides.
                active_range.restore_states_and_values(cx, self, context_object, overrides);

                // Step 32.4.5. Abort these steps.
                return;
            }
            let first_child = end_block
                .children()
                .nth(0)
                .expect("Already checked at least 1 child in previous statement");
            // Step 32.5. If end block's firstChild is not an inline node,
            // restore states and values from record, then abort these steps.
            if !first_child.is_inline_node() {
                // TODO: Restore state
                return;
            }
            // Step 32.6. Let children be a list of nodes, initially empty.
            rooted_vec!(let mut children);
            // Step 32.7. Append the first child of end block to children.
            children.push(first_child.as_traced());
            // Step 32.8. While children's last member is not a br,
            // and children's last member's nextSibling is an inline node,
            // append children's last member's nextSibling to children.
            loop {
                let Some(last) = children.last() else {
                    break;
                };
                if last.is::<HTMLBRElement>() {
                    break;
                }
                let Some(next) = last.GetNextSibling() else {
                    break;
                };
                if next.is_inline_node() {
                    children.push(next.as_traced());
                    continue;
                }
                break;
            }
            // Step 32.9. Record the values of children, and let values be the result.
            // TODO

            // Step 32.10. While children's first member's parent is not start block,
            // split the parent of children.
            loop {
                if children
                    .first()
                    .and_then(|child| child.GetParentNode())
                    .is_some_and(|parent_of_child| parent_of_child != start_block)
                {
                    split_the_parent(cx, children.r());
                    continue;
                }
                break;
            }
            // Step 32.11. If children's first member's previousSibling is an editable br,
            // remove that br from its parent.
            if let Some(first) = children.first() {
                if let Some(previous_of_first) = first.GetPreviousSibling() {
                    if previous_of_first.is_editable() && previous_of_first.is::<HTMLBRElement>() {
                        assert!(previous_of_first.has_parent());
                        previous_of_first.remove_self(cx);
                    }
                }
            }
        // Step 33. Otherwise, if start block is a descendant of end block:
        } else if end_block.is_ancestor_of(&start_block) {
            // Step 33.1. Call collapse() on the context object's selection,
            // with first argument start block and second argument start block's length.
            if self
                .Collapse(Some(&start_block), start_block.len(), CanGc::from_cx(cx))
                .is_err()
            {
                unreachable!("Must always be able to collapse");
            }
            // Step 33.2. Let reference node be start block.
            let mut reference_node = start_block.clone();
            // Step 33.3. While reference node is not a child of end block, set reference node to its parent.
            loop {
                if end_block.children().all(|child| child != reference_node) {
                    if let Some(parent) = reference_node.GetParentNode() {
                        reference_node = parent;
                        continue;
                    }
                }
                break;
            }
            // Step 33.4. If reference node's nextSibling is an inline node and start block's lastChild is a br,
            // remove start block's lastChild from it.
            if reference_node
                .GetNextSibling()
                .is_some_and(|next| next.is_inline_node())
            {
                if let Some(last) = start_block.children().last() {
                    if last.is::<HTMLBRElement>() {
                        assert!(last.has_parent());
                        last.remove_self(cx);
                    }
                }
            }
            // Step 33.5. Let nodes to move be a list of nodes, initially empty.
            rooted_vec!(let mut nodes_to_move);
            // Step 33.6. If reference node's nextSibling is neither null nor a block node,
            // append it to nodes to move.
            if let Some(next) = reference_node.GetNextSibling() {
                if !next.is_block_node() {
                    nodes_to_move.push(next);
                }
            }
            // Step 33.7. While nodes to move is nonempty and its last member isn't a br
            // and its last member's nextSibling is neither null nor a block node,
            // append its last member's nextSibling to nodes to move.
            loop {
                if let Some(last) = nodes_to_move.last() {
                    if !last.is::<HTMLBRElement>() {
                        if let Some(next_of_last) = last.GetNextSibling() {
                            if !next_of_last.is_block_node() {
                                nodes_to_move.push(next_of_last);
                                continue;
                            }
                        }
                    }
                }
                break;
            }
            // Step 33.8. Record the values of nodes to move, and let values be the result.
            // TODO

            // Step 33.9. For each node in nodes to move,
            // append node as the last child of start block, preserving ranges.
            for node in nodes_to_move.iter() {
                move_preserving_ranges(cx, node, |cx| start_block.AppendChild(cx, node));
            }
        // Step 34. Otherwise:
        } else {
            // Step 34.1. Call collapse() on the context object's selection,
            // with first argument start block and second argument start block's length.
            if self
                .Collapse(Some(&start_block), start_block.len(), CanGc::from_cx(cx))
                .is_err()
            {
                unreachable!("Must always be able to collapse");
            }
            // Step 34.2. If end block's firstChild is an inline node and start block's lastChild is a br,
            // remove start block's lastChild from it.
            if end_block
                .children()
                .nth(0)
                .is_some_and(|next| next.is_inline_node())
            {
                if let Some(last) = start_block.children().last() {
                    if last.is::<HTMLBRElement>() {
                        assert!(last.has_parent());
                        last.remove_self(cx);
                    }
                }
            }
            // Step 34.3. Record the values of end block's children, and let values be the result.
            // TODO

            // Step 34.4. While end block has children,
            // append the first child of end block to start block, preserving ranges.
            loop {
                if let Some(first_child) = end_block.children().nth(0) {
                    move_preserving_ranges(cx, &first_child, |cx| {
                        start_block.AppendChild(cx, &first_child)
                    });
                    continue;
                }
                break;
            }
            // Step 34.5. While end block has no children,
            // let parent be the parent of end block, then remove end block from parent,
            // then set end block to parent.
            let mut end_block = end_block;
            loop {
                if end_block.children_count() == 0 {
                    if let Some(parent) = end_block.GetParentNode() {
                        assert!(end_block.has_parent());
                        end_block.remove_self(cx);
                        end_block = parent;
                        continue;
                    }
                }
                break;
            }
        }

        // Step 35.
        //
        // This step does not exist in the spec

        // Step 36. Let ancestor be start block.
        // TODO

        // Step 37. While ancestor has an inclusive ancestor ol in the same editing host whose nextSibling is
        // also an ol in the same editing host, or an inclusive ancestor ul in the same editing host whose nextSibling
        // is also a ul in the same editing host:
        // TODO

        // Step 38. Restore the values from values.
        // TODO

        // Step 39. If start block has no children, call createElement("br") on the context object and
        // append the result as the last child of start block.
        if start_block.children_count() == 0 {
            let br = context_object.create_element(cx, "br");
            if start_block.AppendChild(cx, br.upcast()).is_err() {
                unreachable!("Must always be able to append");
            }
        }

        // Step 40. Remove extraneous line breaks at the end of start block.
        start_block.remove_extraneous_line_breaks_at_the_end_of(cx);

        // Step 41. Restore states and values from overrides.
        active_range.restore_states_and_values(cx, self, context_object, overrides);
    }

    /// <https://w3c.github.io/editing/docs/execCommand/#set-the-selection%27s-value>
    fn set_the_selection_value(
        &self,
        cx: &mut js::context::JSContext,
        new_value: Option<DOMString>,
        command: CommandName,
        context_object: &Document,
    ) {
        let active_range = self
            .active_range()
            .expect("Must always have an active range");

        // Step 1. Let command be the current command.
        //
        // Passed as argument

        // Step 2. If there is no formattable node effectively contained in the active range:
        if active_range.first_formattable_contained_node().is_none() {
            // Step 2.1. If command has inline command activated values, set the state override to true if new value is among them and false if it's not.
            // TODO

            // Step 2.2. If command is "subscript", unset the state override for "superscript".
            if command == CommandName::Subscript {
                context_object.set_state_override(CommandName::Superscript, None);
            }
            // Step 2.3. If command is "superscript", unset the state override for "subscript".
            if command == CommandName::Superscript {
                context_object.set_state_override(CommandName::Subscript, None);
            }
            // Step 2.4. If new value is null, unset the value override (if any).
            // Step 2.5. Otherwise, if command is "createLink" or it has a value specified, set the value override to new value.
            context_object.set_value_override(command, new_value);
            // Step 2.6. Abort these steps.
            return;
        }
        // Step 3. If the active range's start node is an editable Text node,
        // and its start offset is neither zero nor its start node's length,
        // call splitText() on the active range's start node,
        // with argument equal to the active range's start offset.
        // Then set the active range's start node to the result, and its start offset to zero.
        let start_node = active_range.start_container();
        let start_offset = active_range.start_offset();
        if start_node.is_editable() && start_offset != 0 && start_offset != start_node.len() {
            if let Some(start_text) = start_node.downcast::<Text>() {
                let Ok(start_text) = start_text.SplitText(cx, start_offset) else {
                    unreachable!("Must always be able to split");
                };
                active_range.set_start(start_text.upcast(), 0);
            }
        }
        // Step 4. If the active range's end node is an editable Text node,
        // and its end offset is neither zero nor its end node's length,
        // call splitText() on the active range's end node,
        // with argument equal to the active range's end offset.
        let end_node = active_range.end_container();
        let end_offset = active_range.end_offset();
        if end_node.is_editable() && end_offset != 0 && end_offset != end_node.len() {
            if let Some(end_text) = end_node.downcast::<Text>() {
                if end_text.SplitText(cx, end_offset).is_err() {
                    unreachable!("Must always be able to split");
                };
            }
        }
        // Step 5. Let element list be all editable Elements effectively contained in the active range.
        // Step 6. For each element in element list, clear the value of element.
        active_range.for_each_effectively_contained_child(|child| {
            if child.is_editable() {
                if let Some(element_child) = child.downcast::<HTMLElement>() {
                    element_child.clear_the_value(cx, &command);
                }
            }
        });
        // Step 7. Let node list be all editable nodes effectively contained in the active range.
        // Step 8. For each node in node list:
        active_range.for_each_effectively_contained_child(|child| {
            if child.is_editable() {
                // Step 8.1. Push down values on node.
                child.push_down_values(cx, &command, new_value.clone());
                // Step 8.2. If node is an allowed child of "span", force the value of node.
                if is_allowed_child(
                    NodeOrString::Node(DomRoot::from_ref(child)),
                    NodeOrString::String("span".to_owned()),
                ) {
                    child.force_the_value(cx, &command, new_value.as_ref());
                }
            }
        });
    }
}