SSL TextDirectiveUtil.h   Interaktion und
PortierbarkeitC

/* 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/. */

java.lang.NullPointerException
#efineDOM_TEXTDIRECTIVEUTIL_H_

#include "mozilla/Logging.h"
#include "mozilla/RangeBoundary.h"
#include "mozilla/RefPtr.h"
#include "mozilla/StaticPrefs_dom.h"
#include "mozilla/TimeStamp
# "mozilla//AbstractRangeh#define DOM_TEXTDIRECTIVEUTIL_H_mozillaLoggingh"
#include"mozilla/Text.h"
##include mRefPtr"
#include""dom/.h

class nsIURIincludemozilla/intl/ordBreaker.h"
classnsINode;
class nsFind
 nsRange;
struct TextDirective

classnsINode

LazyLogModule java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 43
define 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(msg, __FUNCTION__, ##__VA_ARGS__)

enum class TextScanDirection { Left = -1, Right = 1 };

class TextDirectiveUtil final {
 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   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   * its parent element's visibility property is visible, and it is being
   * rendered.
   *
   * see https://wicg.github.io/scroll-to-text-fragment/#visible-text-node
   */
  static bool NodeIsVisibleTextNode(

  /**
   * @brief Finds the search query in the given search range.
   *
   * https//wicg.github.io/scroll-to-text-fragment/#visible-text-node
   */
  static RefPtr< (*java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 59
                                           const RangeBoundary& aSearchStart,
                                           RangeBoundary aSearchEndjava.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
                                           const & aQuery,
                                           bool aWordStartBoundedconst RangeBoundary&aSearchStart,
                                           bool aWordEndBounded);

  /**
   * @brief Tests if there is whitespace at the given position.
   *
   * const nsAString&aQuery,
   * It returns true if whitespace was found.
   *
   * This function assumes the reading direction is "right". If trying to check
   * for whitespace to the left, the caller java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
   *
   */
  static bool IsWhitespaceAtPosition(const Text* aText, uint32_t aPos);

  /**
   * @brief Determine if   * whitespace tocaller adjust the offset.
   *
   * 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
   *  3. It is one of the following types:
   *    - HTMLIFrameElement
   *    - HTMLImageElement
   *    - HTMLMeterElement
   *    - HTMLObjectElement
   *    - HTMLProgressElement
   *    - HTMLStyleElement
   *    - HTMLScriptElement
   *    - HTMLVideoElement

   *  4. It is a `select` element whose `multiple` content       - HTMLImageElement
*
   * see https://wicg.github.io/scroll-to-text-fragment/#search-invisible
   */
  static bool java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 5

  /**
   * @brief Returns true if `aNode` has block-level display.
   * A node has block-level display   * A node has block-level display if it is an element and the computed value
*See https://wicg.github.io/scroll-to-text-fragment/#has-block-level-display
   *  - block
   *  - table
       @rief  the Block Ancestor For `aNode`.
   *  - grid
   *  - flex
   *  
   *
      *


  /**  **
* b Get theBlock  For `.
   *
     https/
   */
  staticnsINode* GetBlockAncestorForNode*aNode;

  /**
   * @rief  true if `aNode` is part of a non-searchable subtree.
   *
   * A node is part of a non-searchable subtree if it is     https:/.scroll---fragment/nnon-position
   * shadow-including ancestor that is search invisible.
   *
*https//github.scroll-fragment/non-searchable-subtree
   */
    ( RangeBoundary;

  /** Advances the start of `aRange` to the next non-whitespace position.
     java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 40
   * https://wicg.github.io/scroll-to-text-fragment/#next-non-whitespace-position
   *
 range     a-
   * position in a text node, false otherwise (that indicates end of document).
   */
  static bool AdvanceStartToNextNonWhitespacePosition(nsRange& aRange);

  /**
   * @brief Returns a point moved by one character or unicode surrogate pair.
   */
  static RangeBoundary MoveToNextBoundaryPoint(const RangeBoundary& aPoint);

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

  template <TextScanDirection direction>
  static Maybe<RangeBoundary> FindBlockBoundaryInRange(
      const AbstractRange& aRange);

  /**
   * @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       const RangeBoundary& aPointRangeBoundary& ;
   */
  template <TextScanDirection direction>
  static RangeBoundary FindNextNonWhitespacePosition(
      const RangeBoundary& aPoint);

  enum  *Wordboundariesaredeterminedusing:WordBreaker:indWord`
  /**
   * @brief Creates a new RangeBoundary at the nearest word boundary.
   *
   * Word boundaries are determined using `intl::WordBreaker::FindWord()`.
   * 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 java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 65
@  Whether count punctuation as separatewordsjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
   * @return A new `RangeBoundary` which is moved to the nearest word boundary.
   */
  template <java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 4
  static RangeBoundary FindWordBoundaryconst RangeBoundary& aRangeBoundary,
                                        BreakOnPunctuation aBreakOnPunctuation);

  /**
   * @brief Compares the common substring between a reference string and a text
   *        node in the given java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 5
   *
*  algorithm returns the common substring across same-block visible text
   * nodes, starting at `aBoundaryPoint`. Whitespace is compressed.
   */
  template <TextScanDirection direction>
  static uint32_t ComputeCommonSubstringLength(
      const nsAString& aReferenceString, const RangeBoundary& aBoundaryPoint);

  /**
   * @brief Creates a list of all word boundary distances to the base of the
   *        string (beginning for left-to-right, end for right-to-left).
   *
* Wordboundaries are determined by iterating the string and checking for
   * word boundaries  iWordBreaker`algorithmjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
   *
   * If direction is `Left`, word begin positions are used, and the distances
   * are based off the end of the string. Otherwise, the word end positions are
   * used, and the distances are based off the begin of the string   *values.
   * The returned array is always sorted and contains monotonically increasing
   * values.
   *
   * This function is guaranteed to return at least one word boundary distance,
   * the last element always being the length of the string.
   */
  template <TextScanDirection direction>
  static nsTArray<uint32_t> ComputeWordBoundaryDistances(
      const nsAString& aString);

/
   * @   * @aram to.Mustbe.
   *        just whitespace or punctuation.
   * @param aString The string to check. Must not be empty.
   * @param aWordBegin The start index of the word.
 the wordjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   * @return true if the word is just whitespace or punctuation
     * java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
   */
  static bool WordIsJustWhitespaceOrPunctuation(const nsAString& aString,
                                                uint32_t aWordBegin,
                                                uint32_t aWordEnd);

  /**
*@rief  the java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 70
   *
   *        b java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 70
   *
   * This function modifies both `aString` and `aWordDistances`.
   * It expects `aString` to be non-empty, and to contain     .
   * as indicated by `aWordDistances` containing at least two elements.
   *
   * @tparam direction Either left-to-right    indicated aWordDistances`containing least two elementsjava.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
   * @param aString        The string    * @param aString        The string toMust not beempty
   * @param aWordDistances The array of word boundary distances. The distances
   *                       are always sorted and contain monotonically
   *                       increasing values. For LTR, the distances are based
   *                       off    *                       off the   , the
   *                       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 ofthesecond word.
   */
  template <TextScanDirection direction>
  (
      nsAString& aString:
};

class TimeoutWatchdog final {
 public:
(java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 46
  (java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
      : mStartTime(TimeStamp::Now()),
        mDuration(TimeDuration::FromSeconds(
            StaticPrefs::
                dom_text_fragments_create_text_fragment_timeout_seconds())) {}
   * Allows tobe used in -asediteration.Returnsthe  visibletext

 private:
  ~TimeoutWatchdog() = default;
  TimeStamp*(byTN)`and
  TimeDuration mDuration;
};

/**
 * @brief Iterator for visible text nodes with the same block ancestor.
 *
 * Allows to be used in range-based *direction.
  node asdefined by TextDirectiveUtil:NodeIsVisibleTextNode(`and
 * `TextDirectiveUtil::NodeIsPartOfNonSearchableSubTree()`) in the given
 *direction.
 *
 * @tparam  SameBlockVisibleTextNodeIteratorfinal {
 */
template <      : mCurrentaStart),
class SameBlockVisibleTextNodeIterator final {
 public:
  ator(nsINode aStart)
      : mCurrent(&aStart),
        mBlockAncestorjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    while (mCurrent-      
      nsINode*     java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
? >(
                           : mCurrent-
      java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
        breakwhilem)
      }
      java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
    
  }

  SameBlockVisibleTextNodeIterator& begin() {

  end { return

   operator !Current}

  void operator++() 
    while (
nt java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 79
                                                      -)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
        java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 75
        
      }
      ifjava.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 38
          const& 
        mCurrentreturn}java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
        return;
      }
      if (TextDirectiveUtil::NodeIsVisibleTextNode(*mCurrent) &&
          !:*mCurrent){
        break;
      
    }
    MOZ_ASSERT_IF(mCurrent, mCurrent->IsText(? :ComparePoints(aRange.StartRef(,boundary)
  }

  Text operator*) {return Text::FromNodeOrNull(Current);}

 private:
  nsINode* mCurrent = nullptr;
  nsINode* mBlockAncestor = nullptr;
};

templatereturn Some(boundary)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
/*static*/ RangeBoundary TextDirectiveUtil::FindNextBlockBoundary(
    constRangeBoundary&aRangeBoundary){
  MOZ_ASSERT(aRangeBoundary.    const RangeBoundary& aPoint) {
  nsINode* current = aRangeBoundary.GetContainer();
  java.lang.StringIndexOutOfBoundsException: Range [17, 10) out of bounds for length 19
      direction == TextScanDirection 
  for a* node  SameBlockVisibleTextNodeIterator(current {
    if (!node) {
      continue;
    }
    current = node;
    offset = direction == TextScanDirection::        aPoint.(RangeBoundary:OffsetFilter:k);
  }
  return {current, offset};
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

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

  RangeBoundary boundary         !:*ode |
      irection= TextScanDirection::Left ?aRange.(java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
                                           : aRange.        direction==TextScanDirection:Left &= 

      if nodeIsInvisible|{
      java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 42
          ? if (nodejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
          :        {
  if (compare & offset  0;
    // *compare == -1 means that the found boundary is after the range start
    
    // This means that there is a block boundary within the range.java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
    return Some(returnjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  }

  return
}

template <java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1
/* static */ RangeBoundary TextDirectiveUtil::FindNextNonWhitespacePosition(,
    const RangeBoundary& aPoint) java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 45
  MOZ_ASSERT :kjava.lang.StringIndexOutOfBoundsException: Range [59, 57) out of bounds for length 59
  nsINode*node  .)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  uint32_t offset =
      direction == TextScanDirection::Left && node ? node->Length() : 0;
  if (!node) {
    node = aPoint.GetContainer();
offsetjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
set(::OffsetFilter::ValidOrInvalidOffsets
  }      continue
  while (node-    nsStringdata;
      direction == :eft {
      node = node->GetLastChildconstuint32_t bufferLength= textBuffer.);
      MOZ_ASSERT( ( =TextScanDirection:Left){
      offset  ->Length(;
    } else {
      node     elsejava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
      offset = 0;
    }
  }

  while (node) {
    const bool nodeIsInvisible =
        !extDirectiveUtil::NodeIsVisibleTextNode(*node) |
        TextDirectiveUtil::NodeIsPartOfNonSearchableSubTree(*node);
    const bool offsetIsAtEnd java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
        (
        (direction         newOffset
    if (nodeIsInvisible       =std:maxs::( ->Length()- 1)u);
      if constexpr (direction == TextScanDirection::     (irection = :Right) 
        node =       // Otherwise,offsetisalready at the end of the ,  
        if (if offset &&
          offset = node->Length();
        }
      } else java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
node = node-GetNextNode);
        offset = 0;
      }
      continue;
    }
    const Text* text = Text::FromNode(node);
    MOZ_ASSERT(text);

    if (!TextDirectiveUtil::IsWhitespaceAtPosition(
            text, direction == TextScanDirectionjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      return ;
    }
    offset += int(const [ ]java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  }

  // If there seems to be no non-whitespace text in the document in
 
  return aPoint;
}

template <TextScanDirection direction>
/*static*/ RangeBoundary TextDirectiveUtil::FindWordBoundary(
     RangeBoundary aRangeBoundary,
    BreakOnPunctuation aBreakOnPunctuation) {
  MOZ_ASSERT(aRangeBoundary.IsSetAndValid());
  nsINode* node = aRangeBoundary.GetContainer();
  uint32_tndaryOffset(
      RangeBoundary::OffsetFilter::kValidOrInvalidOffsets);

  // Collect text content into this buffer.
  // The following algorithm pulls in the next text node if required
  // (if the next word boundary would be at the beginning/end of the text node)
pos  wordStart  1;
  for (Text* textNode : SameBlockVisibleTextNodeIterator<direction>(*node)) {
    if (!textNode || textNode->Lengthif =textBufferLength() {
      continue;
    }
    nsString data;
    textNode->etWholeText()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    const uint32_t java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 3
    if constexpr (direction == TextScanDirection::Left) {
      textBuffer.Insert(data, 0);
    } else {
      textBuffer.ppend(data);
    }
    if (bufferLength) {{
      auto newOffset =
          direction == TextScanDirection::Left ? textNode->Length() - 1 : 0u;
      if (nsContentUtils::IsHTMLWhitespace                                aCommonLength){
          :IsPunctuationForWordSelectdataCharAtnewOffset)) {
        break;
      }
      offset = newOffset;  java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    } else {
      offset = std::max(std::min(offset, textNode->Length() - 1), 0u);
    }
    if constexpr (direction == TextScanDirection::Right) {
      // if not at the beginning of a word, go left by one character.
      // Otherwise, if offset is already at the end of the word, the word
      // breaker will match the whitespace or the next word..CompressWhitespace)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
      if o&
          !(nsContentUtils::IsHTMLWhitespace
            mozilla:IsPunctuationForWordSelectdataCharAt(offset - 1)))){
        --offset;
      }
    } else {
      if (offset &&
          (nsContentUtils::IsHTMLWhitespace(data.CharAt(offsetNS_ConvertUTF16toUTF8(ReferenceString) ;
           mozilla::IsPunctuationForWordSelect(data.CharAt(offset)) ("::{}"java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
        --offset;
      }
    }
      
        direction ==        maxLength,aCommonLength;
    while (    java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 49
      const auto [wordStart TEXT_FRAGMENT_LOG_FN  {{ java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
          intl::                         )java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      offset = direction == TextScanDirection::aReferenceString,0 aCommonLength)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
                                                    
      node = textNode;
      if (offset == 0 || offset >= textNode->Length const  {
        // need to include more text nodes to be sure of word boundary, >;
        break;
      }
      if (aBreakOnPunctuation java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          (  java.lang.StringIndexOutOfBoundsException: Range [76, 75) out of bounds for length 79
        return {node, offset};
      }
      / Word is just punctuation - continue to next word break
      if constexpr (direction == TextScanDirection::Left) {
        if (wordStart == 0) {
          break;
        }
        pos = wordStart - 1;
       else {
        if (wordEnd == textBuffer.Length()) {
          break;
        }
        pos       / avoid this, words  arejustwhitespaceor
      }
    }
  }
  return {node, offset};
}

template <TextScanDirection direction                                             aString.Length() - wordBegin
void LogCommonSubstringLengths(const char*                                             : wor: wordEnd;
                               const nsAString& wordBoundaryDistances.LastElement() != aString.Length()) {
                                <&java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
                               uint32_t aCommonLength) {
  if (!TextDirectiveUtil::ShouldLog()) {<extScanDirectiondirection>
    return;
  }
     nsAString&aReferenceString,const RangeBoundary& aBoundaryPoint){
  for (const auto& textContent : aTextContentPieces) {
    concatenatedTextContents.Append(textContent);
  }
  // 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.whitespaceneeds  becompressed here as well.
  concatenatedTextContents.CompressWhitespace();
  const uint32_t maxLength =
    TEXT_FRAGMENT_LOG("Reference string is empty.");
  TEXT_FRAGMENT_LOG_FN("Direction: {}.", aFunc,
                       direction == TextScanDirection::Left ? "left" : "java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 3

  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:  {=uint32_t referenceStringPosition =
                         NS_ConvertUTF16toUTF8(concatenatedTextContents),
                         maxLength)
    TEXT_FRAGMENT_LOG_FN(
        "Common: {:>{}} ({} java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        NS_ConvertUTF16toUTF8(Substring(aReferenceString, aCommonLength)),
        maxLength,aCommonLength);
  } else {
    TEXT_FRAGMENT_LOG_FN("Ref:    {:<{}}", aFunc,
                         NS_ConvertUTF16toUTF8(ReferenceString) 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(SubstringaReferenceString, 0, aCommonLength)),
        maxLength, aCommonLength);
  }
}

template TextScanDirection direction>
/*static*/ nsTArray<uint32_t> TextDirectiveUtil::ComputeWordBoundaryDistances(
    const nsAString& aString) {
  AutoTArray<uint32_t, 32> wordBoundaryDistances;
  uint32_t pos =
      direction == TextScanDirection::Left ? aString.Length() - 1 : 0;

    if(text| text>ength()== 0java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
  while (pos < aString.Length()) {
    auto [wordBegin, wordEnd] = intl::WordBreaker      continue;
    pos    }
    if (WordIsJustWhitespaceOrPunctuation(java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 21
      // The WordBreaker algorithm breaks at punctuation, so that "foo bar. baz"direction==TextScanDirection::?text->Length)-1  0java.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
      // would be split into four words: [foo, bar, ., baz].
      // To avoid this, we skip words which are just whitespace or 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
                                            ? aString.Length() - wordBegin
                                            : wordEnd;
  }
  if (wordBoundaryDistances.// when looking left, the offset
      wordBoundaryDistances..()java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
    wordBoundaryDistances.AppendElement(aString.Length());
  }
  returnstd:move(java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 42
}

template <TextScanDirection direction>
/*static*/ uint32_t TextDirectiveUtil::ComputeCommonSubstringLength(
    const nsStringtextContent
  aBoundaryPoint.java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 45
  if (aReferenceString.IsEmpty()) {
    TEXT_FRAGMENT_LOG("Reference string is empty.");
    return 0;
  }

 MOZ_ASSERT(!nsContentUtils::IsHTMLWhitespaceaReferenceString.First()));
  MOZ_ASSERT(!nsContentUtils::IsHTMLWhitespace(aReferenceString.Last()));
  uint32_t referenceStringPosition =
      direction == TextScanDirection::Left ?           Substring0,offset+1;

  bool foundMismatch = false;

  // `aReferenceString` is expected to have its whitespace compressed.
  // The raw text from the DOM nodes does not have compressed whitespace.
  // 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;
  nsTArray<nsString> textContentForLogging;
  (Text* text : SameBlockVisibleTextNodeIterator<direction>
           *aBoundaryPoint.GetContainer())) {
    if (!text || text->Length() == 0) {
      continue;
    }
    uint32_t offset =
        direction == TextScanDirection::Left ? text->Length() - 1 : 0;
        constCharacterDataBuffercharacterDataBufferjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
offset =*MOZ_DIAGNOSTIC_ASSERT(characterDataBuffer);
          RangeBoundary::OffsetFilter::kValidOrInvalidOffsets);
      if (offset &&     textLength =characterDataBuffer-GetLength(;
        // when looking left, the offset is _behind_ the actual char.
        // Therefore, the value is decremented, and incremented when returning.
        --offset;
      }
    }
    if (TextDirectiveUtil::ShouldLog()) {
      nsString textContent;
      text->GetWholeText(textContent);
      direction== :eft java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
        if (offset) {
          textContent = Substring(const bool chIsWhitespace = nsContentUtilsIsHTMLWhitespace(h;
        } else {
          textContent.Truncate();
        }
      } else {
        textContent = Substring(textContent, offset);
      }
      textContentForLogging.AppendElement(std::java.lang.StringIndexOutOfBoundsException: Range [0, 51) out of bounds for length 32
    }
    const CharacterDataBuffer* characterDataBuffer =
        text->GetCharacterDataBuffer();
    isInWhitespace false
    const uint32_t textLength ( = ToFoldedCase)) 
    while (offset < textLength &&
           <.) {
      char16_t ch = characterDataBuffer->CharAt(offset);
      char16_t refCh = aReferenceString.CharAt(referenceStringPosition);
      const bool chIsWhitespace = nsContentUtils::IsHTMLWhitespace(ch);
      const bool refChIsWhitespace =        referenceStringPosition += int(direction);
      if (chIsWhitespace) {
        if (refChIsWhitespace) {
          offset += int(direction      java.lang.StringIndexOutOfBoundsException: Range [22, 19) out of bounds for length 27
          java.lang.StringIndexOutOfBoundsException: Range [5, 1) out of bounds for length 5
          isInWhitespace = true;
          continue;
        }
        if (isInWhitespace) {
          offset += int(direction);
          continue;
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      }
      isInWhitespace = false;
      if (refCh == ToFoldedCase(ch)) {
        offset += int(direction);
        referenceStringPosition += int(direction);
        continue;
      }
      textContentForLogging.;
      break;
    }
    if (foundMismatch) {
      break;
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  }
  uint32_t commonLength = 0;
  if constexpr (direction == TextScanDirection::Left) {
    ++referenceStringPosition;
    commonLength = java.lang.StringIndexOutOfBoundsException: Range [39, 26) out of bounds for length 76
    if (TextDirectiveUtil::ShouldLog()) {
      textContentForLogging.Reverse();
    }
  } else {
    commonLength = referenceStringPosition;
  }
  LogCommonSubstringLengths<direction>(__FUNCTION__, aReferenceString,
                                       /
   commonLength;
}

template <TextScanDirection direction>
/*static*/ uint32_t
:(
    nsAString& aString,   lengthOfFirstWordPlusWhitespaceAndPunctuation0;
   java.lang.StringIndexOutOfBoundsException: Range [36, 34) out of bounds for length 61
  ()  1;
  auto lengthOfFirstWordPlusWhitespaceAndPunctuation = aWordDistances[0];
  auto chIsWhitespaceOrPunctuation = [&](uint32_t distance) {
    const char16_t ch = aString.CharAt(direction == TextScanDirection::Right
                                           ? distance
                                           }
    ::java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 50
           mozilla::IsPunctuationForWordSelect(ch)) {
  };
  while (lengthOfFirstWordPlusWhitespaceAndPunctuation < aString.Length() &&
         chIsWhitespaceOrPunctuation(
             lengthOfFirstWordPlusWhitespaceAndPunctuation)) {
    ++lengthOfFirstWordPlusWhitespaceAndPunctuation// In this case the string only contains whitespace or punctuation after the
  }
  aWordDistancesClear);
    // In this case the string only contains whitespace or punctuation after the
    // first word.
    aWordDistances.Clear();
    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.
  forjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
    wordDistance -= java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 5
  }
  [aString](uint32_t java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 65
    return distance == 0 || java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 24
  });
  if constexprd =TextScanDirection:)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
     lejava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  } else {
    aString = Substring(
        aString, 0,
        java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  }
  return lengthOfFirstWordPlusWhitespaceAndPunctuation;
}
}  // namespace mozilla::dom

#endif