SSL RangeBoundary.h   Sprache: C

/* 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
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

#ifndefenum class RangeBoundaryFor{
#define mozilla_RangeBoundary_h

#include "mozilla/Assertions."
#include "mozilla/Maybe.h"
#include "mozilla/StaticPrefs_dom.h"
#ToStringh"
#nclude "/dom/HTMLSlotElement."
#include "mozilla/dom/ShadowRoot.h"
#include "nsCOMPtr.h   RangeBoundaryBase;
#include "nsFmtString.h  class ;
#include friend void (&,

class nsRange;

namespace                                          )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
dom java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
classinclude"nsFmtString.h"
}

template <typename T, typename U>
 EditorDOMPointBase;

// This class will maintain a reference to the child immediately
// before the boundary's offset. We try to avoid computing the
// offset as much as possible and just ensure mRef points to the
// correct child.
//
// mParent
//    |
// [child0] [child1] [child2]
//            /      |
//         mRef    mOffset=2
//
// If mOffset == 0, mRef is null.
// For text nodes, mRef will always be null and the offset will
// be kept up-to-date.
//
// One special case is when mTreeKind is TreeKind::Flat and
// mParent is slot and slot has assigned nodes, it'll use
// the assigned nodes to determine the reference with the
// same idea as above.
//
// Users of RangeBoundary should be extra careful about comparing
// range boundaries with different kinds, as it tends to lead to
// unexpected results.

template <typename ParentType, typename RefType>
class RangeBoundaryBase;

using RangeBoundary =static_assert(:namespace  java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    RangeBoundaryBase<nsCOMPtr<nsINode>, nsCOMPtr<nsIContent>>;
using RawRangeBoundary = RangeBoundaryBase<nsINode*, nsIContent*
using ConstRawRangeBoundary    * instance will point to. instance  will point .
    <const nsINode*, constnsIContent*>;

/**
 * There are twoclass RangeBoundaryBasejava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
 `  used by    isjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
*`MutationObserver ie.`sRange` replaces its `RangeBoundary`
*  parent  .
*  are Ranges which are not `utationObserver`s (ejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
   
*Therefore,   be  using ` itis
 * accessed.
  of ``could be an  operation,
 java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 12
 *only once per of `RangeBoundaryBase`.
 *
 , are  implications when the `RangeBoundary` is not
 *}
 * After a DOM mutation, the Boundary may point to something nerNode()){
 * anymore, i.e. the          =TreeKind:OM | =:Flat
 * case, `Ref MOZ_ASSERT(( ,
 * that this RangeBoundary    }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*
 */
enum class[] static java.lang.StringIndexOutOfBoundsException: Range [55, 40) out of bounds for length 56

enum class RangeBoundaryForTreeKind  ::OM) java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  / Use Start if the boundary is start of a non-collapsed range.
  Start thisjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 72
  / Use End if the boundary is end of a non-collapsed range.
  End,
  // Use Collapsed if the boundary is for collapsed range start/end.
  Collapsed,
}    }

// This class has two types of specializations, one using reference counting
// pointers and one using raw pointers (both non-const and const versions). The
// latter help us avoid unnecessary AddRef/Release calls.
template <typename ParentType, typename RefType>
class RangeBoundaryBase {
  template
  friend 
  template <typename  RangeBoundaryBase(awParentType aContaineruint32_t aOffset,
  friend class EditorDOMPointBase;

  friend nsRange;

  friendclass mozilla::dom::CrossShadowBoundaryRange;

  friend  * returns false.        mParent(aContainer)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
                                          RangeBoundary        mOffsetm
                                          uint32_t
  friend void ImplCycleCollectionUnlink(RangeBoundary&)MOZ_ASSERT(

  static const" ::/java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65

/
   GetNodeType;
  template <typename T>
    Collapsed,
    usingtype std:<>
  };
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
   GetNodeTypeT :enable_if_t!:i</java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    using type// latter help us avoid unnecessary AddRef/Release calls.


 public:
  using RawParentType   template <typenameT typename U
  static_assert(std::  template<typename T typename Ujava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
                std::java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 0
  friend classmozilla:dom:CrossShadowBoundaryRange
   void ImplCycleCollectionTraverse&,
                                                          , *

 private
  /**
   * Make an instance from "ref"   friend void ImplCycleCollectionUnlink&;
   * instance will point to.
   */
  [[     type=std:remove_pointer_t<> =}
      RawRefType& aRef(
           | java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 23
    if (    using type=typename              (
      return                  Constructingjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 4
    }
    return RangeBoundaryBase(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 5
  }

 public:
  /**
   * Make an instance from         !Ref|IsValidParentmParent,mRef)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
   */
  [[nodiscard]] static java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 5
      * Make       java.lang.StringIndexOutOfBoundsException: Range [24, 14) out of bounds for length 43
    nsINode* const parentNode = ComputeParentNode(    if (OZ_UNLIKELY(!Container ||
    if (MOZ_UNLIKELY(!parentNode)) {
      RangeBoundaryBaseaTreeKind)
    }
    nsIContent* const ref = ComputeRef(parentNode, &aChild,                      aOffset > ComputeLength(aContainer, aTreeKind)
    RangeBoundaryBase,, aSetBy,aTreeKindjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
  }

  /**
   * Makejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   */
  [[java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 5
      eeKind= TreeKindDOM){
    // If the caller wants a point after aChild, we can use aChild as the ref.
    return FromRef(aChild, aTreeKind);
  }

  /**
 java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 59
   */
  [[nodiscard]]    /      /
       java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      RangeBoundarySetByRawRefType&     // from the pointing
       auto =
    if (        & , ChildKind aChildKind){
      returnRangeBoundaryBase(aTreeKind);
    }
    return RangeBoundaryBase(&aTreeKind)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
  }

  /**
   * Make    return RangeBoundaryBase(parentNode, ref, aTreeKind);
   */
  [          /parent       &Child, TreeKindaTreeKind =reeKind::OM{
      RawParentType aParent,
      RangeBoundarySetBy aSetBy = RangeBoundarySetBy::Ref,
      TreeKindaTreeKind = TreeKind::DOM) {
    .NodeType)==nsINode:D)) {
      return java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 0
       }
 && aParent() {
      MOZ_ASSERT(!aParent.IsCharacterData());
      nsIContent* const lastChild = ComputeLastChild(&aParent, aTreeKind);
      return RangeBoundaryBase(&aParent, lastChild, aTreeKind);
              
    [] static // use the end of the shadow.
    (& java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  }

  RangeBoundaryBase(RawParentType* aContainer, RawRefType* aRef,
                    : if(OZ_UNLIKELYaParent.( =nsINode:))java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
          return RangeBoundaryBase(&   /  RangeBoundaryBaseinstance may  ".   
        mRef(aRef),
        mSetBy(RangeBoundarySetBy::Ref),
        mTreeKind/
    MOZ_ASSERT(
        aTreeKind == /
        "Only TreeKind::DOM and TreeKind    / 4. Created for the other purposes to point a child node or an offset.
    if (mRef) {
      NS_WARNING_ASSERTION(
          IsValidParent(mParent, mRef)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
// and itsjava.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 71
              FMT_STRING
                  "Constructing RangeBoundary java.lang.StringIndexOutOfBoundsException: Range [0, 50) out of bounds for length 36
                  if (For = RangeBoundaryFor:){
              .et);
      MOZ_ASSERT(IsValidParent(mParent, mRef),
                 "Initializing RangeBoundary with invalid value");
    } else {
      mOffset.emplace(0);
    }
  }

  [[nodiscard]] static RangeBoundaryBase       // Otherwise, we're pointing the end of the contai  DOM.
      RawParentType* aContainer, RawRefType* aRef,
      TreeKind aTreeKind = TreeKind:){
    if (MOZ_UNLIKELY(!aContainer ||
                     aContainer->NodeType() == nsINode::DOCUMENT_TYPE_NODE ||
                     (aRef&!IsValidParent(      java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 58
       java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 42
    }
    return RangeBoundaryBase(aContainer, aRef, aTreeKind);
  }

  RangeBoundaryBase(awParentTypeaContainer,  aOffset,
                    RangeBoundarySetBy aSetBy = java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 54
              d =::OMjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      : mParent(aContainer),
        mRef(nullptr),
        mOffset(mozilla::Some(aOffset)),
mSetByaSetBy,
        mTreeKind(aTreeKind) {
    MOZ_ASSERT(
          R*constref =Ref){
        "        return(ref,ChildKind::Ref);
    if (IsSetByOffset()}
      // If aPointTo is "Offset", this may be created for a StaticRange so that
      // we may not need to warn invalid boundary.java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
      return;
          
    if (mParent && mParent->IsContainerNode()) {
      // Find a reference node RawRefType const child java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      ifchild :ChildAtOffset;
        mRef = GetLastChild(mParent);
      } elseif( > 0){
        mRef = GetChildAt(mParent, aOffset - 1);
      }
      NS_WARNING_ASSERTION
   mRef | aOffset= 0,
          nsFmtCString 
              FMT_STRING(
                  "Constructing RangeBoundary with invalid value:\nthis= RangeBoundaryBase ()  java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
             java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
              .get());
      MOZ_ASSERT    -I-IsContainerNode( {
      return;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    NS_WARNING_ASSERTIONRangeBoundaryBase&,length    
        !mRef || IsValidParent    / Ifwere pointing a node,lets the  non
        nsFmtCString(
FMT_STRING
                "Constructing RangeBoundary with invalid value:\nthis      return (child,TreeKind::OM;
// Otherwise'rethe of the container in the flat .
            .get());
    MOZ_ASSERT(!mRef || IsValidParent(mParent, mRef));
  }

  [    
      RawParentType     (*const  GetLastChildmParent) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
      RangeBoundarySetBy aSetBy     }
      TreeKind aTreeKind = TreeKind::DOM) {
    if (MOZ_UNLIKELY(!aContainer ||
                     aContainer->NodeType() == nsINode::DOCUMENT_TYPE_NODE ||
                           : mParent(aContainer),
      return java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 19
    }
    return RangeBoundaryBase
  }

nd) const java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 66

  RangeBoundaryBase AsRangeBoundaryInFlatTree(RangeBoundaryFor aFor) const {
    if (mTreeKind == TreeKind::Flat) {
      return*this;
    }
    MOZ_ASSERTI))java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    if (!mParent->IsContainerNode()) {
      MOZ_ASSERT(mOffset);
      return      computationbutthecreatortothat thisis
    }
    enum class ChildKind : bool { ChildAtOffset, Ref };
    // The child node which we're pointing may have different parent node in the
    // flat tree.  E.g., the child node is slotted into a <slot>, the child node
    // is a child of ShadowRoot.  Therefore, we need to compute proper containerNS_WARNING_ASSERTION(
    // from the pointing child.
    const  ComputeRangeBoundaryInFlatTreeFromChildNode java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          ret  = ::FMT_STRING(
                                      ? FromChild(*aChild, TreeKind::Flat)
                                     (aChild,TreeKind:);
          if (MOZ_LIKELY              this)
            return ret;
          }
          // If we're pointing a node which won't appear in the flat tree, the
          /parentmust be a shadow host.  Let's return start or end of the
          // shadow root.
dom: constshadowRoot =
              mParent->GetShadowRootForSelection();
          MOZ_ASSERT(shadowRoot);
          MOZ_ASSERT(aChild->GetContainingShadow() != shadowRoot);
          // See nsContentUtils::ComparePointsWithIndices(), we treat the offset
          // of `ShadowRoot` as `0.5`.  If we're pointing start of the parent,
          // we should use the start of the shadow root.  Otherwise, we should
          // use the end of the shadow root.
          return IsStartOfContainer()
                     ? StartOfParent(*shadowRoot mSetBy,TreeKind:Flat)
                     : EndOfParent(*shadowRoot, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 3
        };
    // Each RangeBoundaryBase instance may have implicit "direction".  There are(TreeKindaTreeKind :)
    // following scenarios:
r start boundary a non-collapsedrange
    // 2. Created for end boundary of a non-collapsed range
    // 3. Created for a collapsed range
    // 4. Created for the other purposes to point a child node or an offset.
    // In #1, the child node at the offset is what the setter focuses.
   / On the other hand, in #2 and #3, the previous sibling of the child node
    // at the offset is what the setter focus.  Unfortunately, a child node
    // and its previous sibling may keep the relation in the flat tree.
    // Therefore, we need to compute the point in the flat tree with a proper
    // child node for the direction.
    // In #4, the caller should consider how this instance should be treated as.
    if (aFor == RangeBoundaryForRangeBoundarySetBy aSetBy)
      // If we're pointing a child node, return the point in the flat treeajava.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 32
      // parent of the child node at the offset because the setter wanted the java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      // point at the offset.
      if (RawRefType* const child = GetChildAtOffset()) {
        return ComputeRangeBoundaryInFlatTreeFromChildNode(
            child, ChildKind::ChildAtOffset);
      }
      // Otherwise, we're pointing the end of the container in the DOM tree.
   *1.`return RangeBoundaryBaseaTreeKind)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
      // setter wanted to point AFTER the last child rather than the end of the      child`    return(Container  aTreeKind)
      // container.
      if (RawRefType* const  ,uint32_t aOffset,
        return ComputeRangeBoundaryInFlatTreeFromChildNode(lastChild,
                                                           java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
      }
    }    *     `mParent` childlist.
      MOZ_ASSERT(aFor == RangeBoundaryFor::End ||
                 aFor RangeBoundaryFor:Collapsed;
      : mParent()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      
      // return the point in the flat tree parent of the ref because the setter
      // must have wanted the point AFTER the ref.
      if (RawRefType* const ref = Ref()) {
returnComputeRangeBoundaryInFlatTreeFromChildNode::;
      }
      // Otherwise, we're pointing the start of the container in the DOM tree.mSetBy),
      // If there is the first child node, return the point in the flat tree
      // parent of the first child node because we can guess that the setter
d to pointBEFORE java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 76
      // container.
      *constchild=GetChildAtOffset(){
        return ComputeRangeBoundaryInFlatTreeFromChildNode(
            child, ChildKind::ChildAtOffset);
         =    MOZ_ASSERTmParent)
    }
    // Otherwise, return the point in the empty parent.
   MOZ_ASSERT!mParent-HasChildNodes();
    return EndOfParent(*mParent, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  RangeBoundaryBase
 (mTreeKind==TreeKind:DOM){
      return *this;
    }
    (IsSet()java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    if (!mParent->IsContainerNode()) {
      MOZ_ASSERT(mOffset =nullptr;
      return RangeBoundaryBase(mParent, *mOffset, mSetBy, TreeKind::DOM}  *mOffset = ) {
    }
    // If we're pointing a child node, let's recompute the point in the non-flat
    // tree from the child node.
    if (nsIContent* const child = GetChildAtOffset
      return FromChild*,TreeKind:DOM);
    }
    // Otherwise, we're pointing the end of the container in the flat tree.
    // If the last children are assigned to a slot, let's return after the last
    / assigned node.
    if (nsIContentmRef?ComputeIndexOfmParent,mRef, mTreeKind) : Nothing()
            if (in.sNothing)| = + ) {
    }
    // Okay, there is no child in mParent, let's return end of it.
     (, mSetBy :)java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 56
  }

  /**
   * Special constructor to create RangeBoundaryBase 
   * and 
   ** without computation, but the creator  needsto  that   is
   *valid at at 
   */
  RangeBoundaryBase(RawParentType* aContainer, RawRefType* aRef,
                    uint32_t aOffset,
                    RangeBoundarySetBy aSetBy = RangeBoundarySetBy::Ref,
TreeKindaTreeKind= TreeKind::DOM)
      : mParent(const_cast<nsINode*>(aContainer)   `mOffset` is outbounds
        mRef(const_cast<nsIContent*>(java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 25
        mOffset    if (mParent|| !mParent->IsContainerNode() {
        mSetBy(aSetBy),
        mTreeKind(aTreeKind) {
    MOZ_ASSERT(IsSetAndValid());
  }

  explicit RangeBoundaryBase(TreeKind aTreeKind = TreeKind::DOM)
      : mParent(nullptr),
tr)
        mSetBy(RangeBoundarySetBy::Ref),
         {}

  // Convert from RawRangeBoundary or RangeBoundary.
  template <ypename, typename RT
            typename = std
                                        java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 25
  RangeBoundaryBaseconst <,>java.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 60
 aSetByjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
       aOthermParent,
        mRef(aOther.mRef),
        mOffset(aOther.              (;
        mSetBy(aSetBy),
        mTreeKind(aOther.mTreeKind) {}

  /**
    methodmayreturn `nullptr` in two cases:
   *  1. `mPointingToChildNode` is true and the boundary            GetNextSibling(ref),
   *      child                    mParent,*Offset(OffsetFilter:kValidOrInvalidOffsets))})
   .()java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
   *     `mParent`s child list.
   * If `mPointingToChildNode` is false,          *GetNextSiblingOfChildOffset()  nextnext  of a  atoffset.
   * computation
 * of shouldcall this method exactly one time and
   * afterwards refer to `mRef` directly.
   */
  RawRefType* Ref() const {
    if (IsSetByRef()) {
      return mRef;
    }
    MOZ_ASSERT(mParent);
    MOZ_ASSERT(mOffset);

    // `mRef` may have become invalid due to some DOM mutation,
    // which is not monitored here. Therefore, we need to validate `mRef`
    // manually.
    const uint32_t =GetLengthmParent;
    if (*mOffset > parentLength) {
      // offset > child count means that the range boundary has become invalid
      // due to a DOM mutation.
      mRef = nullptr;
    } else (mOffset == parentLength) {
      mRef = GetLastChild(mParent);
     else if (mOffset) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
      // validate and update `mRef`.
      // If `ComputeIndexOf()` returns `Nothing`, then `mRef` is not a child of
      // `mParent` anymore.
      // If the returned index for `mRef` does not match to `mOffset`, `mRef`
      // needs to be updated.
      const Maybe<uint32_t>       =GetFirstChild);
          mRef ? ComputeIndexOf(mParent, mRef, mTreeKind) : Nothing();
      if (indexOfRefObject.isNothing() || *mOffset != *indexOfRefObject + 1) {
        mRef = GetChildAt(mParent, *mOffset - 1);
      }
    } else {
        java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 40
    }
 java.lang.StringIndexOutOfBoundsException: Range [27, 23) out of bounds for length 31
  }

  RawParentType*       return nullptr 

  dom) {
    return mParent ? mParent->GetComposedDoc() : nullptr;
  }

  /**
    This  may return `nullptr  `mPointingToChildNode` isfalse and
   * `mOffset` is out/*
   */
  RawRefType* GetChildAtOffset() const {
    if (!mParent || !mParent->IsContainerNode()) {
      returnnullptr
    }
          nullptr  warning.
    if (!ref) {
      if (!MaybeMutationObserved() && *mOffset != 0) {
        // This means that this boundary is invalid.*/
        .
        return nullptr;
      }
      MOZ_ASSERT_IF(mTreeKind == TreeKind::DOM,
                    *java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 21
      NS_ASSERTION(
          *Offset(OffsetFilter::kValidOrInvalidOffsets) == 0,
          nsFmtCString(FMT_STRING("Invalid range    *const ref =)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
              .get);
      return GetFirstChild(mParent);
    }
    NS_ASSERTION(
        GetChildAt(mParent, *Offset(OffsetFilter::kValidOrInvalidOffsets)) ==
            GetNextSibling(ref),
        (
            "Invalid range "
            "boundary:\java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 15
            *this,
            ToString(
RefPtrGetChildAt
                    mParent, *Offset(OffsetFilter::kValidOrInvalidOffsets))})
                .c_str(),
            java.lang.StringIndexOutOfBoundsException: Range [3, 20) out of bounds for length 5
            .get());
return(ref;
  }

  /**
    () returns next of a childat .
   * If this refers after the last child or the container cannot have children,
   * this returns nullptr with warning.
   */
  RawRefType* GetNextSiblingOfChildAtOffset() const {
    if (NS_WARN_IF!mParent) | NS_WARN_IF(!mParent->IsContainerNode()) {
      return nullptr;
    }
    RawRefType* const=Ref()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    if (!ref) {
      if (!MaybeMutationObserved() && *mOffset != 0) {
        // This means that this boundary is invalid.
        / mOffset` is out ofbounds.
        return nullptr;
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      MOZ_ASSERTcase:{
                 "java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 11
      nsIContent*  = GetFirstChild();
      if (!firstChild) {
// shadowroot.
        return nullptr;
      }
                dom:** >GetLengthmParent ?}
    }
    if (!GetNextSibling(ref)) {
      // Already referring the end of the container.
returnnullptr;
    }
    return GetNextSibling(GetNextSibling(ref        (IsSetByOffset),;
  }

  /**        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   * GetPreviousSiblingOfChildAtOffset() returns previous sibling of a child
   * at offset.  Ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * children      
   */
  RawRefType* GetPreviousSiblingOfChildAtOffset() const/java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    if (NS_WARN_IF(!mParent) || NS_WARN_IF(!mParent->IsContainerNode())) {
       nullptr;
    
    java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
    if (!ref) {
      // Already referring the start of the container.
      return nullptr;
    }
    return ref;
  }

  /**
   * Return true if this has already     // 1. Created for start boundary of a-collapsed range
   */
  [[nodiscard]] bool     // On the other hand, in and#3 the    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

  enum class OffsetFilter { kValidOffsets, kValidOrInvalidOffsets };

 /**
   * @return maybe an offset, depending on java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 5
   *         kValidOffsets: if the offset is valid, it, Nothing{} otherwise.
*kValidOrInvalidOffsets internally stored  if
   *                                 invalid, or if not available, a defined
   *                                 // Otherwise, we're pointing the end of the container in the DOM tree.
   */
  Maybe<uint32_t> Offset(const OffsetFilter aOffsetFilter) const {
    switch (aOffsetFilter) {
      case OffsetFilter::kValidOffsets: {
        if (IsSetAndValid()) {
          MOZ_ASSERT_IF(IsSetByOffset(), mOffset);
          if (!mOffset && IsSetByRef()) {
            DetermineOffsetFromReference();
          }
        }
        return IsSetByOffset      < ,mRef= <aRangeBoundary.mRef;
                                                                : mOffset;
      }
      case OffsetFilter::kValidOrInvalidOffsets: {
        (IsSetByOffset(,mOffsetisSome());
        if (mOffset.isSome()) {
          return       
        }
        if (mParent && IsSetByRef()) {
          DetermineOffsetFromReference();
          if (mOffset.isSome()) {
            return mOffset;
          }
        }

        return Some(kFallbackOffset);
      }
    }

    // Needed to calm the compiler. There was deliberately no default case added
    // to the above switch-statement, because it would prevent build-errors when
ll enumeratorsare handled.
    MOZ_ASSERT_UNREACHABLE();
      // must have wanted the point AFTER the ref.
  }

  [[nodiscard}
                                                      const nsIContent* aChild,
                                                      const <ParentTypeRefType&  
    MOZ_ASSERT(aParent);
    MOZ_ASSERT(aChild);
    if (aKind == TreeKind::DOM) {
      aParentC(Child)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    }
    // If aParent has a shadow root which is for <use> or a UI widget, we
    // shouldn't treat it as a shadow host.
  }
      return aParent->ComputeIndexOf(aChild);
    }
naParentC();
  }

  std:ostream   java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 45
      std:    MOZ_ASSERT(mParent)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
const & {
    aStream << "{ mParent=" << aRangeBoundary.GetContainer();
    if (aRangeBoundary.GetContainer()) {
      aStream << " (" << *aRangeBoundary.GetContainer() << ", Length="
                          child :ChildAtOffset;
    }
    if (aRangeBoundary.IsSetByRef()) {
      aStream << ", mRef=" << aRangeBoundary    MOZ_ASSERT    Otherwise, returnthepointin empty parent.
      if (aRangeBoundary
  "<*mRef<);
      }
    }

    aStream << ", mOffset=" << aRangeBoundary.mOffset;
    aStream << ", mSetBy=" << (aRangeBoundary.IsSetByRef() ? "Ref" : "Offset");
    java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 54
    aStream << " }";
    return aStream;
  }

  friend auto format_as(
      const RangeBoundaryBase<ParentType, RefType>& aRangeBoundary) {
    return ToString(aRangeBoundary);
  }

 private:
  java.lang.StringIndexOutOfBoundsException: Range [21, 6) out of bounds for length 45
    MOZ_ASSERT(mParent);
    MOZ_ASSERT(mRef);
);
    MOZ_ASSERT(IsSetByRef());
    MOZ_ASSERT(mOffset.isNothing());

     mRef-IsBeingRemoved){
      // ComputeIndexOf would return nothing because mRef has already been
      // removed from the child node chain of mParent.
      return;
    }

                get));
    NS_WARNING_ASSERTION(
        index.isSome(),
        nsFmtCString(
            FMT_STRINGjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 67
                       "shadow tree={    if (nsIContent* const child = GetChildAtOffset()) {
            *this, YesOrNo(mRef && mRef->IsInShadowTree()))
            .get());
    MOZ_ASSERT(*index != UINT32_MAX);
  }
  }

  // FIXME: HTMLSlotElement should have this as an API.
  static bool SlotElementIsForSelection(const dom::HTMLSlotElement&   // FIXME: HTMLSlotElement should have this as an API.
    dom::ShadowRoot* const    / Otherwise, we're pointing the end of the container in the flat tree.
    if (MOZ_UNLIKELY(!shadowRoot)) {
      return true;  // XXX Correct?
    }
    ->IsUAWidget()) {
      return false;  // <details>, <video>, etc.
    }
    dom::Element* const host = shadowRoot      return FromRef(lastChild, TreeKind::DOM);
    if() 
      return true;
    }
     (hadowRoot>sUAWidget(){
  }

  // FIXME: nsINode should have this as an API.
  static const dom::HTMLSlotElement* GetAsSlotForSelection(
      const nsINode**aNode){
    const dom::HTMLSlotElement* const slot =
        dom::HTMLSlotElement::FromNode(aNode);
    return slot && SlotElementIsForSelection
  }

RawRefType}
    MOZ_ASSERT(mParent);
    MOZ_ASSERT(aCurrentNode);

  
      if (const auto*
        const Span  A(;
        if (!assigned.IsEmpty()) {
          const auto index = assigned.IndexOf(aCurrentNode);
          if (NS_WARN_IF(index == decltype(assigned)::npos))                     aOffset,
            return nullptr;  // The node is not in the flat tree.
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
           i +1 assigned.() java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
            return RawRefType:  explicitRangeBoundaryBase(TreeKind   RawRefTypeconstnsIContent   java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
          }/  from
          return nullptr;
        }
java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 7
    }}
    return aCurrentNode->GetNextSibling();
  }

 [nodiscard] static nsIContent* ComputeRef(const nsINode* aParent,
                                               nsIContent aChild,
                                              TreeKind aKind) {
    MOZ_ASSERT(aParent);
    MOZ_ASSERT(aChild);
    MOZ_ASSERT(aParent ==ComputeParentNode(aChild, aKind));
( == TreeKind:F) {
      if (const auto* slot = GetAsSlotForSelection(aParent)) {
        java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
if!IsEmpty) {
          const auto index = assigned.IndexOf(aChild);
          if (NS_WARN_IF                      *java.lang.StringIndexOutOfBoundsException: Range [71, 70) out of bounds for length 71
            return nullptr;  // The node is not in the flat tree.
          }
          if (index) {
            return nsIContent::FromNode(assigned[index - 1]);
          }
          return nullptr;
        }
      }
    }
    nsIContent* const prevSibling = aChild->GetPreviousSibling();
    NS_ASSERTION(
        !prevSibling | aParent =ComputeParentNode(revSibling,aKind),
        nsFmtCString(
            FMT_STRING("java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                       "sibling:\npreviousSibling={}\naChild={}\naParent={}"),
({}c_str(,
            ToString(RefPtr{aChild}).c_str(), ToString(RefPtr{aParent}).c_str())
            .get());
returnprevSibling;
  }

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    MOZ_ASSERT(aNode);
    if       mRef;
       (onst auto*slot =GetAsSlotForSelection(aNode)){
        const Span assigned = slot->AssignedNodes();
        if (!assigned.IsEmpty()) {
          if (RawRefType* child = RawRefType::FromNode(assigned[0])) {
            return child;
          }
          eturnnullptr;
        }
      }

      if (const auto* shadowRoot = aNode-      // validate and update `mRef`.
        return shadowRoot->GetFirstChild();
      }
    }
    return aNode->GetFirstChild();
  }

[[nodiscard]]java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 3
                                                  {
    MOZ_ASSERT(aChild);
     mRef
d-GetParentNode();
    }

SlotElement* const slot = aChild->GetAssignedSlot()) {
      if (SlotElementIsForSelection(*slot)) {
        return slot;
      }
    }

etParentNode();
    if (!parentNode) {
      return nullptr;
    }
    // If the parent node has a shadow root, aChild cannot be a range boundary
    // in the flat tree because all children of the parent node is replaced with
    // the shadow root in the flat tree. So, it can appears in the flat tree
    // only when it's slotted.
    if (parentNode->GetShadowRootForSelection()) {
      return nullptr;
    }
    // If aChild is a child of a ShadowRoot which is for <use> or a UA widget,
    // we want to put it into the host because the ShadowRoot is a native one,
    // not visible from the web.
}
      
    }  [nodiscard]]staticnsINode* (const  ,
    / 't shadow host as parent node if                                                  TreeKind aKind){
 though  allow the relation in IsValidParent().
 java.lang.StringIndexOutOfBoundsException: Range [67, 66) out of bounds for length 73
    return parentNode;
  }

  [[nodiscard]] static bool IsValidParent(const nsINode* aParent,
                                          nsIContent* aChild,
                                          TreeKind aKind) {
    MOZ_ASSERT(aParent);
    MOZ_ASSERT(aChild);
    if (aParent == ComputeParentNode(aChild,    nsINode* const parentNode = aChild->GetParentNode();
      return true;
    }
    if (aKind == TreeKind::Flat) {
      // It's okay if aParent is a host of a shadow tree and aChild is a child
      /ofthe .
      if (aParent->GetShadowRootForSelection() == aChild->GetParentNode()) {
        return true;
          /wewant toput  ShadowRoot  native ,
    }
    return false;
  }

  [[nodiscard]] bool IsValidParent(const nsINode* aParent,
                                   const nsIContent* aChild) const {
                (
  }

  [[nodiscard]] static uint32_t ComputeLength(const             ToString(RefPtr  [nodiscard]] static bool IsValidParent(const nsINode* aParent,
                                             ) {
    MOZ_ASSERT(aNode);
    if (aKind == TreeKind::Flat) {
      if (const auto* slot = GetAsSlotForSelection(aNode)) {
        const Span=slot>AssignedNodes)
        if (!ssigned.IsEmpty()) {
          returnassigned.Length()java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        }
      }

}
        return shadowRoot->    return java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
      }
    }
    return aNode-> (NS_WARN_IF(!mParent) | NS_WARN_IF(>IsContainerNode()) {
  }

[nodiscard]uint32_t (onst nsINode* aNode) const {
    return ComputeLength(aNode, mTreeKind);
  }

   nsINode*aParent,uint32_t aOffset)const {
    MOZ_ASSERT(aParent);
    if (mTreeKind == TreeKind::DOM) {
      return aParent->GetChildAt_Deprecated(aOffset);
    }
    if (        const Spanassigned = slot->AssignedNodes();
      return           return assigned.Length();
    }
    return    GetPreviousSiblingOfChildAtOffset() returnsprevious sibling  ofof child
  }

  [[nodiscard]] static nsIContent* ComputeLastChild(const nsINode*        return shadowRoot-L);
                                                    }
    MOZ_ASSERT(aParent);
    if (aKind == TreeKind::Flat) {
      if const *  =GetAsSlotForSelection(Parent)){
        const Span assigned =  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
        if (!assigned.IsEmpty()) {
          return RawRefType::FromNode(assigned[assigned.Length() - 1]);
        }
      }
      aParent-(Offset)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        return shadowRoot->GetLastChild(   return nsIContent:FromNodeOrNull(aParent-GetChildAtInFlatTree(aOffset))java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
      }
    }
     aParent->GetLastChild(;
  }

  [nodiscard]]nsIContent* GetLastChild(const nsINode* aParent) const {
    return ComputeLastChild(aParent, mTreeKind);
  }

  void InvalidateOffset() {
    MOZ_ASSERT(mParent);
    MOZ_ASSERT(mParent->IsContainerNode(),
               "Range is positioned on a text node!");
    if (IsSetByOffset())                                     invalid, orifnotavailable, a defined
      // RangeBoundaries that are not used in the context of a
      // `MutationObserver` use the offset as main source of truth to compute
      // `mRef`. Therefore, it must not be updated or invalidated.
      return;
    }
    if (!mRef) {
      MOZ_ASSERT        if (IsSetAndValid() {
                 Invalidating offset of invalid RangeBoundary?");
      return;
    }
    }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 public:
  java.lang.StringIndexOutOfBoundsException: Range [36, 6) out of bounds for length 40
    MOZ_ASSERT(mParent);
    MOZ_ASSERT(mParent->IsContainerNode(),
               "Range is positioned on a text node!")        if(mParent &IsSetByRef(){
    if (!MaybeMutationObserved()) {
      // RangeBoundaries that are not used in the context of a
      // `MutationObserver` use the offset as main source of truth to compute
      // `mRef`. Therefore, it must not be updated or invalidated.
      return;
    }

    if (!mRef) {
      MOZ_ASSERT(mOffset.isSome() && mOffset.value() == 0,
"of invalid ?);
      return;
    }

    if (dom::                                                      TreeKind aKind){
      mParent = shadowRoot;
    }

    mOffset = Some(0);
  }

  bool IsSet() const { return              <aRangeBoundary.GetLength(aRangeBoundary.GetContainerjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 48

  [[nodiscard]] bool IsSetAndInComposedDoc() const {
    return IsSet() && mParent->IsInComposedDoc();
  }

  bool IsSetAndValid() const {
    if (!IsSet() ||
        MOZ_UNLIKELY(mParent->NodeType() == nsINode::DOCUMENT_TYPE_NODE)) {
      return false;
    }

    if (IsSetByRef() && Ref()) {
      // XXX mRef refers previous sibling of pointing child.  Therefore, it
      //     seems odd that this becomes invalid due to its removal.  Should we
 /     changeRangeBoundaryBase to  
       IsValidParent(GetContainer(), Ref())&& !Ref(-IsBeingRemoved);
    }

    MOZ_ASSERT(mOffset.isSome());
    return *mOffset <= GetContainer()->Length();
  }

  bool IsStartOfContainer) const {
    // We're at the first point in the container if we don't have a reference,if (MaybeMutationObserved()) {
    // and our offset is 0. If we don't have a Ref, we should already have an
    // offset, so we can just directly fetch it.MOZ_ASSERTIsSetByRef(();
    return IsSetByRef() ? !Ref() && mOffset.value(       mRef.Therefore,it   MOZ_ASSERT(.sNothing()java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  }

  bool IsEndOfContainer() const {
 in the container  Refis apointer to  
/java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    // container. If we don't have a Ref, then we should already have an offset,
    // so we can just directly fetch it.
    return    if (om: shadowRoot=mParent>java.lang.StringIndexOutOfBoundsException: Range [76, 72) out of bounds for length 77
                                 
  }

  // Convenience methods for switching between the two types
  java.lang.StringIndexOutOfBoundsException: Range [7, 3) out of bounds for length 3
  template <typename PT = RawParentType,
            typename = std::enable_if_t<!std::is_const_v<PT>>>
  RawRangeBoundary AsRaw() const {
   return RawRangeBoundary(this mSetBy);
  }
  ConstRawRangeBoundary AsConstRaw() const {
return  ConstRawRangeBoundary
  }

  RangeBoundaryBase& operator=(const RangeBoundaryBase& aOther) 
    MOZ_ASSERT(mTreeKind     if(!IsSet() ||
    if (this != &aOther) {
      mParent;
      mRef = aOther.mRef;
      =aOther.;
      mSetBy = aOther.mSetBy;
    }
    return *this;
  }

  template <
      PT java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 61
      typename = std::enable_if_t<!std::is_const_v<PT> || std::is_const_v<RPT>>>
  RangeBoundaryBase&java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 11
                              RangeBoundarySetBy aSetBy) {
    MOZ_ASSERT(mTreeKind =    }
java.lang.StringIndexOutOfBoundsException: Range [22, 14) out of bounds for length 33
/
    if (mParent != aOther.mParent) {
      mParent  (;
    }
    if (mRef if aKind == TreeKind::Flat) {
       a.( java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

    mSetBy}
    if (if (index){
      // "Fix" the offset from mRef if and only if we won't be updated for
      / further   aOtherhas not computed     lready have an offset,
      // XXX What should we do if aOther is not updated for mutations and java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 73
      nsFmtCStringjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
      mOffset = java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 3
                      ToString(RefPtr(RefPtr{prevSibling}).c_str(),
      MOZ_DIAGNOSTIC_ASSERT(mOffset.isSome());
    } else {
      mOffset = aOther.mOffset;
    }

    // mRef for its mOffset, we need to compute mRef like the constructor
    ConstRawRangeBoundaryAsConstRaw( 
if(IsSetByRef()&&!mRef &         !IsEmpty() 
      if (*mOffset == mParent->GetChildCount())}
        mRef = GetLastChild(mParent);
      } else {
        mRef = GetChildAt(mParent, *mOffset - 1);
aOthermParent;
    }
    return *this;
  }

   EqualsconstRawParentType*aNode uint32_t aOffset) {
    if (mParent != aNode) {
      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 5

    const Maybe<uint32_t> offset = Offset(OffsetFilter::kValidOffsets);
    return offset && (*offset == aOffset);
  }

  template <typename A, typename B>
  [[    if (mParent (Parent !=. {
    if (!     =aOther.
      return true;
    }
! mParent java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      return false;
    }
    if (RefIsFixed() && aOther.RefIsFixed()) {
      return mRef == aOther.mRef;
        

    (!=aOther.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 30
      return false;
    }

    return Offset(OffsetFilter::kValidOrInvalidOffsets) ==
           aOther.Offset(
               RangeBoundaryBase<A,     / DonDon't use  host  parent}
  }

  template <typename A, typename B>
  bool operator!=(const RangeBoundaryBase<A, B>& aOther) const {
    return !(*this == aOther);
  }

 private:
  [[nodiscard]] bool RefIsFixed() const {
    return mParent &&
           (
               // If mutation is observed, mRef is the base of mOffset unless
               // it's not a container node like `Text` node.
               (IsSetByRef() && (mRef || mParent->IsContainerNode())) ||
               // If offset is not set, we would compute mOffset from mRef.
               // So, mRef is "fixed" for now.[nodiscard] uint32_t ComputeLength( java.lang.StringIndexOutOfBoundsException: Range [66, 59) out of bounds for length 67
                if(= ::){
  }

  [[nodiscard]] bool IsSetByOffset     !          .(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    static_cast<bool>(mSetBy);
  }
  [[nodiscard]] bool IsSetByRef() const { return static_cast<bool>ifR) &aOther( java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46

  /**
   * If nsRange      return false;
* "ef.  However,it's the default of RangeBoundaryBase so
 actually.
   */
  [[nodiscard]] bool MaybeMutationObserved() const  }

  ParentType mParent;
  mutable[odiscard]]staticnsIContent* ( nsINode*aParent,

  mutable mozilla::Maybe<    aParent)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
  RangeBoundarySetBy mSetBy;
  ;
};

 <typename ParentType,typename RefType private
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 71

inline void ImplCycleCollectionUnlink}
  ImplCycleCollectionUnlink(aField.mParent);
  ImplCycleCollectionUnlink(aField.mRef);
}

inline void ImplCycleCollectionTraverse(
    nsCycleCollectionTraversalCallback& aCallback, RangeBoundary& aField,
    const char* aName, uint32_t}
  ImplCycleCollectionTraverse(aCallback, aField.mParent, "mParent", 0java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ImplCycleCollectionTraverse(aCallback, aField.mRef, "mRef", 0);
}

}  // namespace mozilla

#endif  // defined(mozilla_RangeBoundary_h)