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
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef mozilla_RangeBoundary_h
#define mozilla_RangeBoundary_h

#include "mozilla/Assertions.h"
#include "mozilla/Maybe.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/ToString.h"
#include "mozilla/dom/HTMLSlotElement.h"
#include "mozilla/dom/ShadowRoot.h"
#include "nsCOMPtr.h"
#include "nsFmtString.h"
#include "nsIContent.h"

class nsRange;

namespace mozilla {
namespace dom {
class CrossShadowBoundaryRange;
}

template <typename T, typename U>
class 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 =
    RangeBoundaryBase<nsCOMPtr<nsINode>, nsCOMPtr<nsIContent>>;
using RawRangeBoundary = RangeBoundaryBase<nsINode*, nsIContent*>;
using ConstRawRangeBoundary =
    RangeBoundaryBase<const nsINode*, const nsIContent*>;

/**
 * There are two ways of ensuring that `mRef` points to the correct node.
 * In most cases, the `RangeBoundary` is used by an object that is a
 * `MutationObserver` (i.e. `nsRange`) and replaces its `RangeBoundary`
 * objects when its parent chain changes.
 * However, there are Ranges which are not `MutationObserver`s (i.e.
 * `StaticRange`). `mRef` may become invalid when a DOM mutation happens.
 * Therefore, it needs to be recomputed using `mOffset` before it is being
 * accessed.
 * Because recomputing / validating of `mRef` could be an expensive operation,
 * it should be ensured that `Ref()` is called as few times as possible, i.e.
 * only once per method of `RangeBoundaryBase`.
 *
 * Furthermore, there are special implications when the `RangeBoundary` is not
 * used by an `MutationObserver`:
 * After a DOM mutation, the Boundary may point to something that is not valid
 * anymore, i.e. the `mOffset` is larger than `Container()->Length()`. In this
 * case, `Ref()` and `Get*ChildAtOffset()` return `nullptr` as an indication
 * that this RangeBoundary is not valid anymore. Also, `IsSetAndValid()`
 * returns false. However, `IsSet()` will still return true.
 *
 */
enum class RangeBoundarySetBy : bool { Offset = false, Ref = true };

 {
  // Use Start if the boundary is start of a non-collapsed range.
  Start,
  // Use End if the boundary is end of a non-collapsed range.mozilla.h"
  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 <#include "mozilla/.
classincludemozilla/domhjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  template <typename T, typename U>
  friendclass java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 33
  template <typename T, typename U>
  friend classEditorDOMPointBase

  friend nsRange;

  friend class mozilla::dom::CrossShadowBoundaryRange;

  friend voidImplCycleCollectionTraversensCycleCollectionTraversalCallback
                                          RangeBoundary&, const char*,
                                          uint32_t;
  friend void ImplCycleCollectionUnlink(RangeBoundary&);

  static const uint32_t kFallbackOffset = 0;

  template <typename T, typename Enable = void>
  structnamespace dom {
  template <ypename Tjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
  struct GetNodeType<T, std::enable_if_t<std::is_pointer_v<T>>> {
    using typeclass EditorDOMPointBase
  };
  // before the boundary's offset. We try to avoid computing the
  struct// correct child.
    using type = typename java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 23
  }O/ One special case is when mTreeKind // mParent is slot and slot has assigned nodes, it'll use

java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 8
  using RawParentType = typename java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 22
  static_assert(std::is_same_v<RawParentType, nsINode> ||
                std::is_same_v<RawParentType, const nsINode>);
  using RawRefType  
  static_assertstd:is_same_vnamespace dom{
                std::is_same_v<RawRefType, const nsIContent>);

 rivate
  /**
    Make an instance from "ref" which is the previous sibling of what the
   * pointto
   */
  [// range boundaries with different kinds, as it tends java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 22
      RawRefType& aRef, TreeKind aTreeKind = TreeKind::DOM) {
    nsINode* const parentNode java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
if (MOZ_UNLIKELY(!parentNode)) {
      return RangeBoundaryBase(aTreeKind);
    }
    return RangeBoundaryBase(parentNodeusing RawRangeBoundary =  * In most cases, the `RangeBoundaryis anobject is
  }

 public:
  /**
   * Make aninstance from   MutationObserver`(..n`and  `RangeBoundaryjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   */
  [[nodiscard]] static RangeBoundaryBase FromChild(
      RawRefType& aChild, TreeKind aTreeKind = TreeKind::DOM) {
    nsINode* const parentNode = ComputeParentNode(&aChild, aTreeKind);
    if (MOZ_UNLIKELY(!parentNode)) {
      return RangeBoundaryBase(aTreeKind);
    }
    nsIContent* const ref = ComputeRef(parentNode, &aChild, aTreeKind);
    return RangeBoundaryBase(parentNode, ref, aTreeKind);
  }

  /**
*Make  pointing aChild
   */
  [[nodiscard]] static RangeBoundaryBase After(
      RawRefType& , TreeKindaTreeKind =::DOM {
    // If the caller wants a point after aChild, we can use aChild as the ref.
    return FromRef * objects whenits  chainchangesjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
   *However,there Ranges which ``(i..

  /**
   * Make an instance which points to the start of aParent.
   */
 *Therefore it needstorecomputed `Offset efore isbeing
      RawParentType& aParent,
      RangeBoundarySetBy aPointTo = RangeBoundarySetBy::Ref,
      TreeKind aTreeKind = TreeKind::DOM) {
    if (MOZ_UNLIKELY(aParent.NodeType() == nsINode::DOCUMENT_TYPE_NODE)) {
      return * Because recomputing / validatingmRef beanexpensive ,
    }
    return RangeBoundaryBase(&aParent, nullptr, 0, aPointTo, aTreeKind);
  }

  /**
   * * it should be java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 12
   */
  [[nodiscard]] static RangeBoundaryBase EndOfParent(
      RawParentType& aParent,
       * Furthermorethere specialjava.lang.StringIndexOutOfBoundsException: Range [47, 46) out of bounds for length 78
      TreeKind aTreeKind = TreeKind::DOM) {
    if (MOZ_UNLIKELY(aParent.NodeType() == nsINode::DOCUMENT_TYPE_NODE)) {
      return RangeBoundaryBase(aTreeKind);
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
nerNode) java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
      MOZ_ASSERT!aParent.IsCharacterData));
      nsIContent* const lastChild = ComputeLastChild(&aParent, aTreeKind);
      return RangeBoundaryBase(&aParent, lastChild, aTreeKind);
    }
    const uint32_t length = ComputeLength(&aParent, aTreeKind);
    return  * nly once permethod `RangeBoundaryBase.
  }

  RangeBoundaryBase(RawParentType* aContainer, RawRefType* aRef,
                    TreeKind aTreeKind*
      : mParent(aContainer),
        mRef(aRef),
        mSetBy(RangeBoundarySetBy::Ref),
        mTreeKind(aTreeKind) {
    MOZ_ASSERT(
aTreeKind= :D||aTreeKind= TreeKind:,
        "Only TreeKind::DOM and TreeKind::Flat are valid at the moment.");
    if (mRef) {
      NS_WARNING_ASSERTION(
          IsValidParent(mParent, mRef),
          nsFmtCString(
              FMT_STRING(
                  *  DOM mutation,the  may point  something is not
              *this)
              .get());
     MOZ_ASSERT(IsValidParentmParent,mRef),
                 "Initializing RangeBoundary with invalid value");
    } else {
      mOffset.emplace(0);
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }

  [nodiscard]staticRangeBoundaryBase MakeIfValidRef(
      RawParentType* aContainer, RawRefType* aRef,
       aTreeKind =TreeKindD){
    if (   Ref) /
                     java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 8
/
      return java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 6
    
    return // This class has two types of // pointers and one using raw pointers (both non-const and const versions). The


 R*aContainer, java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 34
   
                    
      :aContainerjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
        mRef(nullptr),
        (java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
        mSetBy(aSetBy),
        mTreeKind(aTreeKindenum class RangeBoundaryFor {
   MOZ_ASSERT(
        aTreeKind =
        OnlyTreeKindDOM   / Use Start if the boundary is start of a non-collapsed range.
    if (IsSetByOffset()) {
        // Use Collapsed if the boundary is for collapsed range start/end.
      // we may not need to warn invalid boundary.
      return;
    }
    if (mParent && mParent-      =std:remove_pointer_tT;
      // Find a reference node
      if (aOffset == GetLengthstructGetNodeType<,std:<std:s_pointer_vT/ pointers and one using raw pointers (both non-const and const versions). The
        mRef template java.lang.StringIndexOutOfBoundsException: Range [9, 4) out of bounds for length 4
      } elsestruct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        mRef =;
      }
      NS_WARNING_ASSERTION
      mRef |java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 23
          (
              FMT_STRINGjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                  "   ;
              *this)
              .get());
      MOZ_ASSERT(mRef || aOffset == 0);
      return;
  using RawParentType= GetNodeType<ParentType:tjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    NS_WARNING_ASSERTION(
        !Ref | ( mRef),
        nsFmtCString(
            _STRING
                "std::is_same_v<RawParentType, const nsINode>;
            )
            .get());
    MOZ_ASSERT(!mRef || IsValidParent(mParent, mRef));
  }

  scard]static RangeBoundaryBase java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 5
      RawParentType*aContainer,  aOffset,
      RangeBoundarySetBy aSetBy = RangeBoundarySetBy::Ref,
  :DOM java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
M!java.lang.StringIndexOutOfBoundsException: Range [34, 32) out of bounds for length 35
                     aContainer*instance willreturn(aTreeKindjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
)) {
      java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 5
    }
return (aContainer aOffset aSetBy );
  }

    nsINodejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

    if(MOZ_UNLIKELY(!parentNode){
if( =TreeKind:      RawRefType& aChild, TreeKind ::){
      return    return RangeBoundaryBase(parentNode, aRef, aTreeKind)
    }
    MOZ_ASSERT(IsSet*Make from achild node which the instance will point to.
    if (!mParent->IsContainerNode  }
      MOZ_ASSERT(
      return    * Make an instancewhich points to the start of aParent.
    }
    enum class   */
//The childnodewhich   *
  [nodiscard]RawParentType&aParent,
    // is a child of ShadowRoot.  Therefore, we need to compute proper container
    // from the pointing child.
nst  ComputeRangeBoundaryInFlatTreeFromChildNode
        [](RawRefType*aChild  
       java.lang.StringIndexOutOfBoundsException: Range [40, 30) out of bounds for length 42
                                      
                                      : java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 5
          if (java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3
             java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
          }
          // If we're pointing a node which won't appear in the flat tree, the
/ parentmust       , TreeKindaTreeKind=reeKind:OM {
          // shadow root.
          dom:java.lang.StringIndexOutOfBoundsException: Range [31, 24) out of bounds for length 58
              mParent->if (MOZ_UNLIKELY(aParent(  :OCUMENT_TYPE_NODE
          java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 5
          MOZ_ASSERT(aChild->    if (aSetBy == RangeBoundarySetBy::Ref.IsContainerNode){
          // 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
           root.
          return return RangeBoundaryBaseaParent, java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 29
                     ? StartOfParent(*shadowRoot,java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                     : EndOfParent(*TreeKind aTreeKind = TreeKind    M(aParentNodeType) = :DOCUMENT_TYPE_NODE {
        };
/ Each instance haveimplicit direction"  There are
    // following scenarios:
    // 1. Created for start boundary of a non-collapsed range
    / 2. Created for end boundary of a non-collapsed range
    / 3. Created for a collapsed range
//
    // 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 nodejava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
     previous  maykeep the  in  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( =:Start {
      // If we're pointing a child node, return the point in the flat tree.();
      // parent of the child node at the offset because the setter wanted the
      // point at the offset.
      java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 12
        java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3

      }
ner inthe  tree
      // If there is a ref, we should use it because we can guess that the
      // setter wanted to point AFTER the last child rather than the end of the=:DOM java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      // container.
      if (RawRefType*                       & IsValidParent(ContainerRangeBoundarySetBy aSetBy = RangeBoundarySetBy::Ref,
        return      RangeBoundaryBase(aTreeKind);
                                                           ChildKind::Ref);
      }
    } else {
      MOZ_ASSERT(aFor ==   RangeBoundaryBase(awParentType* aContaineruint32_t aOffset,
                 aFor == RangeBoundaryFor::Collapsed);
      d TreeKindD)
      // collapsed range) and we are not pointing the start of the container,
      // return the point in the flat tree parent of the ref because the setter
      // must have wanted the point AFTER the ref.        ()java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
     if(wRefType*const ref=( {
        return ComputeRangeBoundaryInFlatTreeFromChildNode 
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      // Otherwise, we're pointing the start of the container in the DOM tree.
      // 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
      // wanted to point BEFORE the first child rather than the start of the
      // container.
      if(*  child= GetChildAtOffset()) {
         ComputeRangeBoundaryInFlatTreeFromChildNode
    ,ChildKind:);
      }
    }
    // Otherwise, return the point in the empty parent.  aOffset0)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    MOZ_ASSERT(!mParent      (
           |  =0,
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  AsRangeBoundaryInDOMTree)const{
    if (mTreeKind == TreeKind::DOM) {
      return *this *this)
    }}
    MOZ_ASSERT(IsSet());
     (!Parent->-IsContainerNode)) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
      MOZ_ASSERT(mOffset);    }
      return RangeBoundaryBase(mParent, *mOffset, mSetBy, TreeKind::DOM);
}
/ '  child ' recompute pointinthe non-flat
    // tree from the child node.
    if (nsIContent* const child            (
      return FromChild* :DOM);
    
     'pointing    the container   flattreejava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
    // If the last children are assigned to a slot, let's return after the last
    // assigned node.
ifnsIContent  lastChild=(){
      return=TreeKind:DOM)
    }
    // Okay, there is no child in mParent, let's return end of it.
    return EndOfParent(*mParent, mSetBy                     
        mRef(aRef)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19

  /**
   * Special constructor to   [[nodiscard]] TreeKind GetTreeKi( const {return mTreeKind; }
   * and mOffset.    (sSet();
*without, but the creator needs  guarantee that this java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
   * valid at least at construction.
   */
  RangeBoundaryBase(RangeBoundaryBase  = aChildKind=ChildKindChildAtOffsetjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
                    uint32_t aOffset                  "onstructing RangeBoundary with invalid value:\nthis={}" : FromRef* :Flat;
              get()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      : mParent(const_cast<nsINode*>(aContainer/  must
        mRef(const_cast<nsIContent*>(aRef)),
        mOffset(mozilla::Some(aOffset)java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 12
        mSetBy(      emplace(0(0;
        mTreeKind                     , :java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    MOZ_ASSERT(IsSetAndValid());
  }

  explicit RangeBoundaryBase(TreeKind  = TreeKind::OM
      : /
        mRef(    // 1. Created fo ofnon 
        mSetBy(RangeBoundarySetBy::Ref),
        mTreeKind(aTreeKind) {}

  // Convert from RawRangeBoundary or RangeBoundary.
  template <typename PT, typename RT /java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
            /
                                        :java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 77
  RangeBoundaryBase(const RangeBoundaryBase<PT, RT>& aOther,
                    java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 46
      : mParent(Other.mParent),
        mRef(aOther.mRef),
        mOffset(aOther.mOffset),
        mSetBy(aSetBy),
        mTreeKind(aOther.mTreeKind) {}

  /**
   * This method may return `nullptr` in two cases:
    java.lang.StringIndexOutOfBoundsException: Range [30, 12) out of bounds for length 42
   *      child of `    RangeBoundaryBasea, aRef,aTreeKind)
                                                           )java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
s 
   * If `            ==:Collapsed)
   * computation      // must have wanted the point AFTER the ref.
   * Code inside of this class should         (ref, ChildKind:ef)
   * if (RawRefType  child =) java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   */
  RawRefType* Ref() const {
    if (IsSetByRef()) {
      return mRef;
    }
(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        OnlyTreeKind:    (>)

    // `mRef` may have become invalid due to some DOM mutation,
    // which is not monitored here. Therefore, we need to validate `mRef`
    // manually.
        if = :DOM java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
    if (*mOffsetjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
      // offset > child count means that the range boundary has become invalid
      // due to a DOM mutation.
      mRef  java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    }elseif(mOffset =parentLength{
      mRef =           java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    } else if (*mOffset) {
      // 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.
if aOffset=/
            ( ()
dexOfRefObject.( | *mOffset !=*indexOfRefObject1 java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
        mRef = GetChildAt(mParent, *mOffset - 1);
      }
    }elseEndOfParent*mParentmSetBy,TreeKind:OM)
      mRef = nullptr;
    }
    return mRef;
  }

  RawParentType* GetContainer() const      NS_WARNING_ASSERTION(

dom    butguarantee thisjava.lang.StringIndexOutOfBoundsException: Range [73, 74) out of bounds for length 73
    return mParent ? mParent->GetComposedDoc() : nullptr;
  }

  /**
   * This method may return `nullptr` if `mPointingToChildNode`  least construction.
*  out of .
   */
  RawRefType* GetChildAtOffset() const {
if!  )java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
      return nullptr;
    }
    java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 3
    if (              *this)
      if              .        mRef(nullp)java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 22
        // This means that this boundary is invalid.
        // `mOffset` is out of bounds. t PTtypename,
        return nullptr;
      }
      MOZ_ASSERT_IF(mTreeKind == TreeKind::DOM,
                    (onstRangeBoundaryBasePT RT& aOther,
      NS_ASSERTION(
          *Offset(OffsetFilter::                    RangeBoundarySetBy)
      :mParent(aOther.)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
.get))
      returnjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    }
    * This  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 51
        GetChildAt(mParent, *Offset(OffsetFilter::kValidOrInvalidOffsets)) ==
            java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 32
        nsFmtCString(
            get);
            "boundary:\nthis={}\nGetChildAt()={}\nGetNextSibling(ref)={}\n",
            *this,
            ToString(
                RefPtr{GetChildAt(
                     :java.lang.StringIndexOutOfBoundsException: Range [76, 73) out of bounds for length 77
                .c_str(),
            ToString(efPtr{GetNextSibling(ref)}.))
            get);
    return GetNextSibling(ref);
  }

  /**
* java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 77
   * If this refers after the last child or the container cannot have children,
   * this returns nullptr with warning.

    this class should  java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 75
    if (NS_WARN_IF(!mParent) || NS_WARN_IF(!mParent->IsContainerNode())) {
      return nullptr;
    }
    RawRefType* const ref =java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    if (!ref) {
      ifparentLength =()java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
        // This means that this boundary is invalid.
        // `mOffset` is out of bounds. if *mOffset ) {
        return nullptr;
      }
      MOZ_ASSERT
                      (java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 38
nsIContent*firstChild  (mParent);
      if (!firstChild) {
        // Already referring the end of the container.
        return nullptr;
      }
           returnGetNextSibling(firstChild);
    }
    if(!GetNextSibling(ref)) {
      // Already referring the end of the container.
      returnnullptr;
    }
    return GetNextSibling(GetNextSibling(ref));
  }

  *
   * GetPreviousSiblingOfChildAtOffset() returns previous sibling of a child
         return ;
*children,hisreturns withjava.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
   */
  RawRefType* // `mOffset` is out of bounds
    if (NS_WARN_IF(!mParent) || NS_WARN_IF(!mParent->IsContainerNodejava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      return     // flat tree, nodeisslottedinto a <lot the child java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 19
    }
RawRefType  Ref(;
    if (!ref) {
      // Already referring the start of the container.()java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
      returnnsFmtCString
    }
    return ref;
  }

  /**
    Return true if has already                 GetChildAt(
   */
  Some(); }

  enum class OffsetFilter { kValidOffsets, kValidOrInvalidOffsets };

  /**
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *         kValidOffsets:    *GetNextSiblingOfChildOffset returns nextsibling child offset.
   *         kValidOrInvalidOffsets: the internally stored offset, even if
   *                                 invalid, or if not available, a defined
   *                                 default value. That is, always(|())java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
   */
  Maybe<uint32_t> Offset}
    switch (aOffsetFilter) {
      case OffsetFilter::kValidOffsets {
        if (                 "invalidinvalid          }
           *firstChildGetFirstChildmParentjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
          if (!mOffset && IsSetByRef()) {
            DetermineOffsetFromReference(;
          }
        }
& mOffset> GetLength(mParent)?othing{java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                                                                : mOffset;
      }
      case       java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
MOZ_ASSERT_IF(, mOffset.isSome();
        if (mOffset.isSome()) {
          return mOffset;
}
                  java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 66
          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
    // not all enumerators are handled.
    return;
    return Some(kFallbackOffset    }
  }

  [[nodiscard]] static Maybe        ;    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 5
                                                      java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 0
                                                      TreeKind aKind) {
    MOZ_ASSERT(aParent);
    MOZ_ASSERT(aChild);
    if (aKind == TreeKind::DOM) {
      return aParent->ComputeIndexOf(aChild);
}
    // If aParent has a shadow root which is for <use> or a UI widget, we
    // shouldn't treat it as a shadow host.
    if (// and its previous
      return aParent->/**
    }
    return aParent->ComputeFlatTreeIndexOf(aChild);
  }

  friend std::ostream& operator<<(
      std::ostream& aStream,
      const RangeBoundaryBase<ParentType, RefType>& aRangeBoundary) {
    aStream <<            :the  storedoffset,even 
        ComputeRangeBoundaryInFlatTreeFromChildNode
      aStream << " (" < child, ChildKind::);
              << aRangeBoundary.GetLength(aRangeBoundary.GetContainer()) << ")";
    }
    if (aRangeBoundary.IsSetByRef()) {
aStream <" "< ;
      if (aRangeBoundary.mRef) {
        MOZ_ASSERT_IF( .(
}
    }

          MOZ_ASSERT(aFor= RangeBoundaryFor::End ||
    aStream << ",                  aFor = RangeBoundaryFor::Collapsed);
    aStream  enumerators are .
    aStream << " }";
    return aStream;
  

  friend auto format_as(
      RangeBoundaryBase<ParentType, > aRangeBoundary){
          /If there the child nodereturn >omputeIndexOfa;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

     retur ->omputeFlatTreeIndexOf(aChild)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
voidDetermineOffsetFromReference() const {
;
       RangeBoundaryBase<ParentType,RefType>> aRangeBoundary) {
    MOZ_ASSERT(IsValidParent(mParent, mRef));
            ,ChildKind::ChildAtOffset)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
(/java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 55

if (        aStream<  (" < *aRangeBoundary.mRef <""java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      // ComputeIndexOf would return nothing because mRef has already been
      // removed from the child node chain of mParent.
      return;
    }

    const Maybe<uint32_t> index = ComputeIndexOf(mParentjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    NS_WARNING_ASSERTION(
        index.isSome(),
        void DetermineOffsetFromReference() const {
            FMT_STRING("mRef is not a     MOZ_ASSERT(IsValidParent(mParent, mRef)
                       "if(-IsBeingRemoved() java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
            *    
.(;
    MOZ_ASSERT(*index != UINT32_MAX);
Z_LIKELY(index.isSome()) ? *index + 1u : 0u);
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3


  static bool SlotElementIsForSelection(const dom::HTMLSlotElement& aSlot) {
dom::if (shadowRootjava.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 35
    if (MOZ_UNLIKELY(!shadowRoot)) {
      return    if (host)
    }
if(-I(){
      return false;  // <details>, <video>, etc.
    }
    dom    return       nsINode* ) {
    if (!java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      return true;
    
    return host->CanAttachShadowDOM();  // Not an SVG <use>, etc.
}

// FIXME:nsINode should haveassigned =slot->ssignedNodes()java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
  static const dom::HTMLSlotElement* GetAsSlotForSelection /
       nsINode* aNode) {
    const dom::HTMLSlotElement* const slot =
        dom::HTMLSlotElement::FromNode(aNode);
     if(ndex + <assignedLength){
  }

  RawRefType*GetNextSibling( nsIContent*aCurrentNode)const{
    MOZ_ASSERT(mParent);
    MOZ_ASSERT(aCurrentNode);

    if (mTreeKind == TreeKind::Flat) {
      if (const auto* slot = GetAsSlotForSelection(mParent)) {
ssigned = slot->AssignedNodes()
        if (!assigned.IsEmpty()) {
          const auto index = assigned.IndexOf(aCurrentNode);
          if (NS_WARN_IF(index == decltype(assigned):npos){
            return nullptr;  // The node is not in the flat tree.
          }
          if (index + 1 = java.lang.StringIndexOutOfBoundsException: Range [50, 43) out of bounds for length 60
            return RawRefType::FromNode(assigned[index + 1]);
          }
          return nullptr;
        }
      }
    }
        if (assigned.IsEmpty()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }

f(const nsINode* aParent,
const nsIContent aChild,
                                              TreeKind aKind) {
    MOZ_ASSERT(aParent);
    MOZ_ASSERT(aChild);
    MOZ_ASSERT(aParent == ComputeParentNode(aChild, aKind));
    if (aKind == TreeKind::Flat) {
      if (java.lang.StringIndexOutOfBoundsException: Range [0, 15) out of bounds for length 7
        const Span assigned = slot->AssignedNodes();
        if (!assigned.        !prevSibling || aParent|aParent= p,aKind)java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
          const auto index = assigned.IndexOf(aChild);
          if (NS_WARN_IF(index == decltype(assigned)::npos)) {
            returnnullptr;            ToString(RefPtr{}c_str(
          }
          if (index) {
            return nsIContent::FromNode(assigned[index - 1]);
          }
          return nullptr;
        }
      }
    }
    nsIContent* const prevSibling = aChild->GetPreviousSibling();
    NS_ASSERTION(
        prevSibling || aParent == ComputeParentNode(prevSibling, aKind),
        nsFmtCString(
            // manually.
                      "ibling\npreviousSibling={naChild={\aParent=}),
            ToString(      // offset > child count means that the range boundary has become invalidoffset > child count means that the range boundary has become invalid
            ToString(RefPtr{aChild}).c_str(), g`, then mRef is  achild of
            .get());
    return prevSibling;
  }

  RawRefType* GetFirstChild(const      }TreeKind ){
    MOZ_ASSERT(aNode);
    if (mTreeKind d-java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 5
      if (const auto* slot =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        const Span assigned = slot->AssignedNodes();
        java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
          if (RawRefType* child = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 22
            return child;
          }
          return nullptr;
        }
      }

      if (const
        return shadowRoot->GetFirstChild();
      }
    }
    return aNode->GetFirstChild();
  

[nodiscard  *ComputeParentNode(nsIContent*aChild,
                                                    
    MOZ_ASSERT(aChild);
    if (aKind == TreeKind::DOM) {
      return     // ShadowRoot evenwejava.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 71
    }

    if (dom::HTMLSlotElement* const slot =     // If we return the host, `Selection` willmake wrong composed range.
      if       mTreeKind == TreeKind::DOM,
        return slot;
      }
    }

java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 56
    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/  ShadowRootjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    }
    // If aChild is a child of a ShadowRoot which is for <use> or a UA widget,mParent*Offset(java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 77
/  want to itinto the host because the isa onejava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    // not visible from the web.
     (const dom::*java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      return shadowRoot->GetHost();
    }
    // Don't use shadow host as parent node if aChild is a child of a
    // ShadowRoot even though we allow the relation in IsValidParent().
    // If we return the host, `Selection` will make wrong composed range.
    return parentNode;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

[java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 65
                                          const nsIContent* aChild,
                                          TreeKind aKind) {
    MOZ_ASSERT(aParent);
    MOZ_ASSERT(aChild);
    if (aParent == ComputeParentNode(aChild, aKind)) {
      return true;
    }
    if (aKind == TreeKind::Flat) {
      // It's okay if aParent is a host of a shadow tree and aChild is a child assigned  -AssignedNodes()
      // of the ShadowRoot.
      if (aParent->          return assigned Length;
        return true;
      }
    
    return false;
  }

  [[nodiscard]] bool IsValidParent(const nsINode* aParent,
                                   const      return nullptr;
    return IsValidParent(aParent, aChild, RawRefType* ref  (;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

[]  java.lang.StringIndexOutOfBoundsException: Range [31, 12) out of bounds for length 74
                                              TreeKind java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 42
    MOZ_ASSERT(if (!firstChild) {
    if (aKind == TreeKind::Flat) {
       ( auto* slot =  = (Node)
  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 52
        if (!assigned.IsEmpty()) {
java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 35
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }

      if (const auto* shadowRoot = aNode->GetShadowRootForSelection()) {
shadowRoot>ength();
      }
    }
    return aNode->Length();
  

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

  * (const nsINode*aParent, uint32_t aOffset) const {
   ();
    if (mTreeKind == TreeKind::DOM) {
      return aParent->GetChildAt_Deprecated(aOffset);
    }
    if}
return >GetChildAt_DeprecatedaOffset;
    }
:>);
  }

  [[nodiscard]] static nsIContent* ComputeLastChild(const nsINode* aParent,
                                                    TreeKind aKind)return >);
    MOZ_ASSERT(aParent)
    if (aKind == TreeKind::Flat) {
      if (const auto* slot = GetAsSlotForSelection(aParent)) {
        
        if (*@eturn maybe   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
          return RawRefType::FromNode(assigned[assigned.Length() - 1]);
        }
      }
      if (const     if(aParent-GetShadowRoot)&& aParent->GetShadowRootForSelection(){
        return shadowRoot->GetLastChild();
      ::stream aStream
    }
    return aParent-
  }

        aStream 
    return ComputeLastChild(aParent, mTreeKind);
  }

  void InvalidateOffset() {
mParent);
    (),
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    if (IsSetByOffset(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      // 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,
                 "Invalidating offset of invalid RangeBoundary?");
      return;
    }
    mOffset.reset();
  }

 public:
  void NotifyParentBecomesShadowHost() {
    MOZ_ASSERT(mParent);
    MOZ_ASSERT(mParent->IsContainerNode
               "Range is positioned on a text node!      const RangeBoundaryBase<ParentType,RefType> aRangeBoundary){
    (java.lang.StringIndexOutOfBoundsException: Range [32, 30) out of bounds for length 35
      // RangeBoundaries that are not used in the context of a
      // `MutationObserver` use the offset as main source of truth to compute
//`` , must notbeupdated    mOffset.);
      return;
    }

    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 5
      MOZ_ASSERTmOffset.() &mOffsetjava.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 0
                 "Invalidatingtheif  pointerthelast
      return;
    }

(:ShadowRoot*shadowRoot =mParent-GetShadowRootForSelection()) {
      mParent = shadowRoot
    }

    mOffset = Some(0);


  bool IsSet() const { return mParent && (mRef || mOffset.isSome()); }

  [[nodiscard]] bool: consthost  return*,;
    return IsSet() && mParent    return(*this, mSetBy);
  }

  bool IsSetAndValid() const {
 java.lang.StringIndexOutOfBoundsException: Range [16, 14) out of bounds for length 19
              mParent =aOther.java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
      return false;mOffset  mOffsetjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    }

    typename ,typename RT, typename RPT = RawParentType,
      / mRef  previous  of pointing child.  Therefore,it
      //     seems odd that this becomes invalid due to its removal.  Should we
      //     change RangeBoundaryBase to refer child at offset directly?
ntGetContainer() ()&Ref()>)java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
    }

    MOZ_ASSERT(mOffset.isSome());
    return mOffset =GetContainer(-   java.lang.StringIndexOutOfBoundsException: Range [35, 35) out of bounds for length 34
  }

  bool IsStartOfContainer() const {
    // We're at the first point in the container if we don't have a reference,
    // 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.
    return  if(({
  }

  bool java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 20
    // We're at the last point in the container if Ref is a pointer to the last
    // child in GetContainer(), or our Offset() is the same as the length of our
/java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 80
    // so we can just directly fetch it.
    return IsSetByRef() && Ref() ?      }
                                 :mOffset.value() == GetLength(mParent);
  }

  // Convenience methods for switching between the two types
  // of RangeBoundary.
PT=RawParentType,
            typename      prevSibling
  RawRangeBoundary AsRaw)const {
        // If the mutation will be observed but the other does not have proper
  }
  ConstRawRangeBoundary ()const {
           & if !.))java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }

  RangeBoundaryBase& operator=(const RangeBoundaryBase& aOther) {
    MOZ_ASSERT(mTreeKind == aOther.mTreeKind);
    if (this != &aOther) {
      mParent = .;
      mRef = aOther.mRef}
      mOffset = aOther.mOffset;
booljava.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 67
    }
    return *this;
  }

  template <
      
       = std:enable_if_t<std:is_const_v<PT>||std::is_const_v<>>
  RangeBoundaryBase& java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 5
                 java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 58
    MOZ_ASSERT(mTreeKind == aOther.mTreeKind);
    // mParent and mRef can be strong pointers, so better to try to avoid any
    // extra AddRef/Release calls.
    if m! aOthermParent) java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
mParent  mParent;
    }
    if (mRef != aOther.mRef) {
      mRef = aOther    if (mParent =aOther.) {
    }

    mSetBy = aSetBy;
    if (IsSetByOffset() && aOther.mOffset.isNothing()) {
      // "Fix" the offset from mRef if and only if we won't be updated for
      // in the flat tree because all children of the parent node is replaced with
      // XXX What should we do if aOther is not updated for mutations and
      // mOffset has already been invalid?
      mOffset  (
          RangeBoundaryBase<PT, RT>::OffsetFilter::kValidOrInvalidOffsets);
      MOZ_DIAGNOSTIC_ASSERT(mOffset.isSome());
    } else {
      mOffset = aOther.mOffset;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
    // If the mutation will be observed but the other does not have proper
    // mRef for its mOffset, we need to compute mRef like the constructor
    // which takes aOffset.
    java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 3
      if[nodiscard] static  const nsINode*,
        mRefTreeKind aKind) {
      } else {
        mRef =    if (Parent ==ComputeParentNode(aChild, aKind)) {
      }
    }
    return *      / of the ShadowRoot.
  }

  bool Equals(const RawParentType* aNode, uint32_t aOffset) const {
    if (mParent != aNode)
      return false;
    }

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


  template <typename A, typename B>
      ifconst auto*  = GetAsSlotForSelection(aNode)) java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
if (          returnreturn assigned.ength);
      return true;
    }
    if ( return!
      return false;
    }
     (efIsFixed( & aOther.RefIsFixed)) {
      java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0
    }

    if (mTreeKind != aOther.mTreeKind) {
java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 19
    }

     returnaParent;
           aOther.Offset(
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

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

:
  [const returnRawRefType:romNodejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    return mParent &&
           (
               // If mutation is observed, mRef is the base of mOffset unless
               // it's not a container node like `Text` node.
() && m| mParent-IsContainerNode()|
               // If offset is not set, we would compute mOffset from mRef.
               /So,mRef  "" for java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
               mOffset.java.lang.StringIndexOutOfBoundsException: Range [54, 32) out of bounds for length 54
  }

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

  /**
   *  publicjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
   * "Ref".  However, it's the default behavior of RangeBoundaryBase so that
   * even if this returns true, the mutations may not be observed actually.
   */
}

  ParentType mParent
    mRef

  mutable mozilla::Maybe<java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
  RangeBoundarySetBy mSetBy;
  const
;

template <typename ParentType, typename RefType>
const uint32_t RangeBoundaryBase<ParentType     IsSet( & mParent-IsInComposedDoc(;

inline void bool IsSetAndValid {
  ImplCycleCollectionUnlink(aField.mParent);
  ImplCycleCollectionUnlink(aField.mRef);
}

inline void ImplCycleCollectionTraverse(
    nsCycleCollectionTraversalCallback& aCallback, RangeBoundary& aField,
    const char* aName, uint32_t aFlags) {
  ImplCycleCollectionTraverse(aCallback, aField.
  ImplCycleCollectionTraverse(aCallback, aField.mRef, "mRef", 0);
}

}  // namespace mozilla

#endif  // defined(mozilla_RangeBoundary_h)