script/dom/

range.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::cell::RefCell;
use std::cmp::{Ordering, PartialOrd};
use std::iter;

use dom_struct::dom_struct;
use js::jsapi::JSTracer;
use js::rust::HandleObject;

use crate::dom::abstractrange::{AbstractRange, BoundaryPoint, bp_position};
use crate::dom::bindings::cell::DomRefCell;
use crate::dom::bindings::codegen::Bindings::AbstractRangeBinding::AbstractRangeMethods;
use crate::dom::bindings::codegen::Bindings::CharacterDataBinding::CharacterDataMethods;
use crate::dom::bindings::codegen::Bindings::NodeBinding::NodeMethods;
use crate::dom::bindings::codegen::Bindings::NodeListBinding::NodeListMethods;
use crate::dom::bindings::codegen::Bindings::RangeBinding::{RangeConstants, RangeMethods};
use crate::dom::bindings::codegen::Bindings::TextBinding::TextMethods;
use crate::dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
use crate::dom::bindings::codegen::UnionTypes::TrustedHTMLOrString;
use crate::dom::bindings::error::{Error, ErrorResult, Fallible};
use crate::dom::bindings::inheritance::{Castable, CharacterDataTypeId, NodeTypeId};
use crate::dom::bindings::reflector::reflect_dom_object_with_proto;
use crate::dom::bindings::root::{Dom, DomRoot};
use crate::dom::bindings::str::DOMString;
use crate::dom::bindings::trace::JSTraceable;
use crate::dom::bindings::weakref::{WeakRef, WeakRefVec};
use crate::dom::characterdata::CharacterData;
use crate::dom::document::Document;
use crate::dom::documentfragment::DocumentFragment;
use crate::dom::domrect::DOMRect;
use crate::dom::domrectlist::DOMRectList;
use crate::dom::element::Element;
use crate::dom::html::htmlscriptelement::HTMLScriptElement;
use crate::dom::node::{Node, NodeTraits, ShadowIncluding, UnbindContext};
use crate::dom::selection::Selection;
use crate::dom::text::Text;
use crate::dom::trustedhtml::TrustedHTML;
use crate::dom::window::Window;
use crate::script_runtime::CanGc;

#[dom_struct]
pub(crate) struct Range {
    abstract_range: AbstractRange,
    // A range that belongs to a Selection needs to know about it
    // so selectionchange can fire when the range changes.
    // A range shouldn't belong to more than one Selection at a time,
    // but from the spec as of Feb 1 2020 I can't rule out a corner case like:
    // * Select a range R in document A, from node X to Y
    // * Insert everything from X to Y into document B
    // * Set B's selection's range to R
    // which leaves R technically, and observably, associated with A even though
    // it will fail the same-root-node check on many of A's selection's methods.
    associated_selections: DomRefCell<Vec<Dom<Selection>>>,
}

struct ContainedChildren {
    first_partially_contained_child: Option<DomRoot<Node>>,
    last_partially_contained_child: Option<DomRoot<Node>>,
    contained_children: Vec<DomRoot<Node>>,
}

impl Range {
    fn new_inherited(
        start_container: &Node,
        start_offset: u32,
        end_container: &Node,
        end_offset: u32,
    ) -> Range {
        debug_assert!(start_offset <= start_container.len());
        debug_assert!(end_offset <= end_container.len());
        Range {
            abstract_range: AbstractRange::new_inherited(
                start_container,
                start_offset,
                end_container,
                end_offset,
            ),
            associated_selections: DomRefCell::new(vec![]),
        }
    }

    pub(crate) fn new_with_doc(
        document: &Document,
        proto: Option<HandleObject>,
        can_gc: CanGc,
    ) -> DomRoot<Range> {
        let root = document.upcast();
        Range::new_with_proto(document, proto, root, 0, root, 0, can_gc)
    }

    pub(crate) fn new(
        document: &Document,
        start_container: &Node,
        start_offset: u32,
        end_container: &Node,
        end_offset: u32,
        can_gc: CanGc,
    ) -> DomRoot<Range> {
        Self::new_with_proto(
            document,
            None,
            start_container,
            start_offset,
            end_container,
            end_offset,
            can_gc,
        )
    }

    fn new_with_proto(
        document: &Document,
        proto: Option<HandleObject>,
        start_container: &Node,
        start_offset: u32,
        end_container: &Node,
        end_offset: u32,
        can_gc: CanGc,
    ) -> DomRoot<Range> {
        let range = reflect_dom_object_with_proto(
            Box::new(Range::new_inherited(
                start_container,
                start_offset,
                end_container,
                end_offset,
            )),
            document.window(),
            proto,
            can_gc,
        );
        start_container.ranges().push(WeakRef::new(&range));
        if start_container != end_container {
            end_container.ranges().push(WeakRef::new(&range));
        }
        range
    }

    /// <https://dom.spec.whatwg.org/#contained>
    fn contains(&self, node: &Node) -> bool {
        matches!(
            (
                bp_position(node, 0, &self.start_container(), self.start_offset()),
                bp_position(node, node.len(), &self.end_container(), self.end_offset()),
            ),
            (Some(Ordering::Greater), Some(Ordering::Less))
        )
    }

    /// <https://dom.spec.whatwg.org/#partially-contained>
    fn partially_contains(&self, node: &Node) -> bool {
        self.start_container()
            .inclusive_ancestors(ShadowIncluding::No)
            .any(|n| &*n == node) !=
            self.end_container()
                .inclusive_ancestors(ShadowIncluding::No)
                .any(|n| &*n == node)
    }

    /// <https://dom.spec.whatwg.org/#concept-range-clone>
    fn contained_children(&self) -> Fallible<ContainedChildren> {
        let start_node = self.start_container();
        let end_node = self.end_container();
        // Steps 5-6.
        let common_ancestor = self.CommonAncestorContainer();

        let first_partially_contained_child = if start_node.is_inclusive_ancestor_of(&end_node) {
            // Step 7.
            None
        } else {
            // Step 8.
            common_ancestor
                .children()
                .find(|node| Range::partially_contains(self, node))
        };

        let last_partially_contained_child = if end_node.is_inclusive_ancestor_of(&start_node) {
            // Step 9.
            None
        } else {
            // Step 10.
            common_ancestor
                .rev_children()
                .find(|node| Range::partially_contains(self, node))
        };

        // Step 11.
        let contained_children: Vec<DomRoot<Node>> = common_ancestor
            .children()
            .filter(|n| self.contains(n))
            .collect();

        // Step 12.
        if contained_children.iter().any(|n| n.is_doctype()) {
            return Err(Error::HierarchyRequest);
        }

        Ok(ContainedChildren {
            first_partially_contained_child,
            last_partially_contained_child,
            contained_children,
        })
    }

    /// <https://dom.spec.whatwg.org/#concept-range-bp-set>
    fn set_start(&self, node: &Node, offset: u32) {
        if self.start().node() != node || self.start_offset() != offset {
            self.report_change();
        }
        if self.start().node() != node {
            if self.start().node() == self.end().node() {
                node.ranges().push(WeakRef::new(self));
            } else if self.end().node() == node {
                self.start_container().ranges().remove(self);
            } else {
                node.ranges()
                    .push(self.start_container().ranges().remove(self));
            }
        }
        self.start().set(node, offset);
    }

    /// <https://dom.spec.whatwg.org/#concept-range-bp-set>
    fn set_end(&self, node: &Node, offset: u32) {
        if self.end().node() != node || self.end_offset() != offset {
            self.report_change();
        }
        if self.end().node() != node {
            if self.end().node() == self.start().node() {
                node.ranges().push(WeakRef::new(self));
            } else if self.start().node() == node {
                self.end_container().ranges().remove(self);
            } else {
                node.ranges()
                    .push(self.end_container().ranges().remove(self));
            }
        }
        self.end().set(node, offset);
    }

    /// <https://dom.spec.whatwg.org/#dom-range-comparepointnode-offset>
    fn compare_point(&self, node: &Node, offset: u32) -> Fallible<Ordering> {
        let start_node = self.start_container();
        let start_node_root = start_node
            .inclusive_ancestors(ShadowIncluding::No)
            .last()
            .unwrap();
        let node_root = node
            .inclusive_ancestors(ShadowIncluding::No)
            .last()
            .unwrap();
        if start_node_root != node_root {
            // Step 1.
            return Err(Error::WrongDocument);
        }
        if node.is_doctype() {
            // Step 2.
            return Err(Error::InvalidNodeType);
        }
        if offset > node.len() {
            // Step 3.
            return Err(Error::IndexSize);
        }
        if let Ordering::Less = bp_position(node, offset, &start_node, self.start_offset()).unwrap()
        {
            // Step 4.
            return Ok(Ordering::Less);
        }
        if let Ordering::Greater =
            bp_position(node, offset, &self.end_container(), self.end_offset()).unwrap()
        {
            // Step 5.
            return Ok(Ordering::Greater);
        }
        // Step 6.
        Ok(Ordering::Equal)
    }

    pub(crate) fn associate_selection(&self, selection: &Selection) {
        let mut selections = self.associated_selections.borrow_mut();
        if !selections.iter().any(|s| &**s == selection) {
            selections.push(Dom::from_ref(selection));
        }
    }

    pub(crate) fn disassociate_selection(&self, selection: &Selection) {
        self.associated_selections
            .borrow_mut()
            .retain(|s| &**s != selection);
    }

    fn report_change(&self) {
        self.associated_selections
            .borrow()
            .iter()
            .for_each(|s| s.queue_selectionchange_task());
    }

    fn abstract_range(&self) -> &AbstractRange {
        &self.abstract_range
    }

    fn start(&self) -> &BoundaryPoint {
        self.abstract_range().start()
    }

    fn end(&self) -> &BoundaryPoint {
        self.abstract_range().end()
    }

    pub(crate) fn start_container(&self) -> DomRoot<Node> {
        self.abstract_range().StartContainer()
    }

    pub(crate) fn start_offset(&self) -> u32 {
        self.abstract_range().StartOffset()
    }

    pub(crate) fn end_container(&self) -> DomRoot<Node> {
        self.abstract_range().EndContainer()
    }

    pub(crate) fn end_offset(&self) -> u32 {
        self.abstract_range().EndOffset()
    }

    pub(crate) fn collapsed(&self) -> bool {
        self.abstract_range().Collapsed()
    }

    fn client_rects(
        &self,
    ) -> impl Iterator<Item = euclid::Rect<app_units::Au, euclid::UnknownUnit>> {
        // FIXME: For text nodes that are only partially selected, this should return the client
        // rect of the selected part, not the whole text node.
        let start = self.start_container();
        let end = self.end_container();
        let document = start.owner_doc();
        let end_clone = end.clone();
        start
            .following_nodes(document.upcast::<Node>())
            .take_while(move |node| node != &end)
            .chain(iter::once(end_clone))
            .flat_map(move |node| node.border_boxes())
    }

    /// <https://dom.spec.whatwg.org/#concept-range-bp-set>
    #[allow(clippy::neg_cmp_op_on_partial_ord)]
    fn set_the_start_or_end(
        &self,
        node: &Node,
        offset: u32,
        start_or_end: StartOrEnd,
    ) -> ErrorResult {
        // Step 1. If node is a doctype, then throw an "InvalidNodeTypeError" DOMException.
        if node.is_doctype() {
            return Err(Error::InvalidNodeType);
        }

        // Step 2. If offset is greater than node’s length, then throw an "IndexSizeError" DOMException.
        if offset > node.len() {
            return Err(Error::IndexSize);
        }

        // Step 3. Let bp be the boundary point (node, offset).
        // NOTE: We don't need this part.

        match start_or_end {
            // If these steps were invoked as "set the start"
            StartOrEnd::Start => {
                // Step 4.1  If range’s root is not equal to node’s root, or if bp is after the range’s end,
                // set range’s end to bp.
                // Step 4.2 Set range’s start to bp.
                self.set_start(node, offset);
                if !(self.start() <= self.end()) {
                    self.set_end(node, offset);
                }
            },
            // If these steps were invoked as "set the end"
            StartOrEnd::End => {
                // Step 4.1 If range’s root is not equal to node’s root, or if bp is before the range’s start,
                // set range’s start to bp.
                // Step 4.2 Set range’s end to bp.
                self.set_end(node, offset);
                if !(self.end() >= self.start()) {
                    self.set_start(node, offset);
                }
            },
        }

        Ok(())
    }
}

enum StartOrEnd {
    Start,
    End,
}

impl RangeMethods<crate::DomTypeHolder> for Range {
    /// <https://dom.spec.whatwg.org/#dom-range>
    fn Constructor(
        window: &Window,
        proto: Option<HandleObject>,
        can_gc: CanGc,
    ) -> Fallible<DomRoot<Range>> {
        let document = window.Document();
        Ok(Range::new_with_doc(&document, proto, can_gc))
    }

    /// <https://dom.spec.whatwg.org/#dom-range-commonancestorcontainer>
    fn CommonAncestorContainer(&self) -> DomRoot<Node> {
        self.end_container()
            .common_ancestor(&self.start_container(), ShadowIncluding::No)
            .expect("Couldn't find common ancestor container")
    }

    /// <https://dom.spec.whatwg.org/#dom-range-setstart>
    fn SetStart(&self, node: &Node, offset: u32) -> ErrorResult {
        self.set_the_start_or_end(node, offset, StartOrEnd::Start)
    }

    /// <https://dom.spec.whatwg.org/#dom-range-setend>
    fn SetEnd(&self, node: &Node, offset: u32) -> ErrorResult {
        self.set_the_start_or_end(node, offset, StartOrEnd::End)
    }

    /// <https://dom.spec.whatwg.org/#dom-range-setstartbefore>
    fn SetStartBefore(&self, node: &Node) -> ErrorResult {
        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
        self.SetStart(&parent, node.index())
    }

    /// <https://dom.spec.whatwg.org/#dom-range-setstartafter>
    fn SetStartAfter(&self, node: &Node) -> ErrorResult {
        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
        self.SetStart(&parent, node.index() + 1)
    }

    /// <https://dom.spec.whatwg.org/#dom-range-setendbefore>
    fn SetEndBefore(&self, node: &Node) -> ErrorResult {
        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
        self.SetEnd(&parent, node.index())
    }

    /// <https://dom.spec.whatwg.org/#dom-range-setendafter>
    fn SetEndAfter(&self, node: &Node) -> ErrorResult {
        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
        self.SetEnd(&parent, node.index() + 1)
    }

    /// <https://dom.spec.whatwg.org/#dom-range-collapse>
    fn Collapse(&self, to_start: bool) {
        if to_start {
            self.set_end(&self.start_container(), self.start_offset());
        } else {
            self.set_start(&self.end_container(), self.end_offset());
        }
    }

    /// <https://dom.spec.whatwg.org/#dom-range-selectnode>
    fn SelectNode(&self, node: &Node) -> ErrorResult {
        // Steps 1, 2.
        let parent = node.GetParentNode().ok_or(Error::InvalidNodeType)?;
        // Step 3.
        let index = node.index();
        // Step 4.
        self.set_start(&parent, index);
        // Step 5.
        self.set_end(&parent, index + 1);
        Ok(())
    }

    /// <https://dom.spec.whatwg.org/#dom-range-selectnodecontents>
    fn SelectNodeContents(&self, node: &Node) -> ErrorResult {
        if node.is_doctype() {
            // Step 1.
            return Err(Error::InvalidNodeType);
        }
        // Step 2.
        let length = node.len();
        // Step 3.
        self.set_start(node, 0);
        // Step 4.
        self.set_end(node, length);
        Ok(())
    }

    /// <https://dom.spec.whatwg.org/#dom-range-compareboundarypoints>
    fn CompareBoundaryPoints(&self, how: u16, other: &Range) -> Fallible<i16> {
        if how > RangeConstants::END_TO_START {
            // Step 1.
            return Err(Error::NotSupported);
        }
        let this_root = self
            .start_container()
            .inclusive_ancestors(ShadowIncluding::No)
            .last()
            .unwrap();
        let other_root = other
            .start_container()
            .inclusive_ancestors(ShadowIncluding::No)
            .last()
            .unwrap();
        if this_root != other_root {
            // Step 2.
            return Err(Error::WrongDocument);
        }
        // Step 3.
        let (this_point, other_point) = match how {
            RangeConstants::START_TO_START => (self.start(), other.start()),
            RangeConstants::START_TO_END => (self.end(), other.start()),
            RangeConstants::END_TO_END => (self.end(), other.end()),
            RangeConstants::END_TO_START => (self.start(), other.end()),
            _ => unreachable!(),
        };
        // step 4.
        match this_point.partial_cmp(other_point).unwrap() {
            Ordering::Less => Ok(-1),
            Ordering::Equal => Ok(0),
            Ordering::Greater => Ok(1),
        }
    }

    /// <https://dom.spec.whatwg.org/#dom-range-clonerange>
    fn CloneRange(&self, can_gc: CanGc) -> DomRoot<Range> {
        let start_node = self.start_container();
        let owner_doc = start_node.owner_doc();
        Range::new(
            &owner_doc,
            &start_node,
            self.start_offset(),
            &self.end_container(),
            self.end_offset(),
            can_gc,
        )
    }

    /// <https://dom.spec.whatwg.org/#dom-range-ispointinrange>
    fn IsPointInRange(&self, node: &Node, offset: u32) -> Fallible<bool> {
        match self.compare_point(node, offset) {
            Ok(Ordering::Less) => Ok(false),
            Ok(Ordering::Equal) => Ok(true),
            Ok(Ordering::Greater) => Ok(false),
            Err(Error::WrongDocument) => {
                // Step 2.
                Ok(false)
            },
            Err(error) => Err(error),
        }
    }

    /// <https://dom.spec.whatwg.org/#dom-range-comparepoint>
    fn ComparePoint(&self, node: &Node, offset: u32) -> Fallible<i16> {
        self.compare_point(node, offset).map(|order| match order {
            Ordering::Less => -1,
            Ordering::Equal => 0,
            Ordering::Greater => 1,
        })
    }

    /// <https://dom.spec.whatwg.org/#dom-range-intersectsnode>
    fn IntersectsNode(&self, node: &Node) -> bool {
        let start_node = self.start_container();
        let start_node_root = self
            .start_container()
            .inclusive_ancestors(ShadowIncluding::No)
            .last()
            .unwrap();
        let node_root = node
            .inclusive_ancestors(ShadowIncluding::No)
            .last()
            .unwrap();
        if start_node_root != node_root {
            // Step 1.
            return false;
        }
        let parent = match node.GetParentNode() {
            Some(parent) => parent,
            None => {
                // Step 3.
                return true;
            },
        };
        // Step 4.
        let offset = node.index();
        // Step 5.
        Ordering::Greater ==
            bp_position(&parent, offset + 1, &start_node, self.start_offset()).unwrap() &&
            Ordering::Less ==
                bp_position(&parent, offset, &self.end_container(), self.end_offset())
                    .unwrap()
    }

    /// <https://dom.spec.whatwg.org/#dom-range-clonecontents>
    /// <https://dom.spec.whatwg.org/#concept-range-clone>
    fn CloneContents(&self, can_gc: CanGc) -> Fallible<DomRoot<DocumentFragment>> {
        // Step 3.
        let start_node = self.start_container();
        let start_offset = self.start_offset();
        let end_node = self.end_container();
        let end_offset = self.end_offset();

        // Step 1.
        let fragment = DocumentFragment::new(&start_node.owner_doc(), can_gc);

        // Step 2.
        if self.start() == self.end() {
            return Ok(fragment);
        }

        if end_node == start_node {
            if let Some(cdata) = start_node.downcast::<CharacterData>() {
                // Steps 4.1-2.
                let data = cdata
                    .SubstringData(start_offset, end_offset - start_offset)
                    .unwrap();
                let clone = cdata.clone_with_data(data, &start_node.owner_doc(), can_gc);
                // Step 4.3.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
                // Step 4.4
                return Ok(fragment);
            }
        }

        // Steps 5-12.
        let ContainedChildren {
            first_partially_contained_child,
            last_partially_contained_child,
            contained_children,
        } = self.contained_children()?;

        if let Some(child) = first_partially_contained_child {
            // Step 13.
            if let Some(cdata) = child.downcast::<CharacterData>() {
                assert!(child == start_node);
                // Steps 13.1-2.
                let data = cdata
                    .SubstringData(start_offset, start_node.len() - start_offset)
                    .unwrap();
                let clone = cdata.clone_with_data(data, &start_node.owner_doc(), can_gc);
                // Step 13.3.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
            } else {
                // Step 14.1.
                let clone = child.CloneNode(/* deep */ false, can_gc)?;
                // Step 14.2.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
                // Step 14.3.
                let subrange = Range::new(
                    &clone.owner_doc(),
                    &start_node,
                    start_offset,
                    &child,
                    child.len(),
                    can_gc,
                );
                // Step 14.4.
                let subfragment = subrange.CloneContents(can_gc)?;
                // Step 14.5.
                clone.AppendChild(subfragment.upcast(), can_gc)?;
            }
        }

        // Step 15.
        for child in contained_children {
            // Step 15.1.
            let clone = child.CloneNode(/* deep */ true, can_gc)?;
            // Step 15.2.
            fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
        }

        if let Some(child) = last_partially_contained_child {
            // Step 16.
            if let Some(cdata) = child.downcast::<CharacterData>() {
                assert!(child == end_node);
                // Steps 16.1-2.
                let data = cdata.SubstringData(0, end_offset).unwrap();
                let clone = cdata.clone_with_data(data, &start_node.owner_doc(), can_gc);
                // Step 16.3.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
            } else {
                // Step 17.1.
                let clone = child.CloneNode(/* deep */ false, can_gc)?;
                // Step 17.2.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
                // Step 17.3.
                let subrange =
                    Range::new(&clone.owner_doc(), &child, 0, &end_node, end_offset, can_gc);
                // Step 17.4.
                let subfragment = subrange.CloneContents(can_gc)?;
                // Step 17.5.
                clone.AppendChild(subfragment.upcast(), can_gc)?;
            }
        }

        // Step 18.
        Ok(fragment)
    }

    /// <https://dom.spec.whatwg.org/#dom-range-extractcontents>
    /// <https://dom.spec.whatwg.org/#concept-range-extract>
    fn ExtractContents(&self, can_gc: CanGc) -> Fallible<DomRoot<DocumentFragment>> {
        // Step 3.
        let start_node = self.start_container();
        let start_offset = self.start_offset();
        let end_node = self.end_container();
        let end_offset = self.end_offset();

        // Step 1.
        let fragment = DocumentFragment::new(&start_node.owner_doc(), can_gc);

        // Step 2.
        if self.collapsed() {
            return Ok(fragment);
        }

        if end_node == start_node {
            if let Some(end_data) = end_node.downcast::<CharacterData>() {
                // Step 4.1.
                let clone = end_node.CloneNode(/* deep */ true, can_gc)?;
                // Step 4.2.
                let text = end_data.SubstringData(start_offset, end_offset - start_offset);
                clone
                    .downcast::<CharacterData>()
                    .unwrap()
                    .SetData(text.unwrap());
                // Step 4.3.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
                // Step 4.4.
                end_data.ReplaceData(start_offset, end_offset - start_offset, DOMString::new())?;
                // Step 4.5.
                return Ok(fragment);
            }
        }

        // Steps 5-12.
        let ContainedChildren {
            first_partially_contained_child,
            last_partially_contained_child,
            contained_children,
        } = self.contained_children()?;

        let (new_node, new_offset) = if start_node.is_inclusive_ancestor_of(&end_node) {
            // Step 13.
            (DomRoot::from_ref(&*start_node), start_offset)
        } else {
            // Step 14.1-2.
            let reference_node = start_node
                .ancestors()
                .take_while(|n| !n.is_inclusive_ancestor_of(&end_node))
                .last()
                .unwrap_or(DomRoot::from_ref(&start_node));
            // Step 14.3.
            (
                reference_node.GetParentNode().unwrap(),
                reference_node.index() + 1,
            )
        };

        if let Some(child) = first_partially_contained_child {
            if let Some(start_data) = child.downcast::<CharacterData>() {
                assert!(child == start_node);
                // Step 15.1.
                let clone = start_node.CloneNode(/* deep */ true, can_gc)?;
                // Step 15.2.
                let text = start_data.SubstringData(start_offset, start_node.len() - start_offset);
                clone
                    .downcast::<CharacterData>()
                    .unwrap()
                    .SetData(text.unwrap());
                // Step 15.3.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
                // Step 15.4.
                start_data.ReplaceData(
                    start_offset,
                    start_node.len() - start_offset,
                    DOMString::new(),
                )?;
            } else {
                // Step 16.1.
                let clone = child.CloneNode(/* deep */ false, can_gc)?;
                // Step 16.2.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
                // Step 16.3.
                let subrange = Range::new(
                    &clone.owner_doc(),
                    &start_node,
                    start_offset,
                    &child,
                    child.len(),
                    can_gc,
                );
                // Step 16.4.
                let subfragment = subrange.ExtractContents(can_gc)?;
                // Step 16.5.
                clone.AppendChild(subfragment.upcast(), can_gc)?;
            }
        }

        // Step 17.
        for child in contained_children {
            fragment.upcast::<Node>().AppendChild(&child, can_gc)?;
        }

        if let Some(child) = last_partially_contained_child {
            if let Some(end_data) = child.downcast::<CharacterData>() {
                assert!(child == end_node);
                // Step 18.1.
                let clone = end_node.CloneNode(/* deep */ true, can_gc)?;
                // Step 18.2.
                let text = end_data.SubstringData(0, end_offset);
                clone
                    .downcast::<CharacterData>()
                    .unwrap()
                    .SetData(text.unwrap());
                // Step 18.3.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
                // Step 18.4.
                end_data.ReplaceData(0, end_offset, DOMString::new())?;
            } else {
                // Step 19.1.
                let clone = child.CloneNode(/* deep */ false, can_gc)?;
                // Step 19.2.
                fragment.upcast::<Node>().AppendChild(&clone, can_gc)?;
                // Step 19.3.
                let subrange =
                    Range::new(&clone.owner_doc(), &child, 0, &end_node, end_offset, can_gc);
                // Step 19.4.
                let subfragment = subrange.ExtractContents(can_gc)?;
                // Step 19.5.
                clone.AppendChild(subfragment.upcast(), can_gc)?;
            }
        }

        // Step 20.
        self.SetStart(&new_node, new_offset)?;
        self.SetEnd(&new_node, new_offset)?;

        // Step 21.
        Ok(fragment)
    }

    /// <https://dom.spec.whatwg.org/#dom-range-detach>
    fn Detach(&self) {
        // This method intentionally left blank.
    }

    /// <https://dom.spec.whatwg.org/#dom-range-insertnode>
    /// <https://dom.spec.whatwg.org/#concept-range-insert>
    fn InsertNode(&self, node: &Node, can_gc: CanGc) -> ErrorResult {
        let start_node = self.start_container();
        let start_offset = self.start_offset();

        // Step 1.
        if &*start_node == node {
            return Err(Error::HierarchyRequest);
        }
        match start_node.type_id() {
            // Handled under step 2.
            NodeTypeId::CharacterData(CharacterDataTypeId::Text(_)) => (),
            NodeTypeId::CharacterData(_) => return Err(Error::HierarchyRequest),
            _ => (),
        }

        // Step 2.
        let (reference_node, parent) = match start_node.type_id() {
            NodeTypeId::CharacterData(CharacterDataTypeId::Text(_)) => {
                // Step 3.
                let parent = match start_node.GetParentNode() {
                    Some(parent) => parent,
                    // Step 1.
                    None => return Err(Error::HierarchyRequest),
                };
                // Step 5.
                (Some(DomRoot::from_ref(&*start_node)), parent)
            },
            _ => {
                // Steps 4-5.
                let child = start_node.ChildNodes(can_gc).Item(start_offset);
                (child, DomRoot::from_ref(&*start_node))
            },
        };

        // Step 6.
        Node::ensure_pre_insertion_validity(node, &parent, reference_node.as_deref())?;

        // Step 7.
        let split_text;
        let reference_node = match start_node.downcast::<Text>() {
            Some(text) => {
                split_text = text.SplitText(start_offset, can_gc)?;
                let new_reference = DomRoot::upcast::<Node>(split_text);
                assert!(new_reference.GetParentNode().as_deref() == Some(&parent));
                Some(new_reference)
            },
            _ => reference_node,
        };

        // Step 8.
        let reference_node = if Some(node) == reference_node.as_deref() {
            node.GetNextSibling()
        } else {
            reference_node
        };

        // Step 9.
        node.remove_self(can_gc);

        // Step 10.
        let new_offset = reference_node
            .as_ref()
            .map_or(parent.len(), |node| node.index());

        // Step 11
        let new_offset = new_offset +
            if let NodeTypeId::DocumentFragment(_) = node.type_id() {
                node.len()
            } else {
                1
            };

        // Step 12.
        Node::pre_insert(node, &parent, reference_node.as_deref(), can_gc)?;

        // Step 13.
        if self.collapsed() {
            self.set_end(&parent, new_offset);
        }

        Ok(())
    }

    /// <https://dom.spec.whatwg.org/#dom-range-deletecontents>
    fn DeleteContents(&self) -> ErrorResult {
        // Step 1.
        if self.collapsed() {
            return Ok(());
        }

        // Step 2.
        let start_node = self.start_container();
        let end_node = self.end_container();
        let start_offset = self.start_offset();
        let end_offset = self.end_offset();

        // Step 3.
        if start_node == end_node {
            if let Some(text) = start_node.downcast::<CharacterData>() {
                if end_offset > start_offset {
                    self.report_change();
                }
                return text.ReplaceData(start_offset, end_offset - start_offset, DOMString::new());
            }
        }

        // Step 4.
        rooted_vec!(let mut contained_children);
        let ancestor = self.CommonAncestorContainer();

        let mut iter = start_node.following_nodes(&ancestor);

        let mut next = iter.next();
        while let Some(child) = next {
            if self.contains(&child) {
                contained_children.push(Dom::from_ref(&*child));
                next = iter.next_skipping_children();
            } else {
                next = iter.next();
            }
        }

        let (new_node, new_offset) = if start_node.is_inclusive_ancestor_of(&end_node) {
            // Step 5.
            (DomRoot::from_ref(&*start_node), start_offset)
        } else {
            // Step 6.
            fn compute_reference(start_node: &Node, end_node: &Node) -> (DomRoot<Node>, u32) {
                let mut reference_node = DomRoot::from_ref(start_node);
                while let Some(parent) = reference_node.GetParentNode() {
                    if parent.is_inclusive_ancestor_of(end_node) {
                        return (parent, reference_node.index() + 1);
                    }
                    reference_node = parent;
                }
                unreachable!()
            }

            compute_reference(&start_node, &end_node)
        };

        // Step 7.
        if let Some(text) = start_node.downcast::<CharacterData>() {
            text.ReplaceData(
                start_offset,
                start_node.len() - start_offset,
                DOMString::new(),
            )
            .unwrap();
        }

        // Step 8.
        for child in &*contained_children {
            child.remove_self(CanGc::note());
        }

        // Step 9.
        if let Some(text) = end_node.downcast::<CharacterData>() {
            text.ReplaceData(0, end_offset, DOMString::new()).unwrap();
        }

        // Step 10.
        self.SetStart(&new_node, new_offset).unwrap();
        self.SetEnd(&new_node, new_offset).unwrap();
        Ok(())
    }

    /// <https://dom.spec.whatwg.org/#dom-range-surroundcontents>
    fn SurroundContents(&self, new_parent: &Node, can_gc: CanGc) -> ErrorResult {
        // Step 1.
        let start = self.start_container();
        let end = self.end_container();

        if start
            .inclusive_ancestors(ShadowIncluding::No)
            .any(|n| !n.is_inclusive_ancestor_of(&end) && !n.is::<Text>()) ||
            end.inclusive_ancestors(ShadowIncluding::No)
                .any(|n| !n.is_inclusive_ancestor_of(&start) && !n.is::<Text>())
        {
            return Err(Error::InvalidState);
        }

        // Step 2.
        match new_parent.type_id() {
            NodeTypeId::Document(_) |
            NodeTypeId::DocumentType |
            NodeTypeId::DocumentFragment(_) => {
                return Err(Error::InvalidNodeType);
            },
            _ => (),
        }

        // Step 3.
        let fragment = self.ExtractContents(can_gc)?;

        // Step 4.
        Node::replace_all(None, new_parent, can_gc);

        // Step 5.
        self.InsertNode(new_parent, can_gc)?;

        // Step 6.
        new_parent.AppendChild(fragment.upcast(), can_gc)?;

        // Step 7.
        self.SelectNode(new_parent)
    }

    /// <https://dom.spec.whatwg.org/#dom-range-stringifier>
    fn Stringifier(&self) -> DOMString {
        let start_node = self.start_container();
        let end_node = self.end_container();

        // Step 1.
        let mut s = DOMString::new();

        if let Some(text_node) = start_node.downcast::<Text>() {
            let char_data = text_node.upcast::<CharacterData>();

            // Step 2.
            if start_node == end_node {
                return char_data
                    .SubstringData(self.start_offset(), self.end_offset() - self.start_offset())
                    .unwrap();
            }

            // Step 3.
            s.push_str(
                &char_data
                    .SubstringData(
                        self.start_offset(),
                        char_data.Length() - self.start_offset(),
                    )
                    .unwrap(),
            );
        }

        // Step 4.
        let ancestor = self.CommonAncestorContainer();
        let iter = start_node
            .following_nodes(&ancestor)
            .filter_map(DomRoot::downcast::<Text>);

        for child in iter {
            if self.contains(child.upcast()) {
                s.push_str(&child.upcast::<CharacterData>().Data());
            }
        }

        // Step 5.
        if let Some(text_node) = end_node.downcast::<Text>() {
            let char_data = text_node.upcast::<CharacterData>();
            s.push_str(&char_data.SubstringData(0, self.end_offset()).unwrap());
        }

        // Step 6.
        s
    }

    /// <https://html.spec.whatwg.org/multipage/#dom-range-createcontextualfragment>
    fn CreateContextualFragment(
        &self,
        fragment: TrustedHTMLOrString,
        can_gc: CanGc,
    ) -> Fallible<DomRoot<DocumentFragment>> {
        // Step 2. Let node be this's start node.
        //
        // Required to obtain the global, so we do this first. Shouldn't be an
        // observable difference.
        let node = self.start_container();
        // Step 1. Let compliantString be the result of invoking the
        // Get Trusted Type compliant string algorithm with TrustedHTML,
        // this's relevant global object, string, "Range createContextualFragment", and "script".
        let fragment = TrustedHTML::get_trusted_script_compliant_string(
            node.owner_window().upcast(),
            fragment,
            "Range createContextualFragment",
            can_gc,
        )?;
        let owner_doc = node.owner_doc();
        let element = match node.type_id() {
            // Step 3. Let element be null.
            NodeTypeId::Document(_) | NodeTypeId::DocumentFragment(_) => None,
            // Step 4. If node implements Element, set element to node.
            NodeTypeId::Element(_) => Some(DomRoot::downcast::<Element>(node).unwrap()),
            // Step 5. Otherwise, if node implements Text or Comment, set element to node's parent element.
            NodeTypeId::CharacterData(CharacterDataTypeId::Comment) |
            NodeTypeId::CharacterData(CharacterDataTypeId::Text(_)) => node.GetParentElement(),
            NodeTypeId::CharacterData(CharacterDataTypeId::ProcessingInstruction) |
            NodeTypeId::DocumentType => unreachable!(),
            NodeTypeId::Attr => unreachable!(),
        };

        // Step 6. If element is null or all of the following are true:
        let element = Element::fragment_parsing_context(&owner_doc, element.as_deref(), can_gc);

        // Step 7. Let fragment node be the result of invoking the fragment parsing algorithm steps with element and compliantString.
        let fragment_node = element.parse_fragment(fragment, can_gc)?;

        // Step 8. For each script of fragment node's script element descendants:
        for node in fragment_node
            .upcast::<Node>()
            .traverse_preorder(ShadowIncluding::No)
        {
            if let Some(script) = node.downcast::<HTMLScriptElement>() {
                // Step 8.1. Set script's already started to false.
                script.set_already_started(false);
                // Step 8.2. Set script's parser document to null.
                script.set_parser_inserted(false);
            }
        }

        // Step 9. Return fragment node.
        Ok(fragment_node)
    }

    /// <https://drafts.csswg.org/cssom-view/#dom-range-getclientrects>
    fn GetClientRects(&self, can_gc: CanGc) -> DomRoot<DOMRectList> {
        let start = self.start_container();
        let window = start.owner_window();

        let client_rects = self
            .client_rects()
            .map(|rect| {
                DOMRect::new(
                    window.upcast(),
                    rect.origin.x.to_f64_px(),
                    rect.origin.y.to_f64_px(),
                    rect.size.width.to_f64_px(),
                    rect.size.height.to_f64_px(),
                    can_gc,
                )
            })
            .collect();

        DOMRectList::new(&window, client_rects, can_gc)
    }

    /// <https://drafts.csswg.org/cssom-view/#dom-range-getboundingclientrect>
    fn GetBoundingClientRect(&self, can_gc: CanGc) -> DomRoot<DOMRect> {
        let window = self.start_container().owner_window();

        // Step 1. Let list be the result of invoking getClientRects() on the same range this method was invoked on.
        let list = self.client_rects();

        // Step 2. If list is empty return a DOMRect object whose x, y, width and height members are zero.
        // Step 3. If all rectangles in list have zero width or height, return the first rectangle in list.
        // Step 4. Otherwise, return a DOMRect object describing the smallest rectangle that includes all
        // of the rectangles in list of which the height or width is not zero.
        let bounding_rect = list.fold(euclid::Rect::zero(), |acc, rect| acc.union(&rect));

        DOMRect::new(
            window.upcast(),
            bounding_rect.origin.x.to_f64_px(),
            bounding_rect.origin.y.to_f64_px(),
            bounding_rect.size.width.to_f64_px(),
            bounding_rect.size.height.to_f64_px(),
            can_gc,
        )
    }
}

#[derive(MallocSizeOf)]
pub(crate) struct WeakRangeVec {
    cell: RefCell<WeakRefVec<Range>>,
}

impl Default for WeakRangeVec {
    fn default() -> Self {
        WeakRangeVec {
            cell: RefCell::new(WeakRefVec::new()),
        }
    }
}

#[allow(unsafe_code)]
impl WeakRangeVec {
    /// Whether that vector of ranges is empty.
    pub(crate) fn is_empty(&self) -> bool {
        self.cell.borrow().is_empty()
    }

    /// Used for steps 2.1-2. when inserting a node.
    /// <https://dom.spec.whatwg.org/#concept-node-insert>
    pub(crate) fn increase_above(&self, node: &Node, offset: u32, delta: u32) {
        self.map_offset_above(node, offset, |offset| offset + delta);
    }

    /// Used for steps 4-5. when removing a node.
    /// <https://dom.spec.whatwg.org/#concept-node-remove>
    pub(crate) fn decrease_above(&self, node: &Node, offset: u32, delta: u32) {
        self.map_offset_above(node, offset, |offset| offset - delta);
    }

    /// Used for steps 2-3. when removing a node.
    ///
    /// <https://dom.spec.whatwg.org/#concept-node-remove>
    pub(crate) fn drain_to_parent(&self, context: &UnbindContext, child: &Node) {
        if self.is_empty() {
            return;
        }

        let offset = context.index();
        let parent = context.parent;
        let ranges = &mut *self.cell.borrow_mut();

        ranges.update(|entry| {
            let range = entry.root().unwrap();
            if range.start().node() == parent || range.end().node() == parent {
                entry.remove();
            }
            if range.start().node() == child {
                range.report_change();
                range.start().set(context.parent, offset);
            }
            if range.end().node() == child {
                range.report_change();
                range.end().set(context.parent, offset);
            }
        });

        context
            .parent
            .ranges()
            .cell
            .borrow_mut()
            .extend(ranges.drain(..));
    }

    /// Used for steps 6.1-2. when normalizing a node.
    /// <https://dom.spec.whatwg.org/#dom-node-normalize>
    pub(crate) fn drain_to_preceding_text_sibling(&self, node: &Node, sibling: &Node, length: u32) {
        if self.is_empty() {
            return;
        }

        let ranges = &mut *self.cell.borrow_mut();

        ranges.update(|entry| {
            let range = entry.root().unwrap();
            if range.start().node() == sibling || range.end().node() == sibling {
                entry.remove();
            }
            if range.start().node() == node {
                range.report_change();
                range.start().set(sibling, range.start_offset() + length);
            }
            if range.end().node() == node {
                range.report_change();
                range.end().set(sibling, range.end_offset() + length);
            }
        });

        sibling.ranges().cell.borrow_mut().extend(ranges.drain(..));
    }

    /// Used for steps 6.3-4. when normalizing a node.
    /// <https://dom.spec.whatwg.org/#dom-node-normalize>
    pub(crate) fn move_to_text_child_at(
        &self,
        node: &Node,
        offset: u32,
        child: &Node,
        new_offset: u32,
    ) {
        let child_ranges = child.ranges();
        let mut child_ranges = child_ranges.cell.borrow_mut();

        self.cell.borrow_mut().update(|entry| {
            let range = entry.root().unwrap();

            let node_is_start = range.start().node() == node;
            let node_is_end = range.end().node() == node;

            let move_start = node_is_start && range.start_offset() == offset;
            let move_end = node_is_end && range.end_offset() == offset;

            let remove_from_node =
                move_start && (move_end || !node_is_end) || move_end && !node_is_start;

            let already_in_child = range.start().node() == child || range.end().node() == child;
            let push_to_child = !already_in_child && (move_start || move_end);

            if remove_from_node {
                let ref_ = entry.remove();
                if push_to_child {
                    child_ranges.push(ref_);
                }
            } else if push_to_child {
                child_ranges.push(WeakRef::new(&range));
            }

            if move_start {
                range.report_change();
                range.start().set(child, new_offset);
            }
            if move_end {
                range.report_change();
                range.end().set(child, new_offset);
            }
        });
    }

    /// Used for steps 8-11. when replacing character data.
    /// <https://dom.spec.whatwg.org/#concept-cd-replace>
    pub(crate) fn replace_code_units(
        &self,
        node: &Node,
        offset: u32,
        removed_code_units: u32,
        added_code_units: u32,
    ) {
        self.map_offset_above(node, offset, |range_offset| {
            if range_offset <= offset + removed_code_units {
                offset
            } else {
                range_offset + added_code_units - removed_code_units
            }
        });
    }

    /// Used for steps 7.2-3. when splitting a text node.
    /// <https://dom.spec.whatwg.org/#concept-text-split>
    pub(crate) fn move_to_following_text_sibling_above(
        &self,
        node: &Node,
        offset: u32,
        sibling: &Node,
    ) {
        let sibling_ranges = sibling.ranges();
        let mut sibling_ranges = sibling_ranges.cell.borrow_mut();

        self.cell.borrow_mut().update(|entry| {
            let range = entry.root().unwrap();
            let start_offset = range.start_offset();
            let end_offset = range.end_offset();

            let node_is_start = range.start().node() == node;
            let node_is_end = range.end().node() == node;

            let move_start = node_is_start && start_offset > offset;
            let move_end = node_is_end && end_offset > offset;

            let remove_from_node =
                move_start && (move_end || !node_is_end) || move_end && !node_is_start;

            let already_in_sibling =
                range.start().node() == sibling || range.end().node() == sibling;
            let push_to_sibling = !already_in_sibling && (move_start || move_end);

            if remove_from_node {
                let ref_ = entry.remove();
                if push_to_sibling {
                    sibling_ranges.push(ref_);
                }
            } else if push_to_sibling {
                sibling_ranges.push(WeakRef::new(&range));
            }

            if move_start {
                range.report_change();
                range.start().set(sibling, start_offset - offset);
            }
            if move_end {
                range.report_change();
                range.end().set(sibling, end_offset - offset);
            }
        });
    }

    /// Used for steps 7.4-5. when splitting a text node.
    /// <https://dom.spec.whatwg.org/#concept-text-split>
    pub(crate) fn increment_at(&self, node: &Node, offset: u32) {
        self.cell.borrow_mut().update(|entry| {
            let range = entry.root().unwrap();
            if range.start().node() == node && offset == range.start_offset() {
                range.report_change();
                range.start().set_offset(offset + 1);
            }
            if range.end().node() == node && offset == range.end_offset() {
                range.report_change();
                range.end().set_offset(offset + 1);
            }
        });
    }

    fn map_offset_above<F: FnMut(u32) -> u32>(&self, node: &Node, offset: u32, mut f: F) {
        self.cell.borrow_mut().update(|entry| {
            let range = entry.root().unwrap();
            let start_offset = range.start_offset();
            if range.start().node() == node && start_offset > offset {
                range.report_change();
                range.start().set_offset(f(start_offset));
            }
            let end_offset = range.end_offset();
            if range.end().node() == node && end_offset > offset {
                range.report_change();
                range.end().set_offset(f(end_offset));
            }
        });
    }

    pub(crate) fn push(&self, ref_: WeakRef<Range>) {
        self.cell.borrow_mut().push(ref_);
    }

    fn remove(&self, range: &Range) -> WeakRef<Range> {
        let mut ranges = self.cell.borrow_mut();
        let position = ranges.iter().position(|ref_| ref_ == range).unwrap();
        ranges.swap_remove(position)
    }
}

#[allow(unsafe_code)]
unsafe impl JSTraceable for WeakRangeVec {
    unsafe fn trace(&self, _: *mut JSTracer) {
        self.cell.borrow_mut().retain_alive()
    }
}