/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */

#include "WSRunScanner.h"

#include "EditorDOMPoint.h"
#include "EditorUtils.h"
#include "HTMLEditUtils.h"

#include "mozilla/Assertions.h"
#include "mozilla/dom/AncestorIterator.h"
#include "mozilla/dom/CharacterDataBuffer.h"

#include "nsCRT.h"
#include "nsDebug.h"
#include "nsIContent.h"
#include "nsIContentInlines.h"

namespace mozilla {

using namespace dom;

using AncestorType = HTMLEditUtils::AncestorType;
using AncestorTypes = HTMLEditUtils::AncestorTypes;
using LeafNodeType = HTMLEditUtils::LeafNodeType;
using LeafNodeTypes = HTMLEditUtils::LeafNodeTypes;

template WSRunScanner::TextFragmentData::TextFragmentData(Options,
                                                          const EditorDOMPoint&,
                                                          const Element*);
template WSRunScanner::TextFragmentData::TextFragmentData(
    Options, const EditorRawDOMPoint&, const Element*);
template WSRunScanner::TextFragmentData::TextFragmentData(
    Options, const EditorDOMPointInText&, const Element*);
template WSRunScanner::TextFragmentData::TextFragmentData(
    Options, const EditorRawDOMPointInText&, const Element*);

NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetInclusiveNextCharPoint,
    const EditorDOMPoint&, Options, IgnoreNonEditableNodes, const nsIContent*);
NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetInclusiveNextCharPoint,
    const EditorRawDOMPoint&, Options, IgnoreNonEditableNodes,
    const nsIContent*);
NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetInclusiveNextCharPoint,
    const EditorDOMPointInText&, Options, IgnoreNonEditableNodes,
    const nsIContent*);
NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetInclusiveNextCharPoint,
    const EditorRawDOMPointInText&, Options, IgnoreNonEditableNodes,
    const nsIContent*);

NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetPreviousCharPoint, const EditorDOMPoint&,
    Options, IgnoreNonEditableNodes, const nsIContent*);
NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetPreviousCharPoint,
    const EditorRawDOMPoint&, Options, IgnoreNonEditableNodes,
    const nsIContent*);
NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetPreviousCharPoint,
    const EditorDOMPointInText&, Options, IgnoreNonEditableNodes,
    const nsIContent*);
NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetPreviousCharPoint,
    const EditorRawDOMPointInText&, Options, IgnoreNonEditableNodes,
    const nsIContent*);

NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetEndOfCollapsibleASCIIWhiteSpaces,
    const EditorDOMPointInText&, nsIEditor::EDirection, Options,
    IgnoreNonEditableNodes, const nsIContent*);

NS_INSTANTIATE_METHOD_RETURNING_ANY_EDITOR_DOM_POINT(
    WSRunScanner::TextFragmentData::GetFirstASCIIWhiteSpacePointCollapsedTo,
    const EditorDOMPointInText&, nsIEditor::EDirection, Options,
    IgnoreNonEditableNodes, const nsIContent*);

// FIXME: I think the scanner should not cross the <button> element boundaries.
constexpr static const AncestorTypes kScanAnyRootAncestorTypes = {
    // If the point is in a block, we need to scan only in the block
    AncestorType::ClosestBlockElement,
    // So, we want a root element of the (shadow) tree root element of the
    // point if there is no parent block
    AncestorType::ReturnAncestorLimiterIfNoProperAncestor,
    // Basically, given point shouldn't be a void element, so, ignore
    // ancestor
    // void elements
    AncestorType::IgnoreHRElement};
constexpr static const AncestorTypes kScanEditableRootAncestorTypes = {
    // Only editable elements
    AncestorType::EditableElement,
    // And the others are same as kScanAnyRootAncestorTypes
    AncestorType::ClosestBlockElement,
    AncestorType::ReturnAncestorLimiterIfNoProperAncestor,
    AncestorType::IgnoreHRElement};

template <typename EditorDOMPointType>
WSRunScanner::TextFragmentData::TextFragmentData(
    Options aOptions,  // NOLINT(performance-unnecessary-value-param)
    const EditorDOMPointType& aPoint,
    const Element* aAncestorLimiter /* = nullptr */)
    : mAncestorLimiter(aAncestorLimiter), mOptions(aOptions) {
  if (NS_WARN_IF(!aPoint.IsInContentNodeAndValidInComposedDoc()) ||
      NS_WARN_IF(!aPoint.GetContainerOrContainerParentElement())) {
    // We don't need to support composing in uncomposed tree.
    return;
  }

  MOZ_ASSERT_IF(
      aAncestorLimiter,
      aPoint.template ContainerAs<nsIContent>()->IsInclusiveDescendantOf(
          aAncestorLimiter));

  mScanStartPoint = aPoint.template To<EditorDOMPoint>();
  const Element* const
      editableBlockElementOrInlineEditingHostOrNonEditableRootElement =
          HTMLEditUtils::GetInclusiveAncestorElement(
              *mScanStartPoint.ContainerAs<nsIContent>(),
              mOptions.contains(Option::OnlyEditableNodes)
                  ? kScanEditableRootAncestorTypes
                  : kScanAnyRootAncestorTypes,
              ReferredHTMLDefaultStyle()
                  ? BlockInlineCheck::UseHTMLDefaultStyle
                  : BlockInlineCheck::UseComputedDisplayOutsideStyle,
              aAncestorLimiter);
  if (NS_WARN_IF(
          !editableBlockElementOrInlineEditingHostOrNonEditableRootElement)) {
    return;
  }
  mStart = BoundaryData::ScanCollapsibleWhiteSpaceStartFrom(
      mOptions, mScanStartPoint, &mNBSPData,
      *editableBlockElementOrInlineEditingHostOrNonEditableRootElement);
  MOZ_ASSERT_IF(mStart.IsNonCollapsibleCharacters(),
                !mStart.PointRef().IsPreviousCharPreformattedNewLine());
  MOZ_ASSERT_IF(mStart.IsPreformattedLineBreak(),
                mStart.PointRef().IsPreviousCharPreformattedNewLine());
  mEnd = BoundaryData::ScanCollapsibleWhiteSpaceEndFrom(
      mOptions, mScanStartPoint, &mNBSPData,
      *editableBlockElementOrInlineEditingHostOrNonEditableRootElement);
  MOZ_ASSERT_IF(mEnd.IsNonCollapsibleCharacters(),
                !mEnd.PointRef().IsCharPreformattedNewLine());
  MOZ_ASSERT_IF(mEnd.IsPreformattedLineBreak(),
                mEnd.PointRef().IsCharPreformattedNewLine());
}

// static
template <typename EditorDOMPointType>
Maybe<WSRunScanner::TextFragmentData::BoundaryData> WSRunScanner::
    TextFragmentData::BoundaryData::ScanCollapsibleWhiteSpaceStartInTextNode(
        const EditorDOMPointType& aPoint, NoBreakingSpaceData* aNBSPData) {
  MOZ_ASSERT(aPoint.IsSetAndValid());
  MOZ_DIAGNOSTIC_ASSERT(aPoint.IsInTextNode());

  const bool isWhiteSpaceCollapsible = !EditorUtils::IsWhiteSpacePreformatted(
      *aPoint.template ContainerAs<Text>());
  const bool isNewLineCollapsible =
      isWhiteSpaceCollapsible &&
      !EditorUtils::IsNewLinePreformatted(*aPoint.template ContainerAs<Text>());
  const bool isNewLineLineBreak =
      EditorUtils::IsNewLinePreformatted(*aPoint.template ContainerAs<Text>());
  const CharacterDataBuffer& characterDataBuffer =
      aPoint.template ContainerAs<Text>()->DataBuffer();
  for (uint32_t i = std::min(aPoint.Offset(), characterDataBuffer.GetLength());
       i; i--) {
    WSType wsTypeOfNonCollapsibleChar;
    switch (characterDataBuffer.CharAt(i - 1)) {
      case HTMLEditUtils::kSpace:
      case HTMLEditUtils::kCarriageReturn:
      case HTMLEditUtils::kTab:
        if (isWhiteSpaceCollapsible) {
          continue;  // collapsible white-space or invisible white-space.
        }
        // preformatted white-space.
        wsTypeOfNonCollapsibleChar = WSType::NonCollapsibleCharacters;
        break;
      case HTMLEditUtils::kNewLine:
        if (isNewLineCollapsible) {
          continue;  // collapsible linefeed.
        }
        // preformatted linefeed or replaced with a non-collapsible white-space.
        wsTypeOfNonCollapsibleChar = isNewLineLineBreak
                                         ? WSType::PreformattedLineBreak
                                         : WSType::NonCollapsibleCharacters;
        break;
      case HTMLEditUtils::kNBSP:
        if (isWhiteSpaceCollapsible) {
          if (aNBSPData) {
            aNBSPData->NotifyNBSP(
                EditorDOMPointInText(aPoint.template ContainerAs<Text>(),
                                     i - 1),
                NoBreakingSpaceData::Scanning::Backward);
          }
          continue;
        }
        // NBSP is never converted from collapsible white-space/linefeed.
        wsTypeOfNonCollapsibleChar = WSType::NonCollapsibleCharacters;
        break;
      default:
        MOZ_ASSERT(!nsCRT::IsAsciiSpace(characterDataBuffer.CharAt(i - 1)));
        wsTypeOfNonCollapsibleChar = WSType::NonCollapsibleCharacters;
        break;
    }

    return Some(BoundaryData(
        EditorDOMPoint(aPoint.template ContainerAs<Text>(), i),
        *aPoint.template ContainerAs<Text>(), wsTypeOfNonCollapsibleChar));
  }

  return Nothing();
}

// static
template <typename EditorDOMPointType>
WSRunScanner::TextFragmentData::BoundaryData WSRunScanner::TextFragmentData::
    BoundaryData::ScanCollapsibleWhiteSpaceStartFrom(
        Options aOptions,  // NOLINT(performance-unnecessary-value-param)
        const EditorDOMPointType& aPoint, NoBreakingSpaceData* aNBSPData,
        const Element& aAncestorLimiter) {
  MOZ_ASSERT(aPoint.IsSetAndValid());
  MOZ_ASSERT_IF(aOptions.contains(Option::OnlyEditableNodes),
                // FIXME: Both values should be true here.
                HTMLEditUtils::IsSimplyEditableNode(*aPoint.GetContainer()) ==
                    HTMLEditUtils::IsSimplyEditableNode(aAncestorLimiter));

  if (aPoint.IsInTextNode() && !aPoint.IsStartOfContainer()) {
    Maybe<BoundaryData> startInTextNode =
        BoundaryData::ScanCollapsibleWhiteSpaceStartInTextNode(aPoint,
                                                               aNBSPData);
    if (startInTextNode.isSome()) {
      return startInTextNode.ref();
    }
    // The text node does not have visible character, let's keep scanning
    // preceding nodes.
    return BoundaryData::ScanCollapsibleWhiteSpaceStartFrom(
        aOptions, EditorDOMPoint(aPoint.template ContainerAs<Text>(), 0),
        aNBSPData, aAncestorLimiter);
  }

  const BlockInlineCheck blockInlineCheck =
      aOptions.contains(Option::ReferHTMLDefaultStyle)
          ? BlockInlineCheck::UseHTMLDefaultStyle
          : BlockInlineCheck::Auto;
  // Then, we need to check previous leaf node.
  const auto leafNodeTypes = [&]() -> LeafNodeTypes {
    auto types = aOptions.contains(Option::OnlyEditableNodes)
                     ? LeafNodeTypes{LeafNodeType::LeafNodeOrNonEditableNode}
                     : LeafNodeTypes{LeafNodeType::OnlyLeafNode};
    if (aOptions.contains(Option::StopAtComment)) {
      types += LeafNodeType::TreatCommentAsLeafNode;
    }
    return types;
  }();
  nsIContent* previousLeafContentOrBlock =
      HTMLEditUtils::GetPreviousLeafContentOrPreviousBlockElement(
          aPoint, leafNodeTypes, blockInlineCheck, &aAncestorLimiter);
  if (!previousLeafContentOrBlock) {
    // No previous content means that we reached the aAncestorLimiter boundary.
    return BoundaryData(
        aPoint, const_cast<Element&>(aAncestorLimiter),
        HTMLEditUtils::IsBlockElement(
            aAncestorLimiter, UseComputedDisplayStyleIfAuto(blockInlineCheck))
            ? WSType::CurrentBlockBoundary
            : WSType::InlineEditingHostBoundary);
  }

  if (HTMLEditUtils::IsBlockElement(
          *previousLeafContentOrBlock,
          UseComputedDisplayOutsideStyleIfAuto(blockInlineCheck))) {
    return BoundaryData(aPoint, *previousLeafContentOrBlock,
                        WSType::OtherBlockBoundary);
  }

  if (!previousLeafContentOrBlock->IsText() ||
      (aOptions.contains(Option::OnlyEditableNodes) &&
       HTMLEditUtils::IsSimplyEditableNode(*previousLeafContentOrBlock) !=
           HTMLEditUtils::IsSimplyEditableNode(aAncestorLimiter))) {
    // it's a break or a special node, like <img>, that is not a block and
    // not a break but still serves as a terminator to ws runs.
    return BoundaryData(aPoint, *previousLeafContentOrBlock,
                        previousLeafContentOrBlock->IsHTMLElement(nsGkAtoms::br)
                            ? WSType::BRElement
                            : WSType::SpecialContent);
  }

  if (!previousLeafContentOrBlock->AsText()->TextLength()) {
    // If it's an empty text node, keep looking for its previous leaf content.
    // Note that even if the empty text node is preformatted, we should keep
    // looking for the previous one.
    return BoundaryData::ScanCollapsibleWhiteSpaceStartFrom(
        aOptions, EditorDOMPointInText(previousLeafContentOrBlock->AsText(), 0),
        aNBSPData, aAncestorLimiter);
  }

  Maybe<BoundaryData> startInTextNode =
      BoundaryData::ScanCollapsibleWhiteSpaceStartInTextNode(
          EditorDOMPointInText::AtEndOf(*previousLeafContentOrBlock->AsText()),
          aNBSPData);
  if (startInTextNode.isSome()) {
    return startInTextNode.ref();
  }

  // The text node does not have visible character, let's keep scanning
  // preceding nodes.
  return BoundaryData::ScanCollapsibleWhiteSpaceStartFrom(
      aOptions, EditorDOMPointInText(previousLeafContentOrBlock->AsText(), 0),
      aNBSPData, aAncestorLimiter);
}

// static
template <typename EditorDOMPointType>
Maybe<WSRunScanner::TextFragmentData::BoundaryData> WSRunScanner::
    TextFragmentData::BoundaryData::ScanCollapsibleWhiteSpaceEndInTextNode(
        const EditorDOMPointType& aPoint, NoBreakingSpaceData* aNBSPData) {
  MOZ_ASSERT(aPoint.IsSetAndValid());
  MOZ_DIAGNOSTIC_ASSERT(aPoint.IsInTextNode());

  const bool isWhiteSpaceCollapsible = !EditorUtils::IsWhiteSpacePreformatted(
      *aPoint.template ContainerAs<Text>());
  const bool isNewLineCollapsible =
      isWhiteSpaceCollapsible &&
      !EditorUtils::IsNewLinePreformatted(*aPoint.template ContainerAs<Text>());
  const bool isNewLineLineBreak =
      EditorUtils::IsNewLinePreformatted(*aPoint.template ContainerAs<Text>());
  const CharacterDataBuffer& characterDataBuffer =
      aPoint.template ContainerAs<Text>()->DataBuffer();
  for (uint32_t i = aPoint.Offset(); i < characterDataBuffer.GetLength(); i++) {
    WSType wsTypeOfNonCollapsibleChar;
    switch (characterDataBuffer.CharAt(i)) {
      case HTMLEditUtils::kSpace:
      case HTMLEditUtils::kCarriageReturn:
      case HTMLEditUtils::kTab:
        if (isWhiteSpaceCollapsible) {
          continue;  // collapsible white-space or invisible white-space.
        }
        // preformatted white-space.
        wsTypeOfNonCollapsibleChar = WSType::NonCollapsibleCharacters;
        break;
      case HTMLEditUtils::kNewLine:
        if (isNewLineCollapsible) {
          continue;  // collapsible linefeed.
        }
        // preformatted linefeed or replaced with a non-collapsible white-space.
        wsTypeOfNonCollapsibleChar = isNewLineLineBreak
                                         ? WSType::PreformattedLineBreak
                                         : WSType::NonCollapsibleCharacters;
        break;
      case HTMLEditUtils::kNBSP:
        if (isWhiteSpaceCollapsible) {
          if (aNBSPData) {
            aNBSPData->NotifyNBSP(
                EditorDOMPointInText(aPoint.template ContainerAs<Text>(), i),
                NoBreakingSpaceData::Scanning::Forward);
          }
          continue;
        }
        // NBSP is never converted from collapsible white-space/linefeed.
        wsTypeOfNonCollapsibleChar = WSType::NonCollapsibleCharacters;
        break;
      default:
        MOZ_ASSERT(!nsCRT::IsAsciiSpace(characterDataBuffer.CharAt(i)));
        wsTypeOfNonCollapsibleChar = WSType::NonCollapsibleCharacters;
        break;
    }

    return Some(BoundaryData(
        EditorDOMPoint(aPoint.template ContainerAs<Text>(), i),
        *aPoint.template ContainerAs<Text>(), wsTypeOfNonCollapsibleChar));
  }

  return Nothing();
}

// static
template <typename EditorDOMPointType>
WSRunScanner::TextFragmentData::BoundaryData
WSRunScanner::TextFragmentData::BoundaryData::ScanCollapsibleWhiteSpaceEndFrom(
    Options aOptions,  // NOLINT(performance-unnecessary-value-param)
    const EditorDOMPointType& aPoint, NoBreakingSpaceData* aNBSPData,
    const Element& aAncestorLimiter) {
  MOZ_ASSERT(aPoint.IsSetAndValid());
  MOZ_ASSERT_IF(aOptions.contains(Option::OnlyEditableNodes),
                // FIXME: Both values should be true here.
                HTMLEditUtils::IsSimplyEditableNode(*aPoint.GetContainer()) ==
                    HTMLEditUtils::IsSimplyEditableNode(aAncestorLimiter));

  if (aPoint.IsInTextNode() && !aPoint.IsEndOfContainer()) {
    Maybe<BoundaryData> endInTextNode =
        BoundaryData::ScanCollapsibleWhiteSpaceEndInTextNode(aPoint, aNBSPData);
    if (endInTextNode.isSome()) {
      return endInTextNode.ref();
    }
    // The text node does not have visible character, let's keep scanning
    // following nodes.
    return BoundaryData::ScanCollapsibleWhiteSpaceEndFrom(
        aOptions,
        EditorDOMPointInText::AtEndOf(*aPoint.template ContainerAs<Text>()),
        aNBSPData, aAncestorLimiter);
  }

  const BlockInlineCheck blockInlineCheck =
      aOptions.contains(Option::ReferHTMLDefaultStyle)
          ? BlockInlineCheck::UseHTMLDefaultStyle
          : BlockInlineCheck::Auto;

  // Then, we need to check next leaf node.
  const auto leafNodeTypes = [&]() -> LeafNodeTypes {
    auto types = aOptions.contains(Option::OnlyEditableNodes)
                     ? LeafNodeTypes{LeafNodeType::LeafNodeOrNonEditableNode}
                     : LeafNodeTypes{LeafNodeType::OnlyLeafNode};
    if (aOptions.contains(Option::StopAtComment)) {
      types += LeafNodeType::TreatCommentAsLeafNode;
    }
    return types;
  }();
  nsIContent* nextLeafContentOrBlock =
      HTMLEditUtils::GetNextLeafContentOrNextBlockElement(
          aPoint, leafNodeTypes, blockInlineCheck, &aAncestorLimiter);
  if (!nextLeafContentOrBlock) {
    // No next content means that we reached aAncestorLimiter boundary.
    return BoundaryData(
        aPoint.template To<EditorDOMPoint>(),
        const_cast<Element&>(aAncestorLimiter),
        HTMLEditUtils::IsBlockElement(
            aAncestorLimiter, UseComputedDisplayStyleIfAuto(blockInlineCheck))
            ? WSType::CurrentBlockBoundary
            : WSType::InlineEditingHostBoundary);
  }

  if (HTMLEditUtils::IsBlockElement(
          *nextLeafContentOrBlock,
          UseComputedDisplayOutsideStyleIfAuto(blockInlineCheck))) {
    // we encountered a new block.  therefore no more ws.
    return BoundaryData(aPoint, *nextLeafContentOrBlock,
                        WSType::OtherBlockBoundary);
  }

  if (!nextLeafContentOrBlock->IsText() ||
      (aOptions.contains(Option::OnlyEditableNodes) &&
       HTMLEditUtils::IsSimplyEditableNode(*nextLeafContentOrBlock) !=
           HTMLEditUtils::IsSimplyEditableNode(aAncestorLimiter))) {
    // we encountered a break or a special node, like <img>,
    // that is not a block and not a break but still
    // serves as a terminator to ws runs.
    return BoundaryData(aPoint, *nextLeafContentOrBlock,
                        nextLeafContentOrBlock->IsHTMLElement(nsGkAtoms::br)
                            ? WSType::BRElement
                            : WSType::SpecialContent);
  }

  if (!nextLeafContentOrBlock->AsText()->DataBuffer().GetLength()) {
    // If it's an empty text node, keep looking for its next leaf content.
    // Note that even if the empty text node is preformatted, we should keep
    // looking for the next one.
    return BoundaryData::ScanCollapsibleWhiteSpaceEndFrom(
        aOptions, EditorDOMPointInText(nextLeafContentOrBlock->AsText(), 0),
        aNBSPData, aAncestorLimiter);
  }

  Maybe<BoundaryData> endInTextNode =
      BoundaryData::ScanCollapsibleWhiteSpaceEndInTextNode(
          EditorDOMPointInText(nextLeafContentOrBlock->AsText(), 0), aNBSPData);
  if (endInTextNode.isSome()) {
    return endInTextNode.ref();
  }

  // The text node does not have visible character, let's keep scanning
  // following nodes.
  return BoundaryData::ScanCollapsibleWhiteSpaceEndFrom(
      aOptions,
      EditorDOMPointInText::AtEndOf(*nextLeafContentOrBlock->AsText()),
      aNBSPData, aAncestorLimiter);
}

const EditorDOMRange&
WSRunScanner::TextFragmentData::InvisibleLeadingWhiteSpaceRangeRef() const {
  if (mLeadingWhiteSpaceRange.isSome()) {
    return mLeadingWhiteSpaceRange.ref();
  }

  // If it's start of line, there is no invisible leading white-spaces.
  if (!StartsFromHardLineBreak() && !StartsFromInlineEditingHostBoundary()) {
    mLeadingWhiteSpaceRange.emplace();
    return mLeadingWhiteSpaceRange.ref();
  }

  // If there is no NBSP, all of the given range is leading white-spaces.
  // Note that this result may be collapsed if there is no leading white-spaces.
  if (!mNBSPData.FoundNBSP()) {
    MOZ_ASSERT(mStart.PointRef().IsSet() || mEnd.PointRef().IsSet());
    mLeadingWhiteSpaceRange.emplace(mStart.PointRef(), mEnd.PointRef());
    return mLeadingWhiteSpaceRange.ref();
  }

  MOZ_ASSERT(mNBSPData.LastPointRef().IsSetAndValid());

  // Even if the first NBSP is the start, i.e., there is no invisible leading
  // white-space, return collapsed range.
  mLeadingWhiteSpaceRange.emplace(mStart.PointRef(), mNBSPData.FirstPointRef());
  return mLeadingWhiteSpaceRange.ref();
}

const EditorDOMRange&
WSRunScanner::TextFragmentData::InvisibleTrailingWhiteSpaceRangeRef() const {
  if (mTrailingWhiteSpaceRange.isSome()) {
    return mTrailingWhiteSpaceRange.ref();
  }

  // If it's not immediately before a block boundary, there is no invisible
  // trailing white-spaces.  Note that a collapsible white-space before a <br>
  // element or a preformatted linefeed is visible.
  if (!EndsByBlockBoundary() && !EndsByInlineEditingHostBoundary()) {
    mTrailingWhiteSpaceRange.emplace();
    return mTrailingWhiteSpaceRange.ref();
  }

  // If there is no NBSP, all of the given range is trailing white-spaces.
  // Note that this result may be collapsed if there is no trailing white-
  // spaces.
  if (!mNBSPData.FoundNBSP()) {
    MOZ_ASSERT(mStart.PointRef().IsSet() || mEnd.PointRef().IsSet());
    mTrailingWhiteSpaceRange.emplace(mStart.PointRef(), mEnd.PointRef());
    return mTrailingWhiteSpaceRange.ref();
  }

  MOZ_ASSERT(mNBSPData.LastPointRef().IsSetAndValid());

  // If last NBSP is immediately before the end, there is no trailing white-
  // spaces.
  if (mEnd.PointRef().IsSet() &&
      mNBSPData.LastPointRef().GetContainer() ==
          mEnd.PointRef().GetContainer() &&
      mNBSPData.LastPointRef().Offset() == mEnd.PointRef().Offset() - 1) {
    mTrailingWhiteSpaceRange.emplace();
    return mTrailingWhiteSpaceRange.ref();
  }

  // Otherwise, the may be some trailing white-spaces.
  MOZ_ASSERT(!mNBSPData.LastPointRef().IsEndOfContainer());
  mTrailingWhiteSpaceRange.emplace(mNBSPData.LastPointRef().NextPoint(),
                                   mEnd.PointRef());
  return mTrailingWhiteSpaceRange.ref();
}

EditorDOMRangeInTexts
WSRunScanner::TextFragmentData::GetNonCollapsedRangeInTexts(
    const EditorDOMRange& aRange) const {
  if (!aRange.IsPositioned()) {
    return EditorDOMRangeInTexts();
  }
  if (aRange.Collapsed()) {
    // If collapsed, we can do nothing.
    return EditorDOMRangeInTexts();
  }
  if (aRange.IsInTextNodes()) {
    // Note that this may return a range which don't include any invisible
    // white-spaces due to empty text nodes.
    return aRange.GetAsInTexts();
  }

  const auto firstPoint =
      aRange.StartRef().IsInTextNode()
          ? aRange.StartRef().AsInText()
          : GetInclusiveNextCharPoint<EditorDOMPointInText>(
                aRange.StartRef(),
                ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  if (!firstPoint.IsSet()) {
    return EditorDOMRangeInTexts();
  }
  EditorDOMPointInText endPoint;
  if (aRange.EndRef().IsInTextNode()) {
    endPoint = aRange.EndRef().AsInText();
  } else {
    // FYI: GetPreviousCharPoint() returns last character's point of preceding
    //      text node if it's not empty, but we need end of the text node here.
    endPoint = GetPreviousCharPoint<EditorDOMPointInText>(
        aRange.EndRef(),
        ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
    if (endPoint.IsSet() && endPoint.IsAtLastContent()) {
      MOZ_ALWAYS_TRUE(endPoint.AdvanceOffset());
    }
  }
  if (!endPoint.IsSet() || firstPoint == endPoint) {
    return EditorDOMRangeInTexts();
  }
  return EditorDOMRangeInTexts(firstPoint, endPoint);
}

const WSRunScanner::VisibleWhiteSpacesData&
WSRunScanner::TextFragmentData::VisibleWhiteSpacesDataRef() const {
  if (mVisibleWhiteSpacesData.isSome()) {
    return mVisibleWhiteSpacesData.ref();
  }

  {
    // If all things are obviously visible, we can return range for all of the
    // things quickly.
    const bool mayHaveInvisibleLeadingSpace =
        !StartsFromNonCollapsibleCharacters() && !StartsFromSpecialContent();
    const bool mayHaveInvisibleTrailingWhiteSpace =
        !EndsByNonCollapsibleCharacters() && !EndsBySpecialContent() &&
        !EndsByBRElement() && !EndsByInvisiblePreformattedLineBreak();

    if (!mayHaveInvisibleLeadingSpace && !mayHaveInvisibleTrailingWhiteSpace) {
      VisibleWhiteSpacesData visibleWhiteSpaces;
      if (mStart.PointRef().IsSet()) {
        visibleWhiteSpaces.SetStartPoint(mStart.PointRef());
      }
      visibleWhiteSpaces.SetStartFrom(mStart.RawReason());
      if (mEnd.PointRef().IsSet()) {
        visibleWhiteSpaces.SetEndPoint(mEnd.PointRef());
      }
      visibleWhiteSpaces.SetEndBy(mEnd.RawReason());
      mVisibleWhiteSpacesData.emplace(visibleWhiteSpaces);
      return mVisibleWhiteSpacesData.ref();
    }
  }

  // If all of the range is invisible leading or trailing white-spaces,
  // there is no visible content.
  const EditorDOMRange& leadingWhiteSpaceRange =
      InvisibleLeadingWhiteSpaceRangeRef();
  const bool maybeHaveLeadingWhiteSpaces =
      leadingWhiteSpaceRange.StartRef().IsSet() ||
      leadingWhiteSpaceRange.EndRef().IsSet();
  if (maybeHaveLeadingWhiteSpaces &&
      leadingWhiteSpaceRange.StartRef() == mStart.PointRef() &&
      leadingWhiteSpaceRange.EndRef() == mEnd.PointRef()) {
    mVisibleWhiteSpacesData.emplace(VisibleWhiteSpacesData());
    return mVisibleWhiteSpacesData.ref();
  }
  const EditorDOMRange& trailingWhiteSpaceRange =
      InvisibleTrailingWhiteSpaceRangeRef();
  const bool maybeHaveTrailingWhiteSpaces =
      trailingWhiteSpaceRange.StartRef().IsSet() ||
      trailingWhiteSpaceRange.EndRef().IsSet();
  if (maybeHaveTrailingWhiteSpaces &&
      trailingWhiteSpaceRange.StartRef() == mStart.PointRef() &&
      trailingWhiteSpaceRange.EndRef() == mEnd.PointRef()) {
    mVisibleWhiteSpacesData.emplace(VisibleWhiteSpacesData());
    return mVisibleWhiteSpacesData.ref();
  }

  if (!StartsFromHardLineBreak() && !StartsFromInlineEditingHostBoundary()) {
    VisibleWhiteSpacesData visibleWhiteSpaces;
    if (mStart.PointRef().IsSet()) {
      visibleWhiteSpaces.SetStartPoint(mStart.PointRef());
    }
    visibleWhiteSpaces.SetStartFrom(mStart.RawReason());
    if (!maybeHaveTrailingWhiteSpaces) {
      visibleWhiteSpaces.SetEndPoint(mEnd.PointRef());
      visibleWhiteSpaces.SetEndBy(mEnd.RawReason());
      mVisibleWhiteSpacesData = Some(visibleWhiteSpaces);
      return mVisibleWhiteSpacesData.ref();
    }
    if (trailingWhiteSpaceRange.StartRef().IsSet()) {
      visibleWhiteSpaces.SetEndPoint(trailingWhiteSpaceRange.StartRef());
    }
    visibleWhiteSpaces.SetEndByTrailingWhiteSpaces();
    mVisibleWhiteSpacesData.emplace(visibleWhiteSpaces);
    return mVisibleWhiteSpacesData.ref();
  }

  MOZ_ASSERT(StartsFromHardLineBreak() ||
             StartsFromInlineEditingHostBoundary());
  MOZ_ASSERT(maybeHaveLeadingWhiteSpaces);

  VisibleWhiteSpacesData visibleWhiteSpaces;
  if (leadingWhiteSpaceRange.EndRef().IsSet()) {
    visibleWhiteSpaces.SetStartPoint(leadingWhiteSpaceRange.EndRef());
  }
  visibleWhiteSpaces.SetStartFromLeadingWhiteSpaces();
  if (!EndsByBlockBoundary() && !EndsByInlineEditingHostBoundary()) {
    // then no trailing ws.  this normal run ends the overall ws run.
    if (mEnd.PointRef().IsSet()) {
      visibleWhiteSpaces.SetEndPoint(mEnd.PointRef());
    }
    visibleWhiteSpaces.SetEndBy(mEnd.RawReason());
    mVisibleWhiteSpacesData.emplace(visibleWhiteSpaces);
    return mVisibleWhiteSpacesData.ref();
  }

  MOZ_ASSERT(EndsByBlockBoundary() || EndsByInlineEditingHostBoundary());

  if (!maybeHaveTrailingWhiteSpaces) {
    // normal ws runs right up to adjacent block (nbsp next to block)
    visibleWhiteSpaces.SetEndPoint(mEnd.PointRef());
    visibleWhiteSpaces.SetEndBy(mEnd.RawReason());
    mVisibleWhiteSpacesData.emplace(visibleWhiteSpaces);
    return mVisibleWhiteSpacesData.ref();
  }

  if (trailingWhiteSpaceRange.StartRef().IsSet()) {
    visibleWhiteSpaces.SetEndPoint(trailingWhiteSpaceRange.StartRef());
  }
  visibleWhiteSpaces.SetEndByTrailingWhiteSpaces();
  mVisibleWhiteSpacesData.emplace(visibleWhiteSpaces);
  return mVisibleWhiteSpacesData.ref();
}

ReplaceRangeData
WSRunScanner::TextFragmentData::GetReplaceRangeDataAtEndOfDeletionRange(
    const TextFragmentData& aTextFragmentDataAtStartToDelete) const {
  const EditorDOMPoint& startToDelete =
      aTextFragmentDataAtStartToDelete.ScanStartRef();
  const EditorDOMPoint& endToDelete = mScanStartPoint;

  MOZ_ASSERT(startToDelete.IsSetAndValid());
  MOZ_ASSERT(endToDelete.IsSetAndValid());
  MOZ_ASSERT(startToDelete.EqualsOrIsBefore(endToDelete));

  if (EndRef().EqualsOrIsBefore(endToDelete)) {
    return ReplaceRangeData();
  }

  // If deleting range is followed by invisible trailing white-spaces, we need
  // to remove it for making them not visible.
  const EditorDOMRange invisibleTrailingWhiteSpaceRangeAtEnd =
      GetNewInvisibleTrailingWhiteSpaceRangeIfSplittingAt(endToDelete);
  if (invisibleTrailingWhiteSpaceRangeAtEnd.IsPositioned()) {
    if (invisibleTrailingWhiteSpaceRangeAtEnd.Collapsed()) {
      return ReplaceRangeData();
    }
    // XXX Why don't we remove all invisible white-spaces?
    MOZ_ASSERT(invisibleTrailingWhiteSpaceRangeAtEnd.StartRef() == endToDelete);
    return ReplaceRangeData(invisibleTrailingWhiteSpaceRangeAtEnd, u""_ns);
  }

  // If end of the deleting range is followed by visible white-spaces which
  // is not preformatted, we might need to replace the following ASCII
  // white-spaces with an NBSP.
  const VisibleWhiteSpacesData& nonPreformattedVisibleWhiteSpacesAtEnd =
      VisibleWhiteSpacesDataRef();
  if (!nonPreformattedVisibleWhiteSpacesAtEnd.IsInitialized()) {
    return ReplaceRangeData();
  }
  const PointPosition pointPositionWithNonPreformattedVisibleWhiteSpacesAtEnd =
      nonPreformattedVisibleWhiteSpacesAtEnd.ComparePoint(endToDelete);
  if (pointPositionWithNonPreformattedVisibleWhiteSpacesAtEnd !=
          PointPosition::StartOfFragment &&
      pointPositionWithNonPreformattedVisibleWhiteSpacesAtEnd !=
          PointPosition::MiddleOfFragment) {
    return ReplaceRangeData();
  }
  // If start of deleting range follows white-spaces or end of delete
  // will be start of a line, the following text cannot start with an
  // ASCII white-space for keeping it visible.
  if (!aTextFragmentDataAtStartToDelete
           .FollowingContentMayBecomeFirstVisibleContent(startToDelete)) {
    return ReplaceRangeData();
  }
  auto nextCharOfStartOfEnd = GetInclusiveNextCharPoint<EditorDOMPointInText>(
      endToDelete, ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  if (!nextCharOfStartOfEnd.IsSet() ||
      nextCharOfStartOfEnd.IsEndOfContainer() ||
      !nextCharOfStartOfEnd.IsCharCollapsibleASCIISpace()) {
    return ReplaceRangeData();
  }
  if (nextCharOfStartOfEnd.IsStartOfContainer() ||
      nextCharOfStartOfEnd.IsPreviousCharCollapsibleASCIISpace()) {
    nextCharOfStartOfEnd =
        aTextFragmentDataAtStartToDelete
            .GetFirstASCIIWhiteSpacePointCollapsedTo<EditorDOMPointInText>(
                nextCharOfStartOfEnd, nsIEditor::eNone,
                ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  }
  const auto endOfCollapsibleASCIIWhiteSpaces =
      aTextFragmentDataAtStartToDelete
          .GetEndOfCollapsibleASCIIWhiteSpaces<EditorDOMPointInText>(
              nextCharOfStartOfEnd, nsIEditor::eNone,
              ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  return ReplaceRangeData(nextCharOfStartOfEnd,
                          endOfCollapsibleASCIIWhiteSpaces,
                          nsDependentSubstring(&HTMLEditUtils::kNBSP, 1));
}

ReplaceRangeData
WSRunScanner::TextFragmentData::GetReplaceRangeDataAtStartOfDeletionRange(
    const TextFragmentData& aTextFragmentDataAtEndToDelete) const {
  const EditorDOMPoint& startToDelete = mScanStartPoint;
  const EditorDOMPoint& endToDelete =
      aTextFragmentDataAtEndToDelete.ScanStartRef();

  MOZ_ASSERT(startToDelete.IsSetAndValid());
  MOZ_ASSERT(endToDelete.IsSetAndValid());
  MOZ_ASSERT(startToDelete.EqualsOrIsBefore(endToDelete));

  if (startToDelete.EqualsOrIsBefore(StartRef())) {
    return ReplaceRangeData();
  }

  const EditorDOMRange invisibleLeadingWhiteSpaceRangeAtStart =
      GetNewInvisibleLeadingWhiteSpaceRangeIfSplittingAt(startToDelete);

  // If deleting range follows invisible leading white-spaces, we need to
  // remove them for making them not visible.
  if (invisibleLeadingWhiteSpaceRangeAtStart.IsPositioned()) {
    if (invisibleLeadingWhiteSpaceRangeAtStart.Collapsed()) {
      return ReplaceRangeData();
    }

    // XXX Why don't we remove all leading white-spaces?
    return ReplaceRangeData(invisibleLeadingWhiteSpaceRangeAtStart, u""_ns);
  }

  // If start of the deleting range follows visible white-spaces which is not
  // preformatted, we might need to replace previous ASCII white-spaces with
  // an NBSP.
  const VisibleWhiteSpacesData& nonPreformattedVisibleWhiteSpacesAtStart =
      VisibleWhiteSpacesDataRef();
  if (!nonPreformattedVisibleWhiteSpacesAtStart.IsInitialized()) {
    return ReplaceRangeData();
  }
  const PointPosition
      pointPositionWithNonPreformattedVisibleWhiteSpacesAtStart =
          nonPreformattedVisibleWhiteSpacesAtStart.ComparePoint(startToDelete);
  if (pointPositionWithNonPreformattedVisibleWhiteSpacesAtStart !=
          PointPosition::MiddleOfFragment &&
      pointPositionWithNonPreformattedVisibleWhiteSpacesAtStart !=
          PointPosition::EndOfFragment) {
    return ReplaceRangeData();
  }
  // If end of the deleting range is (was) followed by white-spaces or
  // previous character of start of deleting range will be immediately
  // before a block boundary, the text cannot ends with an ASCII white-space
  // for keeping it visible.
  if (!aTextFragmentDataAtEndToDelete.PrecedingContentMayBecomeInvisible(
          endToDelete)) {
    return ReplaceRangeData();
  }
  auto atPreviousCharOfStart = GetPreviousCharPoint<EditorDOMPointInText>(
      startToDelete, ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  if (!atPreviousCharOfStart.IsSet() ||
      atPreviousCharOfStart.IsEndOfContainer() ||
      !atPreviousCharOfStart.IsCharCollapsibleASCIISpace()) {
    return ReplaceRangeData();
  }
  if (atPreviousCharOfStart.IsStartOfContainer() ||
      atPreviousCharOfStart.IsPreviousCharASCIISpace()) {
    atPreviousCharOfStart =
        GetFirstASCIIWhiteSpacePointCollapsedTo<EditorDOMPointInText>(
            atPreviousCharOfStart, nsIEditor::eNone,
            ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  }
  const auto endOfCollapsibleASCIIWhiteSpaces =
      GetEndOfCollapsibleASCIIWhiteSpaces<EditorDOMPointInText>(
          atPreviousCharOfStart, nsIEditor::eNone,
          ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  return ReplaceRangeData(atPreviousCharOfStart,
                          endOfCollapsibleASCIIWhiteSpaces,
                          nsDependentSubstring(&HTMLEditUtils::kNBSP, 1));
}

// static
template <typename EditorDOMPointType, typename PT, typename CT>
EditorDOMPointType WSRunScanner::TextFragmentData::GetInclusiveNextCharPoint(
    const EditorDOMPointBase<PT, CT>& aPoint,
    Options aOptions,  // NOLINT(performance-unnecessary-value-param)
    IgnoreNonEditableNodes aIgnoreNonEditableNodes,
    const nsIContent* aFollowingLimiterContent /* = nullptr */) {
  MOZ_ASSERT(aPoint.IsSetAndValid());

  if (NS_WARN_IF(!aPoint.IsInContentNode())) {
    return EditorDOMPointType();
  }

  const BlockInlineCheck blockInlineCheck =
      aOptions.contains(Option::ReferHTMLDefaultStyle)
          ? BlockInlineCheck::UseHTMLDefaultStyle
          : BlockInlineCheck::Auto;
  const EditorRawDOMPoint point = [&]() MOZ_NEVER_INLINE_DEBUG {
    nsIContent* const child = [&]() -> nsIContent* {
      nsIContent* child =
          aPoint.CanContainerHaveChildren() ? aPoint.GetChild() : nullptr;
      // XXX Why don't we skip non-editable nodes here?
      while (child && child->IsComment() &&
             !aOptions.contains(Option::StopAtComment)) {
        child = child->GetNextSibling();
      }
      return child;
    }();
    if (!child ||
        HTMLEditUtils::IsBlockElement(
            *child, UseComputedDisplayOutsideStyleIfAuto(blockInlineCheck)) ||
        HTMLEditUtils::IsVisibleElementEvenIfLeafNode(*child)) {
      return aPoint.template To<EditorRawDOMPoint>();
    }
    if (!child->HasChildNodes()) {
      return child->IsText() || HTMLEditUtils::IsContainerNode(*child)
                 ? EditorRawDOMPoint(child, 0)
                 : EditorRawDOMPoint::After(*child);
    }
    // FIXME: This may skip aFollowingLimiterContent, so, this utility should
    // take a stopper param.
    // FIXME: I think we should stop looking for a leaf node if there is a child
    // block because end reason content should not be the other side of the
    // following block boundary.
    nsIContent* const leafContent = HTMLEditUtils::GetFirstLeafContent(
        *child, {LeafNodeType::LeafNodeOrChildBlock}, blockInlineCheck);
    if (!leafContent) {
      return EditorRawDOMPoint(child, 0);
    }
    if (HTMLEditUtils::IsBlockElement(
            *leafContent,
            UseComputedDisplayOutsideStyleIfAuto(blockInlineCheck)) ||
        HTMLEditUtils::IsVisibleElementEvenIfLeafNode(*leafContent)) {
      return EditorRawDOMPoint();
    }
    return EditorRawDOMPoint(leafContent, 0);
  }();
  if (!point.IsSet()) {
    return EditorDOMPointType();
  }

  // If it points a character in a text node, return it.
  // XXX For the performance, this does not check whether the container
  //     is outside of our range.
  if (point.IsInTextNode() &&
      (aIgnoreNonEditableNodes == IgnoreNonEditableNodes::No ||
       HTMLEditUtils::IsSimplyEditableNode(*point.GetContainer())) &&
      !point.IsEndOfContainer()) {
    return EditorDOMPointType(point.ContainerAs<Text>(), point.Offset());
  }

  if (point.GetContainer() == aFollowingLimiterContent) {
    return EditorDOMPointType();
  }

  const Element* const
      editableBlockElementOrInlineEditingHostOrNonEditableRootElement =
          HTMLEditUtils::GetInclusiveAncestorElement(
              *aPoint.template ContainerAs<nsIContent>(),
              HTMLEditUtils::IsSimplyEditableNode(
                  *aPoint.template ContainerAs<nsIContent>())
                  ? kScanEditableRootAncestorTypes
                  : kScanAnyRootAncestorTypes,
              blockInlineCheck);
  if (NS_WARN_IF(
          !editableBlockElementOrInlineEditingHostOrNonEditableRootElement)) {
    return EditorDOMPointType();
  }

  const auto leafNodeTypes = [&]() -> LeafNodeTypes {
    auto types = aIgnoreNonEditableNodes == IgnoreNonEditableNodes::Yes
                     ? LeafNodeTypes(LeafNodeType::LeafNodeOrNonEditableNode,
                                     LeafNodeType::LeafNodeOrChildBlock)
                     : LeafNodeTypes(LeafNodeType::LeafNodeOrChildBlock);
    if (aOptions.contains(Option::StopAtComment)) {
      types += LeafNodeType::TreatCommentAsLeafNode;
    }
    return types;
  }();
  for (nsIContent* nextContent =
           HTMLEditUtils::GetNextLeafContentOrNextBlockElement(
               *point.ContainerAs<nsIContent>(), leafNodeTypes,
               blockInlineCheck,
               editableBlockElementOrInlineEditingHostOrNonEditableRootElement);
       nextContent;
       nextContent = HTMLEditUtils::GetNextLeafContentOrNextBlockElement(
           *nextContent, leafNodeTypes, blockInlineCheck,
           editableBlockElementOrInlineEditingHostOrNonEditableRootElement)) {
    if (!nextContent->IsText() ||
        (aIgnoreNonEditableNodes == IgnoreNonEditableNodes::Yes &&
         !HTMLEditUtils::IsSimplyEditableNode(*nextContent))) {
      if (nextContent == aFollowingLimiterContent ||
          HTMLEditUtils::IsBlockElement(
              *nextContent,
              UseComputedDisplayOutsideStyleIfAuto(blockInlineCheck)) ||
          HTMLEditUtils::IsVisibleElementEvenIfLeafNode(*nextContent)) {
        break;  // Reached end of current runs.
      }
      continue;
    }
    return EditorDOMPointType(nextContent->AsText(), 0);
  }
  return EditorDOMPointType();
}

// static
template <typename EditorDOMPointType, typename PT, typename CT>
EditorDOMPointType WSRunScanner::TextFragmentData::GetPreviousCharPoint(
    const EditorDOMPointBase<PT, CT>& aPoint,
    Options aOptions,  // NOLINT(performance-unnecessary-value-param)
    IgnoreNonEditableNodes aIgnoreNonEditableNodes,
    const nsIContent* aPrecedingLimiterContent /* = nullptr */) {
  MOZ_ASSERT(aPoint.IsSetAndValid());

  if (NS_WARN_IF(!aPoint.IsInContentNode())) {
    return EditorDOMPointType();
  }

  const BlockInlineCheck blockInlineCheck =
      aOptions.contains(Option::ReferHTMLDefaultStyle)
          ? BlockInlineCheck::UseHTMLDefaultStyle
          : BlockInlineCheck::Auto;
  const EditorRawDOMPoint point = [&]() MOZ_NEVER_INLINE_DEBUG {
    nsIContent* const previousChild = [&]() -> nsIContent* {
      nsIContent* previousChild = aPoint.CanContainerHaveChildren()
                                      ? aPoint.GetPreviousSiblingOfChild()
                                      : nullptr;
      // XXX Why don't we skip non-editable nodes here?
      while (previousChild && previousChild->IsComment() &&
             !aOptions.contains(Option::StopAtComment)) {
        previousChild = previousChild->GetPreviousSibling();
      }
      return previousChild;
    }();
    if (!previousChild ||
        HTMLEditUtils::IsBlockElement(
            *previousChild,
            UseComputedDisplayOutsideStyleIfAuto(blockInlineCheck)) ||
        HTMLEditUtils::IsVisibleElementEvenIfLeafNode(*previousChild)) {
      return aPoint.template To<EditorRawDOMPoint>();
    }
    if (!previousChild->HasChildren()) {
      return previousChild->IsText() ||
                     HTMLEditUtils::IsContainerNode(*previousChild)
                 ? EditorRawDOMPoint::AtEndOf(*previousChild)
                 : EditorRawDOMPoint::After(*previousChild);
    }
    // FIXME: This may skip aPrecedingLimiterContent, so, this utility should
    // take a stopper param.
    // FIXME: I think we should stop looking for a leaf node if there is a child
    // block because end reason content should not be the other side of the
    // following block boundary.
    nsIContent* const leafContent = HTMLEditUtils::GetLastLeafContent(
        *previousChild, {LeafNodeType::LeafNodeOrChildBlock}, blockInlineCheck);
    if (!leafContent) {
      return EditorRawDOMPoint::AtEndOf(*previousChild);
    }
    if (HTMLEditUtils::IsBlockElement(
            *leafContent,
            UseComputedDisplayOutsideStyleIfAuto(blockInlineCheck)) ||
        HTMLEditUtils::IsVisibleElementEvenIfLeafNode(*leafContent)) {
      return EditorRawDOMPoint();
    }
    return EditorRawDOMPoint::AtEndOf(*leafContent);
  }();
  if (!point.IsSet()) {
    return EditorDOMPointType();
  }

  // If it points a character in a text node and it's not first character
  // in it, return its previous point.
  // XXX For the performance, this does not check whether the container
  //     is outside of our range.
  if (point.IsInTextNode() &&
      (aIgnoreNonEditableNodes == IgnoreNonEditableNodes::No ||
       HTMLEditUtils::IsSimplyEditableNode(*point.GetContainer())) &&
      !point.IsStartOfContainer()) {
    return EditorDOMPointType(point.ContainerAs<Text>(), point.Offset() - 1);
  }

  if (point.GetContainer() == aPrecedingLimiterContent) {
    return EditorDOMPointType();
  }

  const Element* const
      editableBlockElementOrInlineEditingHostOrNonEditableRootElement =
          HTMLEditUtils::GetInclusiveAncestorElement(
              *aPoint.template ContainerAs<nsIContent>(),
              HTMLEditUtils::IsSimplyEditableNode(
                  *aPoint.template ContainerAs<nsIContent>())
                  ? kScanEditableRootAncestorTypes
                  : kScanAnyRootAncestorTypes,
              blockInlineCheck);
  if (NS_WARN_IF(
          !editableBlockElementOrInlineEditingHostOrNonEditableRootElement)) {
    return EditorDOMPointType();
  }

  const auto leafNodeTypes = [&]() -> LeafNodeTypes {
    auto types = aIgnoreNonEditableNodes == IgnoreNonEditableNodes::Yes
                     ? LeafNodeTypes(LeafNodeType::LeafNodeOrNonEditableNode,
                                     LeafNodeType::LeafNodeOrChildBlock)
                     : LeafNodeTypes(LeafNodeType::LeafNodeOrChildBlock);
    if (aOptions.contains(Option::StopAtComment)) {
      types += LeafNodeType::TreatCommentAsLeafNode;
    }
    return types;
  }();
  for (
      nsIContent* previousContent =
          HTMLEditUtils::GetPreviousLeafContentOrPreviousBlockElement(
              *point.ContainerAs<nsIContent>(), leafNodeTypes, blockInlineCheck,
              editableBlockElementOrInlineEditingHostOrNonEditableRootElement);
      previousContent;
      previousContent =
          HTMLEditUtils::GetPreviousLeafContentOrPreviousBlockElement(
              *previousContent, leafNodeTypes, blockInlineCheck,
              editableBlockElementOrInlineEditingHostOrNonEditableRootElement)) {
    if (!previousContent->IsText() ||
        (aIgnoreNonEditableNodes == IgnoreNonEditableNodes::Yes &&
         !HTMLEditUtils::IsSimplyEditableNode(*previousContent))) {
      if (previousContent == aPrecedingLimiterContent ||
          HTMLEditUtils::IsBlockElement(
              *previousContent,
              UseComputedDisplayOutsideStyleIfAuto(blockInlineCheck)) ||
          HTMLEditUtils::IsVisibleElementEvenIfLeafNode(*previousContent)) {
        break;  // Reached start of current runs.
      }
      continue;
    }
    return EditorDOMPointType(previousContent->AsText(),
                              previousContent->AsText()->TextLength()
                                  ? previousContent->AsText()->TextLength() - 1
                                  : 0);
  }
  return EditorDOMPointType();
}

// static
template <typename EditorDOMPointType>
EditorDOMPointType
WSRunScanner::TextFragmentData::GetEndOfCollapsibleASCIIWhiteSpaces(
    const EditorDOMPointInText& aPointAtASCIIWhiteSpace,
    nsIEditor::EDirection aDirectionToDelete,
    Options aOptions,  // NOLINT(performance-unnecessary-value-param)
    IgnoreNonEditableNodes aIgnoreNonEditableNodes,
    const nsIContent* aFollowingLimiterContent /* = nullptr */) {
  MOZ_ASSERT(aDirectionToDelete == nsIEditor::eNone ||
             aDirectionToDelete == nsIEditor::eNext ||
             aDirectionToDelete == nsIEditor::ePrevious);
  MOZ_ASSERT(aPointAtASCIIWhiteSpace.IsSet());
  MOZ_ASSERT(!aPointAtASCIIWhiteSpace.IsEndOfContainer());
  MOZ_ASSERT_IF(!EditorUtils::IsNewLinePreformatted(
                    *aPointAtASCIIWhiteSpace.ContainerAs<Text>()),
                aPointAtASCIIWhiteSpace.IsCharCollapsibleASCIISpace());
  MOZ_ASSERT_IF(EditorUtils::IsNewLinePreformatted(
                    *aPointAtASCIIWhiteSpace.ContainerAs<Text>()),
                aPointAtASCIIWhiteSpace.IsCharASCIISpace());

  // If we're deleting text forward and the next visible character is first
  // preformatted new line but white-spaces can be collapsed, we need to
  // delete its following collapsible white-spaces too.
  bool hasSeenPreformattedNewLine =
      aPointAtASCIIWhiteSpace.IsCharPreformattedNewLine();
  auto NeedToScanFollowingWhiteSpaces =
      [&hasSeenPreformattedNewLine,
       &aDirectionToDelete](const EditorDOMPointInText& aAtNextVisibleCharacter)
          MOZ_NEVER_INLINE_DEBUG -> bool {
    MOZ_ASSERT(!aAtNextVisibleCharacter.IsEndOfContainer());
    return !hasSeenPreformattedNewLine &&
           aDirectionToDelete == nsIEditor::eNext &&
           aAtNextVisibleCharacter
               .IsCharPreformattedNewLineCollapsedWithWhiteSpaces();
  };
  auto ScanNextNonCollapsibleChar =
      [&hasSeenPreformattedNewLine,
       &NeedToScanFollowingWhiteSpaces](const EditorDOMPointInText& aPoint)
          MOZ_NEVER_INLINE_DEBUG -> EditorDOMPointInText {
    Maybe<uint32_t> nextVisibleCharOffset =
        HTMLEditUtils::GetNextNonCollapsibleCharOffset(aPoint);
    if (!nextVisibleCharOffset.isSome()) {
      return EditorDOMPointInText();  // Keep scanning following text nodes
    }
    EditorDOMPointInText atNextVisibleChar(aPoint.ContainerAs<Text>(),
                                           nextVisibleCharOffset.value());
    if (!NeedToScanFollowingWhiteSpaces(atNextVisibleChar)) {
      return atNextVisibleChar;
    }
    hasSeenPreformattedNewLine |= atNextVisibleChar.IsCharPreformattedNewLine();
    nextVisibleCharOffset =
        HTMLEditUtils::GetNextNonCollapsibleCharOffset(atNextVisibleChar);
    if (nextVisibleCharOffset.isSome()) {
      MOZ_ASSERT(aPoint.ContainerAs<Text>() ==
                 atNextVisibleChar.ContainerAs<Text>());
      return EditorDOMPointInText(atNextVisibleChar.ContainerAs<Text>(),
                                  nextVisibleCharOffset.value());
    }
    return EditorDOMPointInText();  // Keep scanning following text nodes
  };

  // If it's not the last character in the text node, let's scan following
  // characters in it.
  if (!aPointAtASCIIWhiteSpace.IsAtLastContent()) {
    const EditorDOMPointInText atNextVisibleChar(
        ScanNextNonCollapsibleChar(aPointAtASCIIWhiteSpace));
    if (atNextVisibleChar.IsSet()) {
      return atNextVisibleChar.To<EditorDOMPointType>();
    }
  }

  // Otherwise, i.e., the text node ends with ASCII white-space, keep scanning
  // the following text nodes.
  // XXX Perhaps, we should stop scanning if there is non-editable and visible
  //     content.
  EditorDOMPointInText afterLastWhiteSpace = EditorDOMPointInText::AtEndOf(
      *aPointAtASCIIWhiteSpace.ContainerAs<Text>());
  for (EditorDOMPointInText atEndOfPreviousTextNode = afterLastWhiteSpace;;) {
    const auto atStartOfNextTextNode =
        TextFragmentData::GetInclusiveNextCharPoint<EditorDOMPointInText>(
            atEndOfPreviousTextNode, aOptions, aIgnoreNonEditableNodes,
            aFollowingLimiterContent);
    if (!atStartOfNextTextNode.IsSet()) {
      // There is no more text nodes.  Return end of the previous text node.
      return afterLastWhiteSpace.To<EditorDOMPointType>();
    }

    // We can ignore empty text nodes (even if it's preformatted).
    if (atStartOfNextTextNode.IsContainerEmpty()) {
      atEndOfPreviousTextNode = atStartOfNextTextNode;
      continue;
    }

    // If next node starts with non-white-space character or next node is
    // preformatted, return end of previous text node.  However, if it
    // starts with a preformatted linefeed but white-spaces are collapsible,
    // we need to scan following collapsible white-spaces when we're deleting
    // text forward.
    if (!atStartOfNextTextNode.IsCharCollapsibleASCIISpace() &&
        !NeedToScanFollowingWhiteSpaces(atStartOfNextTextNode)) {
      return afterLastWhiteSpace.To<EditorDOMPointType>();
    }

    // Otherwise, scan the text node.
    const EditorDOMPointInText atNextVisibleChar(
        ScanNextNonCollapsibleChar(atStartOfNextTextNode));
    if (atNextVisibleChar.IsSet()) {
      return atNextVisibleChar.To<EditorDOMPointType>();
    }

    // The next text nodes ends with white-space too.  Try next one.
    afterLastWhiteSpace = atEndOfPreviousTextNode =
        EditorDOMPointInText::AtEndOf(
            *atStartOfNextTextNode.ContainerAs<Text>());
  }
}

// static
template <typename EditorDOMPointType>
EditorDOMPointType
WSRunScanner::TextFragmentData::GetFirstASCIIWhiteSpacePointCollapsedTo(
    const EditorDOMPointInText& aPointAtASCIIWhiteSpace,
    nsIEditor::EDirection aDirectionToDelete,
    Options aOptions,  // NOLINT(performance-unnecessary-value-param)
    IgnoreNonEditableNodes aIgnoreNonEditableNodes,
    const nsIContent* aPrecedingLimiterContent) {
  MOZ_ASSERT(aDirectionToDelete == nsIEditor::eNone ||
             aDirectionToDelete == nsIEditor::eNext ||
             aDirectionToDelete == nsIEditor::ePrevious);
  MOZ_ASSERT(aPointAtASCIIWhiteSpace.IsSet());
  MOZ_ASSERT(!aPointAtASCIIWhiteSpace.IsEndOfContainer());
  MOZ_ASSERT_IF(!EditorUtils::IsNewLinePreformatted(
                    *aPointAtASCIIWhiteSpace.ContainerAs<Text>()),
                aPointAtASCIIWhiteSpace.IsCharCollapsibleASCIISpace());
  MOZ_ASSERT_IF(EditorUtils::IsNewLinePreformatted(
                    *aPointAtASCIIWhiteSpace.ContainerAs<Text>()),
                aPointAtASCIIWhiteSpace.IsCharASCIISpace());

  // If we're deleting text backward and the previous visible character is first
  // preformatted new line but white-spaces can be collapsed, we need to delete
  // its preceding collapsible white-spaces too.
  bool hasSeenPreformattedNewLine =
      aPointAtASCIIWhiteSpace.IsCharPreformattedNewLine();
  auto NeedToScanPrecedingWhiteSpaces =
      [&hasSeenPreformattedNewLine, &aDirectionToDelete](
          const EditorDOMPointInText& aAtPreviousVisibleCharacter)
          MOZ_NEVER_INLINE_DEBUG -> bool {
    MOZ_ASSERT(!aAtPreviousVisibleCharacter.IsEndOfContainer());
    return !hasSeenPreformattedNewLine &&
           aDirectionToDelete == nsIEditor::ePrevious &&
           aAtPreviousVisibleCharacter
               .IsCharPreformattedNewLineCollapsedWithWhiteSpaces();
  };
  auto ScanPreviousNonCollapsibleChar =
      [&hasSeenPreformattedNewLine,
       &NeedToScanPrecedingWhiteSpaces](const EditorDOMPointInText& aPoint)
          MOZ_NEVER_INLINE_DEBUG -> EditorDOMPointInText {
    Maybe<uint32_t> previousVisibleCharOffset =
        HTMLEditUtils::GetPreviousNonCollapsibleCharOffset(aPoint);
    if (previousVisibleCharOffset.isNothing()) {
      return EditorDOMPointInText();  // Keep scanning preceding text nodes
    }
    EditorDOMPointInText atPreviousVisibleCharacter(
        aPoint.ContainerAs<Text>(), previousVisibleCharOffset.value());
    if (!NeedToScanPrecedingWhiteSpaces(atPreviousVisibleCharacter)) {
      return atPreviousVisibleCharacter.NextPoint();
    }
    hasSeenPreformattedNewLine |=
        atPreviousVisibleCharacter.IsCharPreformattedNewLine();
    previousVisibleCharOffset =
        HTMLEditUtils::GetPreviousNonCollapsibleCharOffset(
            atPreviousVisibleCharacter);
    if (previousVisibleCharOffset.isSome()) {
      MOZ_ASSERT(aPoint.ContainerAs<Text>() ==
                 atPreviousVisibleCharacter.ContainerAs<Text>());
      return EditorDOMPointInText(
          atPreviousVisibleCharacter.ContainerAs<Text>(),
          previousVisibleCharOffset.value() + 1);
    }
    return EditorDOMPointInText();  // Keep scanning preceding text nodes
  };

  // If there is some characters before it, scan it in the text node first.
  if (!aPointAtASCIIWhiteSpace.IsStartOfContainer()) {
    EditorDOMPointInText atFirstASCIIWhiteSpace(
        ScanPreviousNonCollapsibleChar(aPointAtASCIIWhiteSpace));
    if (atFirstASCIIWhiteSpace.IsSet()) {
      return atFirstASCIIWhiteSpace.To<EditorDOMPointType>();
    }
  }

  // Otherwise, i.e., the text node starts with ASCII white-space, keep scanning
  // the preceding text nodes.
  // XXX Perhaps, we should stop scanning if there is non-editable and visible
  //     content.
  EditorDOMPointInText atLastWhiteSpace =
      EditorDOMPointInText(aPointAtASCIIWhiteSpace.ContainerAs<Text>(), 0u);
  for (EditorDOMPointInText atStartOfPreviousTextNode = atLastWhiteSpace;;) {
    const auto atLastCharOfPreviousTextNode =
        TextFragmentData::GetPreviousCharPoint<EditorDOMPointInText>(
            atStartOfPreviousTextNode, aOptions, aIgnoreNonEditableNodes,
            aPrecedingLimiterContent);
    if (!atLastCharOfPreviousTextNode.IsSet()) {
      // There is no more text nodes.  Return end of last text node.
      return atLastWhiteSpace.To<EditorDOMPointType>();
    }

    // We can ignore empty text nodes (even if it's preformatted).
    if (atLastCharOfPreviousTextNode.IsContainerEmpty()) {
      atStartOfPreviousTextNode = atLastCharOfPreviousTextNode;
      continue;
    }

    // If next node ends with non-white-space character or next node is
    // preformatted, return start of previous text node.
    if (!atLastCharOfPreviousTextNode.IsCharCollapsibleASCIISpace() &&
        !NeedToScanPrecedingWhiteSpaces(atLastCharOfPreviousTextNode)) {
      return atLastWhiteSpace.To<EditorDOMPointType>();
    }

    // Otherwise, scan the text node.
    const EditorDOMPointInText atFirstASCIIWhiteSpace(
        ScanPreviousNonCollapsibleChar(atLastCharOfPreviousTextNode));
    if (atFirstASCIIWhiteSpace.IsSet()) {
      return atFirstASCIIWhiteSpace.To<EditorDOMPointType>();
    }

    // The next text nodes starts with white-space too.  Try next one.
    atLastWhiteSpace = atStartOfPreviousTextNode = EditorDOMPointInText(
        atLastCharOfPreviousTextNode.ContainerAs<Text>(), 0u);
  }
}

EditorDOMPointInText WSRunScanner::TextFragmentData::
    GetPreviousNBSPPointIfNeedToReplaceWithASCIIWhiteSpace(
        const EditorDOMPoint& aPointToInsert) const {
  MOZ_ASSERT(aPointToInsert.IsSetAndValid());
  MOZ_ASSERT(VisibleWhiteSpacesDataRef().IsInitialized());
  NS_ASSERTION(VisibleWhiteSpacesDataRef().ComparePoint(aPointToInsert) ==
                       PointPosition::MiddleOfFragment ||
                   VisibleWhiteSpacesDataRef().ComparePoint(aPointToInsert) ==
                       PointPosition::EndOfFragment,
               "Previous char of aPoint should be in the visible white-spaces");

  // Try to change an NBSP to a space, if possible, just to prevent NBSP
  // proliferation.  This routine is called when we are about to make this
  // point in the ws abut an inserted break or text, so we don't have to worry
  // about what is after it.  What is after it now will end up after the
  // inserted object.
  const auto atPreviousChar = GetPreviousCharPoint<EditorDOMPointInText>(
      aPointToInsert, ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  if (!atPreviousChar.IsSet() || atPreviousChar.IsEndOfContainer() ||
      !atPreviousChar.IsCharNBSP() ||
      EditorUtils::IsWhiteSpacePreformatted(
          *atPreviousChar.ContainerAs<Text>())) {
    return EditorDOMPointInText();
  }

  const auto atPreviousCharOfPreviousChar =
      GetPreviousCharPoint<EditorDOMPointInText>(
          atPreviousChar,
          ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  if (atPreviousCharOfPreviousChar.IsSet()) {
    // If the previous char is in different text node and it's preformatted,
    // we shouldn't touch it.
    if (atPreviousChar.ContainerAs<Text>() !=
            atPreviousCharOfPreviousChar.ContainerAs<Text>() &&
        EditorUtils::IsWhiteSpacePreformatted(
            *atPreviousCharOfPreviousChar.ContainerAs<Text>())) {
      return EditorDOMPointInText();
    }
    // If the previous char of the NBSP at previous position of aPointToInsert
    // is an ASCII white-space, we don't need to replace it with same character.
    if (!atPreviousCharOfPreviousChar.IsEndOfContainer() &&
        atPreviousCharOfPreviousChar.IsCharASCIISpace()) {
      return EditorDOMPointInText();
    }
    return atPreviousChar;
  }

  // If previous content of the NBSP is block boundary, we cannot replace the
  // NBSP with an ASCII white-space to keep it rendered.
  const VisibleWhiteSpacesData& visibleWhiteSpaces =
      VisibleWhiteSpacesDataRef();
  if (!visibleWhiteSpaces.StartsFromNonCollapsibleCharacters() &&
      !visibleWhiteSpaces.StartsFromSpecialContent()) {
    return EditorDOMPointInText();
  }
  return atPreviousChar;
}

EditorDOMPointInText WSRunScanner::TextFragmentData::
    GetInclusiveNextNBSPPointIfNeedToReplaceWithASCIIWhiteSpace(
        const EditorDOMPoint& aPointToInsert) const {
  MOZ_ASSERT(aPointToInsert.IsSetAndValid());
  MOZ_ASSERT(VisibleWhiteSpacesDataRef().IsInitialized());
  NS_ASSERTION(VisibleWhiteSpacesDataRef().ComparePoint(aPointToInsert) ==
                       PointPosition::StartOfFragment ||
                   VisibleWhiteSpacesDataRef().ComparePoint(aPointToInsert) ==
                       PointPosition::MiddleOfFragment,
               "Inclusive next char of aPointToInsert should be in the visible "
               "white-spaces");

  // Try to change an nbsp to a space, if possible, just to prevent nbsp
  // proliferation This routine is called when we are about to make this point
  // in the ws abut an inserted text, so we don't have to worry about what is
  // before it.  What is before it now will end up before the inserted text.
  const auto atNextChar = GetInclusiveNextCharPoint<EditorDOMPointInText>(
      aPointToInsert, ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  if (!atNextChar.IsSet() || NS_WARN_IF(atNextChar.IsEndOfContainer()) ||
      !atNextChar.IsCharNBSP() ||
      EditorUtils::IsWhiteSpacePreformatted(*atNextChar.ContainerAs<Text>())) {
    return EditorDOMPointInText();
  }

  const auto atNextCharOfNextCharOfNBSP =
      GetInclusiveNextCharPoint<EditorDOMPointInText>(
          atNextChar.NextPoint<EditorRawDOMPointInText>(),
          ShouldIgnoreNonEditableSiblingsOrDescendants(mOptions));
  if (atNextCharOfNextCharOfNBSP.IsSet()) {
    // If the next char is in different text node and it's preformatted,
    // we shouldn't touch it.
    if (atNextChar.ContainerAs<Text>() !=
            atNextCharOfNextCharOfNBSP.ContainerAs<Text>() &&
        EditorUtils::IsWhiteSpacePreformatted(
            *atNextCharOfNextCharOfNBSP.ContainerAs<Text>())) {
      return EditorDOMPointInText();
    }
    // If following character of an NBSP is an ASCII white-space, we don't
    // need to replace it with same character.
    if (!atNextCharOfNextCharOfNBSP.IsEndOfContainer() &&
        atNextCharOfNextCharOfNBSP.IsCharASCIISpace()) {
      return EditorDOMPointInText();
    }
    return atNextChar;
  }

  // If the NBSP is last character in the hard line, we don't need to
  // replace it because it's required to render multiple white-spaces.
  const VisibleWhiteSpacesData& visibleWhiteSpaces =
      VisibleWhiteSpacesDataRef();
  if (!visibleWhiteSpaces.EndsByNonCollapsibleCharacters() &&
      !visibleWhiteSpaces.EndsBySpecialContent() &&
      !visibleWhiteSpaces.EndsByBRElement()) {
    return EditorDOMPointInText();
  }

  return atNextChar;
}

}  // namespace mozilla