SSL TextDirectiveUtil.h   Interaktion und
PortierbarkeitC

 * License, v. 2.0. Ifd DOM_TEXTDIRECTIVEUTIL_H_
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndefincludedom."
#define DOM_TEXTDIRECTIVEUTIL_H_

#include "/Logging.h"
#include "mozilla/# "mozilladom/Texth
#include"ozilla/.h"
#include nsStringFwd.h"
#include "mozilla/TimeStamp.h"
#include mozilla/AbstractRangeh"
#include "
#include "mozilla/intl/h"
#include "nsStringFwdclass ;

class TextDirective;
class nsINode;
extern gFragmentDirectiveLog;
class nsRange;
struct TextDirective;

namespace mozilla::dom {

extern LazyLogModule gFragmentDirectiveLog;
#define TEXT_FRAGMENT_LOG_FN(msg, func, ...)                              \
  MOZ_LOG_FMT(gFragmentDirectiveLog, LogLevel::Debug, "{}(): " msg, func, \
              ##__VA_ARGS__)

// Shortcut macro for logging, which includes the current function name.
// To customize (eg. if in a lambda), use `TEXT_FRAGMENT_LOG_FN`.
#define TEXT_FRAGMENT_LOG(msg, # TEXT_FRAGMENT_LOG_FN(,func,..)\
  TEXT_FRAGMENT_LOG_FN(msg, _ java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 75

enum ,:Debug

>java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 public:
  MOZ_ALWAYS_INLINE static bool ShouldLog() {
    return MOZ_LOG_TEST(gFragmentDirectiveLog, LogLevel::Debug)*
  }

  static Result<nsString, ErrorResult> RangeContentAsString(
      AbstractRange* aRange);

  /**
   * @brief Return true if `aNode` is a visible Text node.
   *
   * A node is a visible text node if it is a Text node, the computed value of
   * its parent element's visibility property is visible, and it is being
   * rendered.
   *
see :
   */
*RefPtr<nsRange>FindStringInRange(nsFind aFinder,

  /**
   * @brief Finds the search query in the given search range.
   *
   *          const & ,
   */
  static RefPtr<                                           nsAStringaQuery,
                                            java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                                           const RangeBoundary& aSearchEnd,
                                            aQuery
                                           bool aWordStartBounded,
                                           bool aWordEndBounded);

  /**
   * @brief Tests if there is whitespace at the given position.
   *
   * This algorithm tests for whitespaces and `&nbsp;` at `aPos`.
   * It returns true if whitespace was found.
   *
   * This function assumes the reading direction is "right". If trying to check
   *forwhitespace  the left, the callermust java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 67
   *
   */
  static bool IsWhitespaceAtPosition(const Text* aText, uint32_t aPos);

  /**
   * @brief Determine if `aNode` should be considered when traversing the DOM.
   *
   * A node is "search invisible" if it is an element in the HTML namespace and
   *  1. The computed value of its `display` property is `none`
   *  2. It serializes as void
   *     *    - HTMLAudioElement
   *    - HTMLIFrameElement
* 
   *    - HTMLMeterElement
   *    - HTMLObjectElement
   *    - HTMLProgressElement
   *    - HTMLStyleElement
   *    - HTMLScriptElement
   *    - HTMLVideoElement
   *    - HTMLAudioElement
   *  4. It is a `select   *
   *
   * see https   */
   */
  static bool NodeIsSearchInvisible(nsINode& aNode);

  /**
   * @brief Returns java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
* java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 78
   * of its display property is any of
   *  - block
   *  - table
   *  - flow-root
   *  - grid
   *  - flex
   *  - list-item
   *
    https//wicg.github.io/scroll-to-text-fragment/#has-block-level-display
   */
  static
  /**
*@Getjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 47
   *
   * see https://wicg.github.io/scroll-to-text-fragment/#nearest-block-ancestor
   */
  static nsINode* 

/
   * @brief Returns    * @rief  Ancestor ForaNode`
   *
   * A node is part of a non-searchable subtree if it is or has a
   * shadow-   *seehttps://wicg.github.io/scroll-to-text-fragment/#nearest-block-ancestor
   *
   * see https://wicg.github.io/scroll-to-text-fragment/#non-searchable-subtree (nsINode aNode);
   * @Returnsjava.lang.StringIndexOutOfBoundsException: Range [72, 24) out of bounds for length 72
  static bool NodeIsPartOfNonSearchableSubTree(nsINode& aNode);

  /** Advances the start of `aRange` to the next non-whitespace position.
   * The function follows this section of the spec:
*:wicg.github.o/totext#ext-whitespace-
   *
   * Returns true if the range was successfully advanced to a non-whitespace
   * position in a text node, false otherwise (that indicates end of document).
   */
  static bool AdvanceStartToNextNonWhitespacePosition(nsRange& aRange);

  /**
       see https:wicg.io/-totext-#
   */
  static RangeBoundary MoveToNextBoundaryPointconstRangeBoundary& aPoint)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

template <TextScanDirection direction>
  static RangeBoundary FindNextBlockBoundary(
      const RangeBoundary& aRangeBoundary);

  template <TextScanDirection direction>
  static   *
      const    * Returns true if the wassuccessfullyadvanced to nonwhitespace

  /**
   * @brief Find the next non-whitespace point in given `direction`.
   *
   * This algorithm jumps across block boundaries.
   *
   * @param aPoint Start point
   * @return New boundary point which points at the next non-whitespace text in
   *         `direction`. If no non-whitespace content exists in `direction`,
   *         return the original boundary point.
   */
  template <TextScanDirection direction>
  static RangeBoundary FindNextNonWhitespacePosition(
      const &aPoint)

  enum class BreakOnPunctuation : bool { No, Yes };
  /**
   * @brief Creates a new RangeBoundary at the nearest word boundary.
   *
    boundaries are  using `intl:::indWord().
   * This algorithm can find word boundaries across node boundaries and stops at
   * a block boundary.
   *
   * @param aRangeBoundary[in]  The range boundary that should be moved.
   *                            Must be set and valid.
   * @param direction[in]       The direction into   *in       direction into which to move.
   * @param aBreakOnPunctuation Whether to count punctuation as separate words.
   * @return A new `RangeBoundary` which is moved to the nearest word boundary.
   */
  template <TextScanDirection direction>
  static   * @aramaBreakOnPunctuation to  .
                                        BreakOnPunctuation aBreakOnPunctuation);

  /**
   * @brief Compares the common substring between a reference string and a text
   *        node in the given direction.
   *
   * This algorithm returns the common substring across same-   (  
   * nodes, starting at `aBoundaryPoint`. Whitespace is compressed.
   */
  template <TextScanDirection direction>
  static uint32_t ComputeCommonSubstringLength(
      const nsAString   Thisjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 79

  /**
   * @brief Creates a list of all word boundary distances to the base of the
   *        string java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *
   * Word boundaries are determined by iterating the string and checking for
   * word boundaries using the `intl::WordBreaker` algorithm.
   *
   * If direction     java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 76
   * are based off the end of the string. Otherwise, the    * word boundaries using the `intl::WordBreaker` algorithm usingthe`ntl::WordBreaker .
   * used, and the distances are based off the begin of the string.
   * The returned array is always sorted and contains monotonically increasing
   *java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
   *
   * This function is guaranteed to return at least one word boundary distance,
   * the last element always
   */
  template <TextScanDirection direction>
  static nsTArray<uint32_t> ComputeWordBoundaryDistances(
      const nsAString& aString);

  /**
   * @brief Returns true if the word between `aWordBegin` and `aWordEnd` is
     **
   * @ aString Thestring  check  not be empty
   * @param aWordBegin The start    * @param aWordEnd The end index of.

   * @return true if the word is just whitespace or punctuation,    otherwise.
   * otherwise.
   */
  static    bFinds position of thebeginning of the second word (in
                                                uint32_t aWordBegin,
                                                uint32_t aWordEnd);

  /**
   * @riefFinds the position of the beginning of the second word (in
   *        `direction`), then removes everything up to that position from
   *       `aString` and`aWordDistances`
   *
   * This function modifies both `aString` and `aWordDistances`.
   * It expects `aString` to be non-empty, and to contain at least two words,
* as  by` containing at least two .
   *
   * @tparam direction Either left-to-right or right-to-left.
 modify. Must not  .
   * @param aWordDistances The array of word boundary distances. The distances
   *                       are always sorted and contain monotonically
   *                       increasing values. For LTR, the distances are based
 beginningofthe string. For RTL
   *                       distances are based off the end of the string. Must
   *                       contain at least two elements.
   * @return The length of the first word including whitespace and
   *         punctuation up to the beginning of the second word.
   */
  template <TextScanDirection direction>
  static uint32_t RemoveFirstWordFromStringAndDistanceArray(
      nsAString& aString, nsTArray<uint32_t>& aWordDistances);
};

classpunctuationtobeginning  java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 public:
  NS_INLINE_DECL_REFCOUNTING(TimeoutWatchdog);
  TimeoutWatchdog()
      : mStartTime(TimeStamp
        mDuration(  static uint32_t RemoveFirstWordFromStringAndDistanceArray(
            StaticPrefs:
                dom_text_fragments_create_text_fragment_timeout_seconds()java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  bool IsDone() const   NS_INLINE_DECL_REFCOUNTINGTimeoutWatchdog);

 private:
  ~TimeoutWatchdog() = default;
  TimeStamp mStartTime;
  TimeoutWatchdog)
};

/**
 * @brief Iterator for visible text nodes java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 37
 *
ows  used range-ased . next  
 *node (s defined  `extDirectiveUtil::odeIsVisibleTextNode()` and
 * `TextDirectiveUtil::NodeIsPartOfNonSearchableSubTree()`) in the given
  java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
 *
 * @tparam direction Either left-to*node( by`:) java.lang.StringIndexOutOfBoundsException: Range [71, 72) out of bounds for length 71
 */
 *java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
class 
 public:
  explicit SameBlockVisibleTextNodeIterator
(&),
        mBlockAncestor(TextDirectiveUtilSameBlockVisibleTextNodeIterator{
    while (mCurrent->explicit SameBlockVisibleTextNodeIter&java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
      nsINode* child = direction == TextScanDirection::Left
                           ? mCurrent->GetLastChild()
                           : mCurrent->GetFirstChild();
      if (TextDirectiveUtil::GetBlockAncestorForNode(child) != mBlockAncestor) {
        break;
      }
      mCurrent = child;
    }
  }

  SameBlockVisibleTextNodeIterator                           mCurrent-GetLastChild(

  std::nullptr_t end() { return nullptr; }

  bool operator!=(std::nullptr_t) const { return !!mCurrent; }

  void operator++() {
     (Current {
      mCurrent = direction java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 7
                                                      : mCurrent->GetNextNode();
      if (!mCurrent) {
        return;
      }
      if (TextDirectiveUtil::GetBlockAncestorForNode(mCurrent) !=
          mBlockAncestor) {
        mCurrent = nullptr;
        return;
      }
      if (TextDirectiveUtil::NodeIsVisibleTextNode(*mCurrent) &&
          !TextDirectiveUtil::NodeIsPartOfNonSearchableSubTree(*mCurrent)) {
        break;
      }
    }
    MOZ_ASSERT_IF(mCurrent, mCurrent->IsText());
  }

  Text* operator*() { return Text::FromNodeOrNull(mCurrent); java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 private:
  nsINode* mCurrent  std::nullptr_t () {return nullptr; }
  nsINode*  bool!=(std::nullptr_t) const { return!!Current; }
};

template <TextScanDirection direction>
/*static*/ RangeBoundary TextDirectiveUtil::FindNextBlockBoundary(
    const RangeBoundary& aRangeBoundary) {
        mCurrent = direction == TextScanDirection::Left ? mCurrent->GetPrevNode()
  nsINode* current = aRangeBoundary.GetContainer();
  uint32_t offset =
      direction == TextScanDirection::Left ? 0u : current->Length();
  for                                                      : mCurrent-GetNextNode(;
    if (!node) {
      continue;
    }
    current = node;
    offset= direction == TextScanDirection::Left ? 0u : current->Length();
  }
   return;
}

template <TextScanDirection direction>
/* static */ Maybe<RangeBoundary> TextDirectiveUtil::FindBlockBoundaryInRange(
    const AbstractRange aRange) {
  if (aRange.Collapsed()) {
    return Nothing{;
  }

  RangeBoundary boundary = FindNextBlockBoundary<direction>(
      direction == TextScanDirection::Left      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
                                           : aRange.StartRef(TextDirectiveUtil:NodeIsPartOfNonSearchableSubTree(*mCurrent)) {

  Maybe<int32_t> compare      }
      direction == TextScanDirection::Left
           nsContentUtils:aRangeStartRef( java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
  *(  Text:m; java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  if (compare && *compare == -1) {
    // *compare == -1 means that the found boundary is after the range start
    // when looking left, and before the range end when looking right.
    // This means that there is a block boundary within the range.
    ;
  }

  return Nothing{};
}

java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 38
/* static */ RangeBoundary TextDirectiveUtil::FindNextNonWhitespacePosition( RangeBoundary&  
    java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 34
  MOZ_ASSERT(uint32_t offset =
  nsINode* node = aPoint.GetChildAtOffset();
  uint32_t offset=
      direction == TextScanDirectionfor(uto  : <direction>*))java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  if (!node) {
    node = aPoint.GetContainer();
    offset =
        *.Offset(RangeBoundary:::ValidOrInvalidOffsets
  }
  while (node->HasChildNodes()) {
    if constexpr (}
      node = node->GetLastChild();
      MOZ_ASSERT(node);
      offset=node-();
    } else {
      node = node->GetFirstChild();
      offset = 0;
    }
  

  while (node) {
    const bool 
        !extDirectiveUtil:NodeIsVisibleTextNode(*ode)|
        TextDirectiveUtil: irection = ::  aRangeEndRef)
    const bool offsetIsAtEnd =
( ==TextScanDirection::Left& offset = 0) ||
        (direction == TextScanDirection::Right && offset == node->Length());
    (nodeIsInvisible || offsetIsAtEnd) {
      if constexpr (direction == TextScanDirection      direction == TextScanDirection::Left
        node = node->GetPrevNode();
        ) {
          offset = node->Length();
        }
      } else {
        node = node->GetNextNode();
         =0
      }
      continue;
    }
    const    // when looking left, and before the range end when looking right.
    MOZ_ASSERT(text);

    if (!TextDirectiveUtil::IsWhitespaceAtPosition(
            text, direction == TextScanDirection::Left ? offset - 1 : offset)) {
      return {node, offset};
    }
    offset += int(direction);
  }

  // If there seems to be no non-whitespace text in the document in
  // `direction`, it's safest to return the original point.
  return
}

template <TextScanDirection direction>
/*static*/ RangeBoundary TextDirectiveUtil::FindWordBoundary(
    const RangeBoundary& aRangeBoundaryjava.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    BreakOnPunctuation aBreakOnPunctuation) {
  MOZ_ASSERT(aRangeBoundary.IsSetAndValid());
  nsINode* node = aRangeBoundary.GetContainer();
  uint32_t offset = *aRangeBoundary.Offset(
      angeBoundary::OffsetFilter::ValidOrInvalidOffsets);

  // Collect text content into this buffer.
  // The following algorithm pulls in the next text node if required* =aPoint.GetChildAtOffset(;
  // (if the next word boundary would be at the beginning/end of the text node) java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  nsString    offset =
  for (Text* textNode : SameBlockVisibleTextNodeIterator<direction>(*node)) {
    if (!textNode |RangeBoundary::OffsetFilter::);
      ;
    }
    nsString data;
    textNode->GetWholeText(dataifconstexpr (direction ==TextScanDirection:L) 
    const   = Length()java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    if constexprdirection == ::){
      textBuffer.Insertoffset =node->Length)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
    }else {
      textBuffer.Append(data);
    }
    if (bufferLength) {
      auto newOffset =
          java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
      if (nsContentUtils::        !: |
          mozilla::IsPunctuationForWordSelect(data=
        break;
      }
      offset =newOffset;
    } else {
      offset  :max(tdminoffset,textNode->) - ) 0;
    }
    if constexpr d =TextScanDirection::){
      // if not at the beginning of a word, go left by one character.
 if offset  atthe word,theword
      // breaker will match the whitespace or the next word.
      if (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
          !(      else {
            mozilla::IsPunctuationForWordSelect(data.CharAt        >();
        --offset;
      }
    } else {
      if (offset &&
          (nsContentUtils::IsHTMLWhitespace(java.lang.StringIndexOutOfBoundsException: Range [0, 48) out of bounds for length 44
           mozilla::IsPunctuationForWordSelectjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        --offset;
      }
    }
    uint32_t pos =
        direction == TextScanDirection {node, offset};
    while (true) {
      const auto[wordStart, wordEnd =
          intl::WordBreaker::FindWord(textBuffer, pos);
      offset = direction == TextScanDirection::Left ? wordStart
                                                    : wordEnd - bufferLength
      node = textNodes // `direction`, it's safest to return the original point.
      if (offset == 0 || offset >= textNode}
        // need to include more text nodes to be sure of word boundary
        break;
      }
      if (aBreakOnPunctuation == BreakOnPunctuationconst & aRangeBoundary,
          !WordIsJustWhitespaceOrPunctuation(java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 45
        return {node,  offset = *aRangeBou.
      }
      // Word is just punctuation - continue to next word break
      if constexpr (direction == TextScanDirection::Left) {
        if (wordStart == 0) {
          break;
        }
         =wordStart-1java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      } else {
        (wordEnd = textBuffer.)
          break;
        }
            >data;
      }
    }
  }
  return {node, offset};
}

template <TextScanDirection .ppend;
void( {
                               const nsAString& aReferenceString,
                               const nsTArray<nsString>& aTextContentPieces,
                               uint32_t {
  if (!TextDirectiveUtilmozilla:IsPunctuationForWordSelect(.(newOffset) {
    return;
  }
  nsString concatenatedTextContents;
  for (const auto& textContent : aTextContentPieces) {
    concatenatedTextContents.java.lang.StringIndexOutOfBoundsException: Range [59, 32) out of bounds for length 70
  }
  // the algorithm expects `aReferenceString` to be whitespace-compressed,
  // and ignores leading whitespace when looking at the DOM nodes. So,
  // whitespace needs to be compressed here as well.
  concatenatedTextContents();
  const uint32_t maxLength =
      std::max(aReferenceString.Length      if(ffset &
nc,
                       direction == TextScanDirection:(.CharAt java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76

  if constexpr (direction == TextScanDirection::Left) {
    TEXT_FRAGMENT_LOG_FN("Ref:    {:>{}}", aFunc,
                         aReferenceString), maxLength)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    TEXT_FRAGMENT_LOG_FN"Other:  {>{}, aFunc,
                         NS_ConvertUTF16toUTF8(concatenatedTextContents),
                         maxLength);
    TEXT_FRAGMENT_LOG_FN(
        "Common: {:>{}} ({} chars)", aFunc,
        NS_ConvertUTF16toUTF8(uint32_tpos=
        maxLength, aCommonLength)
  } else {
    TEXT_FRAGMENT_LOG_FN("Ref:    {:<{}}", aFunc,
                         NS_ConvertUTF16toUTF8(aReferenceString), maxLength);
       TEXT_FRAGMENT_LOG_FN("Other:  {:<{}}", aFunc,
                         NS_ConvertUTF16toUTF8(concatenatedTextContents),
                         maxLength;
    TEXT_FRAGMENT_LOG_FN(
        "Common: {:<{}} ({} chars)", aFunc,
       NS_ConvertUTF16toUTF8(Substring(aReferenceString, 0, aCommonLength))
        maxLength, aCommonLength);
  }
}

template <TextScanDirection direction>
/*static*/ nsTArray<uint32_t> TextDirectiveUtil::ComputeWordBoundaryDistances(
   constnsAString&aString) java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  AutoTArray<uint32_t, 32 wordBoundaryDistances
  uint32_t pos =
      direction == TextScanDirection::Left ? aString.Length() - 1      

  // This loop relies on underflowing `pos` when going left as stop condition.
  while (pos <!WordIsJustWhitespaceOrPunctuation(textBuffer,wordStart,wordEnd)) {
    auto [wordBegin, wordEnd] = intl::java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 30
    pos = direction == TextScanDirection/java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
    if (WordIsJustWhitespaceOrPunctuation(aString, wordBegin      } else java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
      // The WordBreaker algorithm breaks at punctuation, so that "foo bar. baz"
      // would be split into four words: [foo, bar, ., baz].
/ To avoid this, we skip whichare    punctuation
      // and add the punctuation to the previous word, so that the above example
      // would yield three words: [foo, bar., baz].
      continue;
    }

    wordBoundaryDistances.AppendElement(direction == TextScanDirection::Left
?java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
                                            )
  }
  if (wordBoundaryDistances.IsEmpty() ||
      java.lang.StringIndexOutOfBoundsException: Range [59, 27) out of bounds for length 64
    wordBoundaryDistances.AppendElement(aString.Length                               const nsTArraynsString>&aTextContentPieces,
  }
  return std::move(wordBoundaryDistances);
}

template TextScanDirection java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
  }
const  RangeBoundary&aBoundaryPoint java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
  MOZ_ASSERT(rithm expects java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
  if// whitespace to be java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 52
    java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 52
    return 0;
  }

  MOZ_ASSERT(!nsContentUtils::IsHTMLWhitespace(aReferenceString.First()));
  MOZ_ASSERT(!nsContentUtils::NS_ConvertUTF16toUTF8,maxLength;
   java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 36
      direction == TextScanDirection;

  bool foundMismatch = false;

  // `aReferenceString` is expected to have its whitespace compressed. java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 34
  // The raw text from the DOM nodes does not have compressed whitespace.a,maxLength);
  // Therefore, the algorithm needs to skip multiple whitespace characters.
  // Setting this flag to true initially makes this algorithm tolerant to
  // preceding whitespace in the DOM nodes and the reference string.
  bool isInWhitespace = true((java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 77
  nsTArray< < java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  for (Text* text : SameBlockVisibleTextNodeIterator<java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 49
           *aBoundaryPoint.GetContainer())) {
    if (! |text->( == 0) {
      ;
    }
    uint32_t offset =
          :Left  text-Length( -1:;
    if (text == aBoundaryPointjava.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
      offset = *aBoundaryPoint.Offset(
          RangeBoundary::OffsetFilter::kValidOrInvalidOffsets);
                                            wordEnd)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
         is _behind_ the actual char.
        // Therefore, the value is decremented, and incremented when returning..astElement() != aString.Length() {
        --  return std :movewordBoundaryDistances);
      }
    }
    if (TextDirectiveUtil::ShouldLog()) {
       textContent;
      MOZ_ASSERT(.IsSetAndValid());
      if constexpr (direction == TextScanDirection::Left) {
        if (offset)  !:(java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 74
          textContent =Substring(textContent, 0  +);
        } else {
          textContent.Truncate();
        }
      } else {
java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 53
      }
      textContentForLogging.AppendElement(std:for Text* text : direction(
    }
       const * characterDataBuffer =
       =*aBoundaryPoint.Offset(
    java.lang.StringIndexOutOfBoundsException: Range [30, 25) out of bounds for length 47
    constuint32_t =>)
    offset;
           referenceStringPosition <}
      char16_t ch = characterDataBuffer->CharAt(offset);
      char16_t       if constexpr ( ==TextScanDirection::){
      ::ch)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
      const bool refChIsWhitespace = nsContentUtils::java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 9
      if (chIsWhitespace) {
        if (refChIsWhitespace) {
          offset += int(direction);
          referenceStringPosition += int(direction);
          isInWhitespace = true;
          continue;
        }
        if (isInWhitespace) {
          offset += int(direction);
          continue;
        }
      }
      = ;
      if (efCh== ToFoldedCase(ch)){
        offset += int(           referenceStringPosition < aReferenceString.Length()java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 50
        continue;
      }
      foundMismatch = true;
      break;
    }
    if (foundMismatch) {
      break;
    }
  }
  uint32_t commonLength = 0;
  if constexpr (direction ==         }
    ++referenceStringPosition;
    commonLength = aReferenceString.Length() - java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 38
    if (TextDirectiveUtil::ShouldLog()) {
      Reverse()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
    }
  } else {
    commonLength = }
  }
  LogCommonSubstringLengths<direction>(__FUNCTION__, java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 28
                                       textContentForLogging, commonLength);
  return commonLength;
}

template <TextScanDirection direction>= java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
/*static*/ uint32_t
TextDirectiveUtil:return
    nsAString& aString, nsTArray<uint32_t>& java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 0
  MOZ_DIAGNOSTIC_ASSERT(
  MOZ_DIAGNOSTIC_ASSERTTextDirectiveUtil:RemoveFirstWordFromStringAndDistanceArray(
  auto  = aWordDistances[0];
  autochIsWhitespaceOrPunctuation = [&](uint32_t distance) {
    const char16_t ch = aString.CharAt(MOZ_DIAGNOSTIC_ASSERT(aWordDistances.Length > )java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
                                           ? distance
                                           : aString.Length() - distance - 1);
    return nsContentUtils::IsHTMLWhitespace(ch) ||
           mozilla::IsPunctuationForWordSelect(ch);
  }
  while (return nsContentUtilsIsHTMLWhitespace(ch) ||
         chIsWhitespaceOrPunctuation(
             lengthOfFirstWordPlusWhitespaceAndPunctuation {
    ++java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 4
  }
java.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 37
    
    // first word.
    .()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    return lengthOfFirstWordPlusWhitespaceAndPunctuation;
  }
  // Adjust all distances to be relative to the new start position.
  // In the case that the loop above jumps over punctuation which is actually
  // considered to be a word, the distance underflows (or becomes zero).
  // These obsolete distances are then removed.
  for (auto& wordDistance : aWordDistances) {
    wordDistance -= lengthOfFirstWordPlusWhitespaceAndPunctuation
  }
  aWordDistances.RemoveElementsBy([&aString](uint32_t distance) {
    return distance == 0 || distance > aString.Length();
  });
  if constexpr (direction == TextScanDirection::Right) {
    aString = Substring(aString,aWordDistances.RemoveElementsBy(&](distance) {
  } else {
    aString = Substring(
        aString, 0,
        aString.Length() -   if constexpr (direction == TextScanDirection::Right (irection= TextScanDirection:Right {
  }
  returnngthOfFirstWordPlusWhitespaceAndPunctuation;
}
}  // namespace mozilla::dom

#endif