/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef nsFrameSelection_h_
#define nsFrameSelection_h_

#include <fmt/format.h>
#include <stdint.h>

#include "WordMovementType.h"
#include "mozilla/Assertions.h"
#include "mozilla/Attributes.h"
#include "mozilla/CaretAssociationHint.h"
#include "mozilla/CompactPair.h"
#include "mozilla/EnumSet.h"
#include "mozilla/EventForwards.h"
#include "mozilla/Result.h"
#include "mozilla/TextRange.h"
#include "mozilla/UniquePtr.h"
#include "mozilla/dom/Element.h"
#include "mozilla/dom/Highlight.h"
#include "mozilla/dom/Selection.h"
#include "mozilla/intl/BidiEmbeddingLevel.h"
#include "nsBidiPresUtils.h"
#include "nsIContent.h"
#include "nsIFrame.h"
#include "nsISelectionController.h"
#include "nsISelectionListener.h"
#include "nsITableCellLayout.h"

class nsRange;

#define BIDI_LEVEL_UNDEFINED mozilla::intl::BidiEmbeddingLevel(0x80)

//----------------------------------------------------------------------

// Selection interface

struct SelectionDetails {
  SelectionDetails()
      : mStart(), mEnd(), mSelectionType(mozilla::SelectionType::eInvalid) {
    MOZ_COUNT_CTOR(SelectionDetails);
  }
  ~SelectionDetails() {
    MOZ_COUNT_DTOR(SelectionDetails);
    // Destroy the linked list without recursion.
    auto next = std::move(mNext);
    while (next) {
      next = std::move(next->mNext);
    }
  }

  int32_t mStart;
  int32_t mEnd;
  mozilla::SelectionType mSelectionType;
  mozilla::dom::HighlightSelectionData mHighlightData;
  mozilla::TextRangeStyle mTextRangeStyle;
  mozilla::UniquePtr<SelectionDetails> mNext;
};

struct SelectionCustomColors {
#ifdef NS_BUILD_REFCNT_LOGGING
  MOZ_COUNTED_DEFAULT_CTOR(SelectionCustomColors)
  MOZ_COUNTED_DTOR(SelectionCustomColors)
#endif
  mozilla::Maybe<nscolor> mForegroundColor;
  mozilla::Maybe<nscolor> mBackgroundColor;
  mozilla::Maybe<nscolor> mAltForegroundColor;
  mozilla::Maybe<nscolor> mAltBackgroundColor;
};

namespace mozilla {
class PresShell;

/** PeekOffsetStruct is used to group various arguments (both input and output)
 *  that are passed to nsIFrame::PeekOffset(). See below for the description of
 *  individual arguments.
 */
enum class PeekOffsetOption : uint16_t {
  // Whether to allow jumping across line boundaries.
  //
  // Used with: eSelectCharacter, eSelectWord.
  JumpLines,

  // Whether we should preserve or trim spaces at begin/end of content
  PreserveSpaces,

  // Whether to stop when reaching a scroll view boundary.
  //
  // Used with: eSelectCharacter, eSelectWord, eSelectLine.
  StopAtScroller,

  // Whether to stop when reaching a placeholder frame.
  StopAtPlaceholder,

  // Whether the peeking is done in response to a keyboard action.
  //
  // Used with: eSelectWord.
  IsKeyboardSelect,

  // Whether bidi caret behavior is visual (set) or logical (unset).
  //
  // Used with: eSelectCharacter, eSelectWord, eSelectBeginLine, eSelectEndLine.
  Visual,

  // Whether the selection is being extended or moved.
  Extend,

  // If true, the offset has to end up in an editable node, otherwise we'll keep
  // searching.
  ForceEditableRegion,

  // Whether the peeking is done for a caret move rather than a selection.
  //
  // Currently this only affects eSelectParagraph: when paragraph movement
  // reaches a block boundary without finding a "stop frame", the result is
  // resolved to the leaf frame at that edge (typically a text frame) rather
  // than to the block container element. This gives a caret a precise text
  // position so that scrolling-into-view works for horizontally overflowing
  // content (bug 2041228). Selection (e.g. triple-click paragraph selection)
  // intentionally does not set this, because it expects the block container
  // itself as the boundary.
  //
  // Set for all caret moves; currently only takes effect with eSelectParagraph.
  ForCaretMove,
};

using PeekOffsetOptions = EnumSet<PeekOffsetOption>;

struct MOZ_STACK_CLASS PeekOffsetStruct {
  PeekOffsetStruct(nsSelectionAmount aAmount, nsDirection aDirection,
                   int32_t aStartOffset, nsPoint aDesiredCaretPos,
                   // Passing by value here is intentional because EnumSet
                   // is optimized as uint*_t in opt builds.
                   const PeekOffsetOptions aOptions,
                   EWordMovementType aWordMovementType = eDefaultBehavior,
                   const dom::Element* aAncestorLimiter = nullptr);

  /**
   * Return true if the ancestor limiter is not specified or if the content for
   * aFrame is an inclusive descendant of mAncestorLimiter.
   */
  [[nodiscard]] bool FrameContentIsInAncestorLimiter(
      const nsIFrame* aFrame) const {
    return !mAncestorLimiter ||
           (aFrame->GetContent() &&
            aFrame->GetContent()->IsInclusiveDescendantOf(mAncestorLimiter));
  }

  // Note: Most arguments (input and output) are only used with certain values
  // of mAmount. These values are indicated for each argument below.
  // Arguments with no such indication are used with all values of mAmount.

  /*** Input arguments ***/
  // Note: The value of some of the input arguments may be changed upon exit.

  // The type of movement requested (by character, word, line, etc.)
  nsSelectionAmount mAmount;

  // eDirPrevious or eDirNext.
  //
  // Note for visual bidi movement:
  //   * eDirPrevious means 'left-then-up' if the containing block is LTR,
  //     'right-then-up' if it is RTL.
  //   * eDirNext means 'right-then-down' if the containing block is LTR,
  //     'left-then-down' if it is RTL.
  //   * Between paragraphs, eDirPrevious means "go to the visual end of
  //     the previous paragraph", and eDirNext means "go to the visual
  //     beginning of the next paragraph".
  //
  // Used with: eSelectCharacter, eSelectWord, eSelectLine, eSelectParagraph.
  const nsDirection mDirection;

  // Offset into the content of the current frame where the peek starts.
  //
  // Used with: eSelectCharacter, eSelectWord
  int32_t mStartOffset;

  // The desired inline coordinate for the caret (one of .x or .y will be used,
  // depending on line's writing mode)
  //
  // Used with: eSelectLine.
  const nsPoint mDesiredCaretPos;

  // An enum that determines whether to prefer the start or end of a word or to
  // use the default behavior, which is a combination of direction and the
  // platform-based pref "layout.word_select.eat_space_to_next_word"
  EWordMovementType mWordMovementType;

  PeekOffsetOptions mOptions;

  // The ancestor limiter element to peek offset.
  const dom::Element* const mAncestorLimiter;

  /*** Output arguments ***/

  // Content reached as a result of the peek.
  nsCOMPtr<nsIContent> mResultContent;

  // Frame reached as a result of the peek.
  //
  // Used with: eSelectCharacter, eSelectWord.
  nsIFrame* mResultFrame;

  // Offset into content reached as a result of the peek.
  int32_t mContentOffset;

  // When the result position is between two frames, indicates which of the two
  // frames the caret should be painted in. false means "the end of the frame
  // logically before the caret", true means "the beginning of the frame
  // logically after the caret".
  //
  // Used with: eSelectLine, eSelectBeginLine, eSelectEndLine.
  CaretAssociationHint mAttach;
};

struct LimitersAndCaretData;

}  // namespace mozilla

struct nsPrevNextBidiLevels {
  void SetData(nsIFrame* aFrameBefore, nsIFrame* aFrameAfter,
               mozilla::intl::BidiEmbeddingLevel aLevelBefore,
               mozilla::intl::BidiEmbeddingLevel aLevelAfter) {
    mFrameBefore = aFrameBefore;
    mFrameAfter = aFrameAfter;
    mLevelBefore = aLevelBefore;
    mLevelAfter = aLevelAfter;
  }
  nsIFrame* mFrameBefore;
  nsIFrame* mFrameAfter;
  mozilla::intl::BidiEmbeddingLevel mLevelBefore;
  mozilla::intl::BidiEmbeddingLevel mLevelAfter;
};

namespace mozilla {
class SelectionChangeEventDispatcher;
namespace dom {
class Highlight;
class Selection;
enum class ClickSelectionType { NotApplicable, Double, Triple };
}  // namespace dom

/**
 * Constants for places that want to handle table selections.  These
 * indicate what part of a table is being selected.
 */
enum class TableSelectionMode : uint32_t {
  None,     /* Nothing being selected; not valid in all cases. */
  Cell,     /* A cell is being selected. */
  Row,      /* A row is being selected. */
  Column,   /* A column is being selected. */
  Table,    /* A table (including cells and captions) is being selected. */
  AllCells, /* All the cells in a table are being selected. */
};

struct SelectionLimiters {
  /**
   * Return true if aContainerNode is in the limiters if one of them is set.
   *
   * Note that this returns true when aContainerNode may be in the scope of
   * an independent selection.  Therefore, even if this returns `true`,
   * aContainerNode may not be valid container node for a selection managed
   * by this owner.
   */
  [[nodiscard]] bool NodeIsInLimiters(const nsINode* aContainerNode) const;

  /**
   * Return true if aRange is completely in the limiters if one of them is set.
   *
   * Note that this returns true when aContainerNode may be in the scope of
   * an independent selection.  Therefore, even if this returns `true`,
   * aRange may not be a valid range for a selection managed by this owner.
   */
  [[nodiscard]] bool RangeInLimiters(const dom::AbstractRange& aRange) const {
    return NodeIsInLimiters(aRange.GetStartContainer()) &&
           (aRange.GetStartContainer() == aRange.GetEndContainer() ||
            NodeIsInLimiters(aRange.GetEndContainer()));
  }

  [[nodiscard]] bool HasLimiters() const {
    return mIndependentSelectionRootElement || mAncestorLimiter;
  }

  friend inline std::string format_as(const SelectionLimiters& aLimiters) {
    return fmt::format(
        "{{ mIndependentSelectionRootElement={}, mAncestorLimiter={} }}",
        ToString(aLimiters.mIndependentSelectionRootElement),
        ToString(aLimiters.mAncestorLimiter));
  }

  friend inline std::ostream& operator<<(std::ostream& aStream,
                                         const SelectionLimiters& aLimiters) {
    return aStream << format_as(aLimiters);
  }

  // The independent selection root element if and only if the
  // nsFrameSelection instance is for an independent selection.
  RefPtr<dom::Element> mIndependentSelectionRootElement;
  // Limit selection navigation to a descendant of this element.
  // This is typically the focused editing host if set unless it's the root
  // element of the document.
  RefPtr<dom::Element> mAncestorLimiter;
};

}  // namespace mozilla

class nsFrameSelection final {
 public:
  friend std::ostream& operator<<(std::ostream&, const nsFrameSelection&);

  using AllowRangeCrossShadowBoundary =
      mozilla::dom::AllowRangeCrossShadowBoundary;
  using CaretAssociationHint = mozilla::CaretAssociationHint;
  using Element = mozilla::dom::Element;

  /*interfaces for addref and release and queryinterface*/

  NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(nsFrameSelection)
  NS_DECL_CYCLE_COLLECTION_NATIVE_CLASS(nsFrameSelection)

  enum class FocusMode {
    kExtendSelection,     /** Keep old anchor point. */
    kCollapseToNewPoint,  /** Collapses the Selection to the new point. */
    kMultiRangeSelection, /** Keeps existing non-collapsed ranges and marks them
                             as generated. */
  };

  /**
   * HandleClick will take the focus to the new frame at the new offset and
   * will either extend the selection from the old anchor, or replace the old
   * anchor. the old anchor and focus position may also be used to deselect
   * things
   *
   * @param aNewfocus is the content that wants the focus
   *
   * @param aContentOffset is the content offset of the parent aNewFocus
   *
   * @param aContentOffsetEnd is the content offset of the parent aNewFocus and
   * is specified different when you need to select to and include both start
   * and end points
   *
   * @param aHint will tell the selection which direction geometrically to
   * actually show the caret on. 1 = end of this line 0 = beginning of this line
   */
  MOZ_CAN_RUN_SCRIPT nsresult HandleClick(nsIContent* aNewFocus,
                                          uint32_t aContentOffset,
                                          uint32_t aContentEndOffset,
                                          FocusMode aFocusMode,
                                          CaretAssociationHint aHint);

  [[nodiscard]] bool IsAvailable() const {
    // mDomSelections is initialized at construction and cleared if the cycle
    // collector unlink them so that if the first selection is available, the
    // others should be fine.
    return !!mDomSelections[0];
  }

  /**
   * Sets the type of the selection based on whether a selection is created
   * by doubleclick, long tapping a word or tripleclick.
   *
   * @param aClickSelectionType   ClickSelectionType::Double if the selection
   *                              is created by doubleclick,
   *                              ClickSelectionType::Triple if the selection
   *                              is created by tripleclick.
   */
  void SetClickSelectionType(
      mozilla::dom::ClickSelectionType aClickSelectionType) {
    mClickSelectionType = aClickSelectionType;
  }

  /**
   * Return true if this is an instance for an independent selection.
   * Currently, independent selection is created only in the text controls
   * to manage selections in their native anonymous subtree.
   */
  [[nodiscard]] bool IsIndependentSelection() const {
    return !!GetIndependentSelectionRootElement();
  }

  /**
   * Returns true if the selection was created by doubleclick or
   * long tap over a word.
   */
  [[nodiscard]] bool IsDoubleClickSelection() const {
    return mClickSelectionType == mozilla::dom::ClickSelectionType::Double;
  }

  /**
   * Returns true if the selection was created by triple click
   */
  [[nodiscard]] bool IsTripleClickSelection() const {
    return mClickSelectionType == mozilla::dom::ClickSelectionType::Triple;
  }

  /**
   * HandleDrag extends the selection to contain the frame closest to aPoint.
   *
   * @param aPresContext is the context to use when figuring out what frame
   * contains the point.
   *
   * @param aFrame is the parent of all frames to use when searching for the
   * closest frame to the point.
   *
   * @param aPoint is relative to aFrame
   */
  MOZ_CAN_RUN_SCRIPT void HandleDrag(nsIFrame* aFrame, const nsPoint& aPoint);

  /**
   * HandleTableSelection will set selection to a table, cell, etc
   * depending on information contained in aFlags
   *
   * @param aParentContent is the paretent of either a table or cell that user
   * clicked or dragged the mouse in
   *
   * @param aContentOffset is the offset of the table or cell
   *
   * @param aTarget indicates what to select
   *   * TableSelectionMode::Cell
   *       We should select a cell (content points to the cell)
   *   * TableSelectionMode::Row
   *       We should select a row (content points to any cell in row)
   *   * TableSelectionMode::Column
   *       We should select a row (content points to any cell in column)
   *   * TableSelectionMode::Table
   *       We should select a table (content points to the table)
   *   * TableSelectionMode::AllCells
   *       We should select all cells (content points to any cell in table)
   *
   * @param aMouseEvent passed in so we can get where event occurred
   * and what keys are pressed
   */
  [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
  HandleTableSelection(nsINode* aParentContent, int32_t aContentOffset,
                       mozilla::TableSelectionMode aTarget,
                       mozilla::WidgetMouseEvent* aMouseEvent);

  /**
   * Add cell to the selection with `SelectionType::eNormal`.
   *
   * @param  aCell  [in] HTML td element.
   */
  nsresult SelectCellElement(nsIContent* aCell);

  /**
   * Remove cells from selection inside of the given cell range.
   *
   * @param  aTable             [in] HTML table element
   * @param  aStartRowIndex     [in] row index where the cells range starts
   * @param  aStartColumnIndex  [in] column index where the cells range starts
   * @param  aEndRowIndex       [in] row index where the cells range ends
   * @param  aEndColumnIndex    [in] column index where the cells range ends
   */
  MOZ_CAN_RUN_SCRIPT nsresult RemoveCellsFromSelection(
      nsIContent* aTable, int32_t aStartRowIndex, int32_t aStartColumnIndex,
      int32_t aEndRowIndex, int32_t aEndColumnIndex);

  /**
   * Remove cells from selection outside of the given cell range.
   *
   * @param  aTable             [in] HTML table element
   * @param  aStartRowIndex     [in] row index where the cells range starts
   * @param  aStartColumnIndex  [in] column index where the cells range starts
   * @param  aEndRowIndex       [in] row index where the cells range ends
   * @param  aEndColumnIndex    [in] column index where the cells range ends
   */
  MOZ_CAN_RUN_SCRIPT nsresult RestrictCellsToSelection(
      nsIContent* aTable, int32_t aStartRowIndex, int32_t aStartColumnIndex,
      int32_t aEndRowIndex, int32_t aEndColumnIndex);

  /**
   * StartAutoScrollTimer is responsible for scrolling frames so that
   * aPoint is always visible, and for selecting any frame that contains
   * aPoint. The timer will also reset itself to fire again if we have
   * not scrolled to the end of the document.
   *
   * @param aFrame is the outermost frame to use when searching for
   * the closest frame for the point, i.e. the frame that is capturing
   * the mouse
   *
   * @param aPoint is relative to aFrame.
   *
   * @param aDelay is the timer's interval.
   */
  MOZ_CAN_RUN_SCRIPT nsresult StartAutoScrollTimer(nsIFrame* aFrame,
                                                   const nsPoint& aPoint,
                                                   uint32_t aDelay);

  /**
   * Stops any active auto scroll timer.
   */
  void StopAutoScrollTimer();

  /**
   * Returns in frame coordinates the selection beginning and ending with the
   * type of selection given
   *
   * @param aContent is the content asking
   * @param aContentOffset is the starting content boundary
   * @param aContentLength is the length of the content piece asking
   * @param aIgnoreSelection is Yes, this won't return selection details about
   * the normal selection.
   */
  enum class IgnoreNormalSelection : bool { No, Yes };
  mozilla::UniquePtr<SelectionDetails> LookUpSelection(
      nsIContent* aContent, int32_t aContentOffset, int32_t aContentLength,
      IgnoreNormalSelection aIgnoreNormalSelection) const;

  /**
   * Sets the drag state to aState for resons of drag state.
   * Note that only can run script when called with false as an argument.
   *
   * @param aState is the new state of drag
   */
  MOZ_CAN_RUN_SCRIPT void SetDragState(bool aState);

  /**
   * Marks us as dragging. Equivalent to SetDragState(true), but without the
   * CAN_RUN_SCRIPT implications.
   */
  void RestoreDragState() { mDragState = true; }
  [[nodiscard]] bool GetDragState() const { return mDragState; }

  /**
   * If we are in table cell selection mode. aka ctrl click in table cell
   */
  [[nodiscard]] bool IsInTableSelectionMode() const {
    return mTableSelection.mMode != mozilla::TableSelectionMode::None;
  }
  void ClearTableCellSelection() {
    mTableSelection.mMode = mozilla::TableSelectionMode::None;
  }

  /**
   * No query interface for selection. must use this method now.
   *
   * @param aSelectionType The selection type what you want.
   */
  [[nodiscard]] mozilla::dom::Selection* GetSelection(
      mozilla::SelectionType aSelectionType) const;

  /**
   * Convenience method to access the `eNormal` Selection.
   */
  [[nodiscard]] mozilla::dom::Selection& NormalSelection() const {
    return *GetSelection(mozilla::SelectionType::eNormal);
  }

  /**
   * Returns the number of highlight selections.
   */
  [[nodiscard]] size_t HighlightSelectionCount() const {
    return mHighlightSelections.Length();
  }

  /**
   * Get a highlight selection by index. The index must be valid.
   */
  [[nodiscard]] RefPtr<mozilla::dom::Selection> HighlightSelection(
      size_t aIndex) const {
    return mHighlightSelections[aIndex].second();
  }

  /**
   * @brief Adds a highlight selection for `aHighlight`.
   */
  MOZ_CAN_RUN_SCRIPT void AddHighlightSelection(
      nsAtom* aHighlightName, mozilla::dom::Highlight& aHighlight);

  void RepaintHighlightSelection(nsAtom* aHighlightName);

  /**
   * @brief Removes the Highlight selection identified by `aHighlightName`.
   */
  MOZ_CAN_RUN_SCRIPT void RemoveHighlightSelection(nsAtom* aHighlightName);

  /**
   * @brief Adds a new range to the highlight selection.
   *
   * If there is no highlight selection for the given highlight yet, it is
   * created using |AddHighlightSelection|.
   */
  MOZ_CAN_RUN_SCRIPT void AddHighlightSelectionRange(
      nsAtom* aHighlightName, mozilla::dom::Highlight& aHighlight,
      mozilla::dom::AbstractRange& aRange);

  /**
   * @brief Removes a range from a highlight selection.
   */
  MOZ_CAN_RUN_SCRIPT void RemoveHighlightSelectionRange(
      nsAtom* aHighlightName, mozilla::dom::AbstractRange& aRange);
  /**
   * ScrollSelectionIntoView scrolls a region of the selection,
   * so that it is visible in the scrolled view.
   *
   * @param aSelectionType the selection to scroll into view.
   *
   * @param aRegion the region inside the selection to scroll into view.
   *
   * @param aFlags the scroll flags.  Valid bits include:
   *   * SCROLL_SYNCHRONOUS: when set, scrolls the selection into view
   *     before returning. If not set, posts a request which is processed
   *     at some point after the method returns.
   *   * SCROLL_FIRST_ANCESTOR_ONLY: if set, only the first ancestor will be
   *     scrolled into view.
   */
  MOZ_CAN_RUN_SCRIPT nsresult
  ScrollSelectionIntoView(mozilla::SelectionType aSelectionType,
                          SelectionRegion aRegion, int16_t aFlags) const;

  /**
   * RepaintSelection repaints the selected frames that are inside the
   * selection specified by aSelectionType.
   *
   * @param aSelectionType The selection type what you want to repaint.
   */
  nsresult RepaintSelection(mozilla::SelectionType aSelectionType);

  /**
   * Return true if aContainerNode is in the selection limiter or the ancestor
   * limiter if one of them is set.
   *
   * Note that this returns true when aContainerNode may be in the scope of
   * an independent selection.  Therefore, even if this returns `true`,
   * aContainerNode may not be valid container node for a selection managed
   * by this instance.
   */
  [[nodiscard]] bool NodeIsInLimiters(const nsINode* aContainerNode) const {
    return mLimiters.NodeIsInLimiters(aContainerNode);
  }

  /**
   * Return true if the both start and end containers of aRange are in the
   * limiters.
   *
   * Note that this returns true when aRange may be in the scope of an
   * independent selection.  Therefore, even if this returns `true`,
   * aRange may not be valid editable range in the UA shadow of the text
   * control element.
   */
  [[nodiscard]] bool RangeInLimiters(
      const mozilla::dom::AbstractRange& aRange) const {
    return mLimiters.RangeInLimiters(aRange);
  }

  /**
   * GetFrameToPageSelect() returns a frame which is ancestor limit of
   * per-page selection.  The frame may not be scrollable.  E.g.,
   * when selection ancestor limit is set to a frame of an editing host of
   * contenteditable element and it's not scrollable.
   */
  [[nodiscard]] nsIFrame* GetFrameToPageSelect() const;

  /**
   * This method moves caret (if aExtend is false) or expands selection (if
   * aExtend is true).  Then, scrolls aFrame one page.  Finally, this may
   * call ScrollSelectionIntoView() for making focus of selection visible
   * but depending on aSelectionIntoView value.
   *
   * @param aForward if true, scroll forward if not scroll backward
   * @param aExtend  if true, extend selection to the new point
   * @param aFrame   the frame to scroll or container of per-page selection.
   *                 if aExtend is true and selection may have ancestor limit,
   *                 should set result of GetFrameToPageSelect().
   * @param aSelectionIntoView
   *                 If IfChanged, this makes selection into view only when
   *                 selection is modified by the call.
   *                 If Yes, this makes selection into view always.
   */
  enum class SelectionIntoView { IfChanged, Yes };
  MOZ_CAN_RUN_SCRIPT nsresult PageMove(bool aForward, bool aExtend,
                                       nsIFrame* aFrame,
                                       SelectionIntoView aSelectionIntoView);

  void SetHint(CaretAssociationHint aHintRight) { mCaret.mHint = aHintRight; }
  [[nodiscard]] CaretAssociationHint GetHint() const { return mCaret.mHint; }

  void SetCaretBidiLevelAndMaybeSchedulePaint(
      mozilla::intl::BidiEmbeddingLevel aLevel);

  /**
   * GetCaretBidiLevel gets the caret bidi level.
   */
  [[nodiscard]] mozilla::intl::BidiEmbeddingLevel GetCaretBidiLevel() const;

  /**
   * UndefineCaretBidiLevel sets the caret bidi level to "undefined".
   */
  void UndefineCaretBidiLevel();

  /**
   * PhysicalMove will generally be called from the nsiselectioncontroller
   * implementations. the effect being the selection will move one unit
   * 'aAmount' in the given aDirection.
   * @param aDirection  the direction to move the selection
   * @param aAmount     amount of movement (char/line; word/page; eol/doc)
   * @param aExtend     continue selection
   */
  MOZ_CAN_RUN_SCRIPT nsresult PhysicalMove(int16_t aDirection, int16_t aAmount,
                                           bool aExtend);

  /**
   * CharacterMove will generally be called from the nsiselectioncontroller
   * implementations. the effect being the selection will move one character
   * left or right.
   * @param aForward move forward in document.
   * @param aExtend continue selection
   */
  MOZ_CAN_RUN_SCRIPT nsresult CharacterMove(bool aForward, bool aExtend);

  /**
   * WordMove will generally be called from the nsiselectioncontroller
   * implementations. the effect being the selection will move one word left or
   * right.
   * @param aForward move forward in document.
   * @param aExtend continue selection
   */
  MOZ_CAN_RUN_SCRIPT nsresult WordMove(bool aForward, bool aExtend);

  /**
   * LineMove will generally be called from the nsiselectioncontroller
   * implementations. the effect being the selection will move one line up or
   * down.
   * @param aForward move forward in document.
   * @param aExtend continue selection
   */
  MOZ_CAN_RUN_SCRIPT nsresult LineMove(bool aForward, bool aExtend);

  /**
   * IntraLineMove will generally be called from the nsiselectioncontroller
   * implementations. the effect being the selection will move to beginning or
   * end of line
   * @param aForward move forward in document.
   * @param aExtend continue selection
   */
  MOZ_CAN_RUN_SCRIPT nsresult IntraLineMove(bool aForward, bool aExtend);

  /**
   * ParagraphMove will generally be called from the nsiselectioncontroller
   * implementations. the effect being the selection will move to beginning or
   * end of paragraph
   * @param aForward move forward in document.
   * @param aExtend continue selection
   */
  MOZ_CAN_RUN_SCRIPT nsresult ParagraphMove(bool aForward, bool aExtend);

  /**
   * CreateRangeExtendedToNextGraphemeClusterBoundary() returns range which is
   * extended from normal selection range to start of next grapheme cluster
   * boundary.
   *
   * @param aLimitersAndCaretData       The data of limiters and additional
   *                                    caret data.
   * @param aRange                      The range which you want to extend.
   * @param aRangeDirection             eDirNext if the start boundary of
   *                                    aRange is focus.  Otherwise, i.e., if
   *                                    the start boundary is anchor,
   *                                    eDirPrevious.
   */
  template <typename RangeType>
  MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
  CreateRangeExtendedToNextGraphemeClusterBoundary(
      mozilla::PresShell& aPresShell,
      const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
      const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
    return CreateRangeExtendedToSomewhere<RangeType>(
        aPresShell, aLimitersAndCaretData, aRange, aRangeDirection, eDirNext,
        eSelectCluster, eLogical);
  }

  /**
   * CreateRangeExtendedToPreviousCharacterBoundary() returns range which is
   * extended from normal selection range to start of previous character
   * boundary.
   *
   * @param aLimitersAndCaretData       The data of limiters and additional
   *                                    caret data.
   * @param aRange                      The range which you want to extend.
   * @param aRangeDirection             eDirNext if the start boundary of
   *                                    aRange is focus.  Otherwise, i.e., if
   *                                    the start boundary is anchor,
   *                                    eDirPrevious.
   */
  template <typename RangeType>
  MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
  CreateRangeExtendedToPreviousCharacterBoundary(
      mozilla::PresShell& aPresShell,
      const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
      const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
    return CreateRangeExtendedToSomewhere<RangeType>(
        aPresShell, aLimitersAndCaretData, aRange, aRangeDirection,
        eDirPrevious, eSelectCharacter, eLogical);
  }

  /**
   * CreateRangeExtendedToNextWordBoundary() returns range which is
   * extended from normal selection range to start of next word boundary.
   *
   * @param aLimitersAndCaretData       The data of limiters and additional
   *                                    caret data.
   * @param aRange                      The range which you want to extend.
   * @param aRangeDirection             eDirNext if the start boundary of
   *                                    aRange is focus.  Otherwise, i.e., if
   *                                    the start boundary is anchor,
   *                                    eDirPrevious.
   */
  template <typename RangeType>
  MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
  CreateRangeExtendedToNextWordBoundary(
      mozilla::PresShell& aPresShell,
      const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
      const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
    return CreateRangeExtendedToSomewhere<RangeType>(
        aPresShell, aLimitersAndCaretData, aRange, aRangeDirection, eDirNext,
        eSelectWord, eLogical);
  }

  /**
   * CreateRangeExtendedToPreviousWordBoundary() returns range which is
   * extended from normal selection range to start of previous word boundary.
   *
   * @param aLimitersAndCaretData       The data of limiters and additional
   *                                    caret data.
   * @param aRange                      The range which you want to extend.
   * @param aRangeDirection             eDirNext if the start boundary of
   *                                    aRange is focus.  Otherwise, i.e., if
   *                                    the start boundary is anchor,
   *                                    eDirPrevious.
   */
  template <typename RangeType>
  MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
  CreateRangeExtendedToPreviousWordBoundary(
      mozilla::PresShell& aPresShell,
      const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
      const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
    return CreateRangeExtendedToSomewhere<RangeType>(
        aPresShell, aLimitersAndCaretData, aRange, aRangeDirection,
        eDirPrevious, eSelectWord, eLogical);
  }

  /**
   * CreateRangeExtendedToPreviousHardLineBreak() returns range which is
   * extended from normal selection range to previous hard line break.
   *
   * @param aLimitersAndCaretData       The data of limiters and additional
   *                                    caret data.
   * @param aRange                      The range which you want to extend.
   * @param aRangeDirection             eDirNext if the start boundary of
   *                                    aRange is focus.  Otherwise, i.e., if
   *                                    the start boundary is anchor,
   *                                    eDirPrevious.
   */
  template <typename RangeType>
  MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
  CreateRangeExtendedToPreviousHardLineBreak(
      mozilla::PresShell& aPresShell,
      const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
      const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
    return CreateRangeExtendedToSomewhere<RangeType>(
        aPresShell, aLimitersAndCaretData, aRange, aRangeDirection,
        eDirPrevious, eSelectBeginLine, eLogical);
  }

  /**
   * CreateRangeExtendedToNextHardLineBreak() returns range which is extended
   * from normal selection range to next hard line break.
   *
   * @param aLimitersAndCaretData       The data of limiters and additional
   *                                    caret data.
   * @param aRange                      The range which you want to extend.
   * @param aRangeDirection             eDirNext if the start boundary of
   *                                    aRange is focus.  Otherwise, i.e., if
   *                                    the start boundary is anchor,
   *                                    eDirPrevious.
   */
  template <typename RangeType>
  MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
  CreateRangeExtendedToNextHardLineBreak(
      mozilla::PresShell& aPresShell,
      const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
      const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection) {
    return CreateRangeExtendedToSomewhere<RangeType>(
        aPresShell, aLimitersAndCaretData, aRange, aRangeDirection, eDirNext,
        eSelectEndLine, eLogical);
  }

  /** Sets/Gets The display selection enum.
   */
  void SetDisplaySelection(int16_t aState) { mDisplaySelection = aState; }
  [[nodiscard]] int16_t GetDisplaySelection() const {
    return mDisplaySelection;
  }

  /**
   * This method can be used to store the data received during a MouseDown
   * event so that we can place the caret during the MouseUp event.
   *
   * @param aMouseEvent the event received by the selection MouseDown
   * handling method. A nullptr value can be use to tell this method
   * that any data is storing is no longer valid.
   */
  void SetDelayedCaretData(mozilla::WidgetMouseEvent* aMouseEvent);

  /**
   * Get the delayed MouseDown event data necessary to place the
   * caret during MouseUp processing.
   *
   * @return a pointer to the event received
   * by the selection during MouseDown processing. It can be nullptr
   * if the data is no longer valid.
   */
  [[nodiscard]] bool HasDelayedCaretData() const {
    return mDelayedMouseEvent.mIsValid;
  }
  [[nodiscard]] bool IsShiftDownInDelayedCaretData() const {
    NS_ASSERTION(mDelayedMouseEvent.mIsValid, "No valid delayed caret data");
    return mDelayedMouseEvent.mIsShift;
  }
  [[nodiscard]] uint32_t GetClickCountInDelayedCaretData() const {
    NS_ASSERTION(mDelayedMouseEvent.mIsValid, "No valid delayed caret data");
    return mDelayedMouseEvent.mClickCount;
  }

  [[nodiscard]] bool MouseDownRecorded() const {
    return !GetDragState() && HasDelayedCaretData() &&
           GetClickCountInDelayedCaretData() < 2;
  }

  [[nodiscard]] const mozilla::SelectionLimiters& LimitersRef() const {
    return mLimiters;
  }

  /**
   * Returns the selection root element if and only if the instance is for an
   * independent selection.  Currently, this is a native anonymous `<div>` for
   * a text control.
   */
  [[nodiscard]] Element* GetIndependentSelectionRootElement() const {
    return mLimiters.mIndependentSelectionRootElement;
  }

  /**
   * Get the independent selection root parent which is usually a text control
   * element which hosts the anonymous subtree managed by this frame selection.
   */
  [[nodiscard]] Element* GetIndependentSelectionRootParentElement() const {
    MOZ_DIAGNOSTIC_ASSERT(IsIndependentSelection());
    return Element::FromNodeOrNull(
        mLimiters.mIndependentSelectionRootElement
            ->GetClosestNativeAnonymousSubtreeRootParentOrHost());
  }

  /**
   * GetAncestorLimiter() returns the root of current selection ranges.  This is
   * typically the focused editing host unless it's the root element of the
   * document.
   */
  [[nodiscard]] Element* GetAncestorLimiter() const {
    return mLimiters.mAncestorLimiter;
  }

  [[nodiscard]] Element* GetAncestorLimiterOrIndependentSelectionRootElement()
      const {
    return mLimiters.mAncestorLimiter
               ? mLimiters.mAncestorLimiter
               : mLimiters.mIndependentSelectionRootElement;
  }

  /**
   * Set ancestor limiter.  If aLimiter is not nullptr, this adjusts all
   * selection ranges into the limiter element.  Thus, calling this may run
   * the selection listeners.
   */
  MOZ_CAN_RUN_SCRIPT void SetAncestorLimiter(Element* aLimiter);

  /**
   * GetPrevNextBidiLevels will return the frames and associated Bidi levels of
   * the characters logically before and after a (collapsed) selection.
   *
   * @param aNode is the node containing the selection
   * @param aContentOffset is the offset of the selection in the node
   * @param aJumpLines
   *   If true, look across line boundaries.
   *   If false, behave as if there were base-level frames at line edges.
   *
   * @return A struct holding the before/after frame and the before/after
   * level.
   *
   * At the beginning and end of each line there is assumed to be a frame with
   * Bidi level equal to the paragraph embedding level.
   *
   * In these cases the before frame and after frame respectively will be
   * nullptr.
   */
  [[nodiscard]] nsPrevNextBidiLevels GetPrevNextBidiLevels(
      nsIContent* aNode, uint32_t aContentOffset, bool aJumpLines) const;

  /**
   * MaintainSelection will track the normal selection as being "sticky".
   * Dragging or extending selection will never allow for a subset
   * (or the whole) of the maintained selection to become unselected.
   * Primary use: double click selecting then dragging on second click
   *
   * @param aAmount the initial amount of text selected (word, line or
   * paragraph). For "line", use eSelectBeginLine.
   */
  nsresult MaintainSelection(nsSelectionAmount aAmount = eSelectNoAmount);

  MOZ_CAN_RUN_SCRIPT nsresult ConstrainFrameAndPointToAnchorSubtree(
      nsIFrame* aFrame, const nsPoint& aPoint, nsIFrame** aRetFrame,
      nsPoint& aRetPoint) const;

  /**
   * @param aPresShell is the parameter to be used for most of the other calls
   * for callbacks etc
   *
   * @param aAccessibleCaretEnabled true if we should enable the accessible
   * caret.
   *
   * @param aEditorRootAnonymousDiv if this instance is for an independent
   * selection for a text control, specify this to the anonymous <div> element
   * of the text control which contains only an editable Text and/or a <br>.
   */
  nsFrameSelection(mozilla::PresShell* aPresShell, bool aAccessibleCaretEnabled,
                   Element* aEditorRootAnonymousDiv = nullptr);

  /**
   * @param aRequesterFuncName function name which wants to start the batch.
   * This won't be stored nor exposed to selection listeners etc, used only for
   * logging.
   */
  void StartBatchChanges(const char* aRequesterFuncName);

  /**
   * @param aRequesterFuncName function name which wants to end the batch.
   * This won't be stored nor exposed to selection listeners etc, used only for
   * logging.
   * @param aReasons potentially multiple of the reasons defined in
   * nsISelectionListener.idl
   */
  MOZ_CAN_RUN_SCRIPT void EndBatchChanges(
      const char* aRequesterFuncName,
      int16_t aReasons = nsISelectionListener::NO_REASON);

  [[nodiscard]] mozilla::PresShell* GetPresShell() const { return mPresShell; }

  void DisconnectFromPresShell();
  MOZ_CAN_RUN_SCRIPT nsresult ClearNormalSelection();

  // Table selection support.
  static nsITableCellLayout* GetCellLayout(const nsIContent* aCellContent);

  /**
   * Called when eFocus event of aDocument will be dispatched to the DOM.
   */
  static void WillFocusDocument(mozilla::PresShell& aPresShell,
                                mozilla::dom::Document& aDocument);

  /**
   * Called when eBlur event of aDocument will be dispatched to the DOM.
   */
  static void WillBlurDocument(mozilla::PresShell& aPresShell,
                               mozilla::dom::Document& aDocument);

 private:
  ~nsFrameSelection();

  /**
   * Populates an existing highlight Selection with ranges from a Highlight.
   * Must be called after the Selection is registered in mHighlightSelections.
   */
  MOZ_CAN_RUN_SCRIPT void PopulateHighlightSelection(
      mozilla::dom::Selection& aSelection, mozilla::dom::Highlight& aHighlight);

  // TODO: in case an error is returned, it sometimes refers to a programming
  // error, in other cases to runtime errors. This deserves to be cleaned up.
  [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
  TakeFocus(nsIContent& aNewFocus, uint32_t aContentOffset,
            uint32_t aContentEndOffset, CaretAssociationHint aHint,
            FocusMode aFocusMode);

  /**
   * After moving the caret, its Bidi level is set according to the following
   * rules:
   *
   * After moving over a character with left/right arrow, set to the Bidi level
   * of the last moved over character. After Home and End, set to the paragraph
   * embedding level. After up/down arrow, PageUp/Down, set to the lower level
   * of the 2 surrounding characters. After mouse click, set to the level of the
   * current frame.
   *
   * The following two methods use GetPrevNextBidiLevels to determine the new
   * Bidi level. BidiLevelFromMove is called when the caret is moved in response
   * to a keyboard event
   *
   * @param aPresShell is the presentation shell
   * @param aNode is the content node
   * @param aContentOffset is the new caret position, as an offset into aNode
   * @param aAmount is the amount of the move that gave the caret its new
   * position
   * @param aHint is the hint indicating in what logical direction the caret
   * moved
   */
  void BidiLevelFromMove(mozilla::PresShell* aPresShell, nsIContent* aNode,
                         uint32_t aContentOffset, nsSelectionAmount aAmount,
                         CaretAssociationHint aHint);
  /**
   * BidiLevelFromClick is called when the caret is repositioned by clicking the
   * mouse
   *
   * @param aNode is the content node
   * @param aContentOffset is the new caret position, as an offset into aNode
   */
  void BidiLevelFromClick(nsIContent* aNewFocus, uint32_t aContentOffset);

  /**
   * @param aReasons potentially multiple of the reasons defined in
   * nsISelectionListener.idl.
   */
  void SetChangeReasons(int16_t aReasons) {
    mSelectionChangeReasons = aReasons;
  }

  /**
   * @param aReasons potentially multiple of the reasons defined in
   * nsISelectionListener.idl.
   */
  void AddChangeReasons(int16_t aReasons) {
    mSelectionChangeReasons |= aReasons;
  }

  /**
   * @return potentially multiple of the reasons defined in
   * nsISelectionListener.idl.
   */
  [[nodiscard]] int16_t PopChangeReasons() {
    int16_t retval = mSelectionChangeReasons;
    mSelectionChangeReasons = nsISelectionListener::NO_REASON;
    return retval;
  }

  [[nodiscard]] nsSelectionAmount GetCaretMoveAmount() {
    return mCaretMoveAmount;
  }

  [[nodiscard]] bool IsUserSelectionReason() const {
    return (mSelectionChangeReasons &
            (nsISelectionListener::DRAG_REASON |
             nsISelectionListener::MOUSEDOWN_REASON |
             nsISelectionListener::MOUSEUP_REASON |
             nsISelectionListener::KEYPRESS_REASON)) !=
           nsISelectionListener::NO_REASON;
  }

  friend class mozilla::dom::Selection;
  friend class mozilla::SelectionChangeEventDispatcher;
  friend struct mozilla::AutoPrepareFocusRange;

  /*HELPER METHODS*/
  // Whether MoveCaret should use logical or visual movement,
  // or follow the bidi.edit.caret_movement_style preference.
  enum CaretMovementStyle { eLogical, eVisual, eUsePrefStyle };
  enum class ExtendSelection : bool { No, Yes };
  MOZ_CAN_RUN_SCRIPT nsresult MoveCaret(nsDirection aDirection,
                                        ExtendSelection aExtendSelection,
                                        nsSelectionAmount aAmount,
                                        CaretMovementStyle aMovementStyle);

  /**
   * @brief Creates `PeekOffsetOptions` for caret move operations.
   *
   * @param aSelection       The selection object. Must be non-null
   * @param aExtendSelection Whether the selection should be extended or not
   * @param aMovementStyle   The `CaretMovementStyle` (logical or visual)
   * @return mozilla::Result<mozilla::PeekOffsetOptions, nsresult>
   */
  [[nodiscard]] mozilla::Result<mozilla::PeekOffsetOptions, nsresult>
  CreatePeekOffsetOptionsForCaretMove(mozilla::dom::Selection* aSelection,
                                      ExtendSelection aExtendSelection,
                                      CaretMovementStyle aMovementStyle) const {
    MOZ_ASSERT(aSelection);
    return CreatePeekOffsetOptionsForCaretMove(
        mLimiters.mIndependentSelectionRootElement,
        static_cast<ForceEditableRegion>(aSelection->IsEditorSelection()),
        aExtendSelection, aMovementStyle);
  }

  enum class ForceEditableRegion : bool { No, Yes };
  [[nodiscard]] static mozilla::Result<mozilla::PeekOffsetOptions, nsresult>
  CreatePeekOffsetOptionsForCaretMove(const Element* aSelectionLimiter,
                                      ForceEditableRegion aForceEditableRegion,
                                      ExtendSelection aExtendSelection,
                                      CaretMovementStyle aMovementStyle);

  /**
   * @brief Get the Ancestor Limiter for caret move operation.
   *
   * If the selection is an editor selection, the correct editing host is
   * identified and chosen as limiting element.
   *
   * @param aSelection The selection object. Must be non-null
   * @return The ancestor limiter, or nullptr.
   */
  [[nodiscard]] mozilla::Result<Element*, nsresult>
  GetAncestorLimiterForCaretMove(mozilla::dom::Selection* aSelection) const;

  /**
   * CreateRangeExtendedToSomewhere() is common method to implement
   * CreateRangeExtendedTo*().  This method creates a range extended from
   * aRange.
   *
   * @param aLimitersAndCaretData       The data of limiters and additional
   *                                    caret data.
   * @param aRange                      The range which you want to extend.
   * @param aRangeDirection             eDirNext if the start boundary of
   *                                    aRange is focus.  Otherwise, i.e., if
   *                                    the start boundary is anchor,
   *                                    eDirPrevious.
   * @param aExtendDirection            Whether you want to extend the range
   *                                    backward or forward.
   * @param aAmount                     The amount which you want to extend.
   * @param aMovementStyle              Whether visual or logical.
   */
  template <typename RangeType>
  MOZ_CAN_RUN_SCRIPT static mozilla::Result<RefPtr<RangeType>, nsresult>
  CreateRangeExtendedToSomewhere(
      mozilla::PresShell& aPresShell,
      const mozilla::LimitersAndCaretData& aLimitersAndCaretData,
      const mozilla::dom::AbstractRange& aRange, nsDirection aRangeDirection,
      nsDirection aExtendDirection, const nsSelectionAmount aAmount,
      CaretMovementStyle aMovementStyle);

  void InvalidateDesiredCaretPos();  // do not listen to mDesiredCaretPos.mValue
                                     // you must get another.

  [[nodiscard]] bool IsBatching() const { return mBatching.mCounter > 0; }

  enum class IsBatchingEnd : bool { No, Yes };

  // nsFrameSelection may get deleted when calling this,
  // so remember to use nsCOMPtr when needed.
  MOZ_CAN_RUN_SCRIPT nsresult
  NotifySelectionListeners(mozilla::SelectionType aSelectionType,
                           IsBatchingEnd aEndBatching = IsBatchingEnd::No);

  static nsresult GetCellIndexes(const nsIContent* aCell, int32_t& aRowIndex,
                                 int32_t& aColIndex);

  [[nodiscard]] static nsIContent* GetFirstCellNodeInRange(
      const nsRange* aRange);
  // Returns non-null table if in same table, null otherwise
  [[nodiscard]] static nsIContent* IsInSameTable(const nsIContent* aContent1,
                                                 const nsIContent* aContent2);
  // Might return null
  [[nodiscard]] static nsIContent* GetParentTable(const nsIContent* aCellNode);

  ////////////BEGIN nsFrameSelection members

  RefPtr<mozilla::dom::Selection>
      mDomSelections[sizeof(mozilla::kPresentSelectionTypes) /
                     sizeof(mozilla::SelectionType)];

  nsTArray<
      mozilla::CompactPair<RefPtr<nsAtom>, RefPtr<mozilla::dom::Selection>>>
      mHighlightSelections;

  struct TableSelection {
    // Get our first range, if its first selected node is a cell.  If this does
    // not return null, then the first node in the returned range is a cell
    // (according to GetFirstCellNodeInRange).
    nsRange* GetFirstCellRange(const mozilla::dom::Selection& aNormalSelection);

    // Get our next range, if its first selected node is a cell.  If this does
    // not return null, then the first node in the returned range is a cell
    // (according to GetFirstCellNodeInRange).
    nsRange* GetNextCellRange(const mozilla::dom::Selection& aNormalSelection);

    [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult
    HandleSelection(nsINode* aParentContent, int32_t aContentOffset,
                    mozilla::TableSelectionMode aTarget,
                    mozilla::WidgetMouseEvent* aMouseEvent, bool aDragState,
                    mozilla::dom::Selection& aNormalSelection);

    /**
     * @return the closest inclusive table cell ancestor
     *         (https://dom.spec.whatwg.org/#concept-tree-inclusive-ancestor) of
     *         aContent, if it is actively editable.
     */
    [[nodiscard]] static nsINode* IsContentInActivelyEditableTableCell(
        nsPresContext* aContext, nsIContent* aContent);

    // TODO: annotate this with `MOZ_CAN_RUN_SCRIPT` instead.
    MOZ_CAN_RUN_SCRIPT nsresult
    SelectBlockOfCells(nsIContent* aStartCell, nsIContent* aEndCell,
                       mozilla::dom::Selection& aNormalSelection);

    MOZ_CAN_RUN_SCRIPT nsresult SelectRowOrColumn(
        nsIContent* aCellContent, mozilla::dom::Selection& aNormalSelection);

    MOZ_CAN_RUN_SCRIPT nsresult
    UnselectCells(const nsIContent* aTable, int32_t aStartRowIndex,
                  int32_t aStartColumnIndex, int32_t aEndRowIndex,
                  int32_t aEndColumnIndex, bool aRemoveOutsideOfCellRange,
                  mozilla::dom::Selection& aNormalSelection);

    nsCOMPtr<nsINode>
        mClosestInclusiveTableCellAncestor;  // used to snap to table selection
    nsCOMPtr<nsIContent> mStartSelectedCell;
    nsCOMPtr<nsIContent> mEndSelectedCell;
    nsCOMPtr<nsIContent> mAppendStartSelectedCell;
    nsCOMPtr<nsIContent> mUnselectCellOnMouseUp;
    mozilla::TableSelectionMode mMode = mozilla::TableSelectionMode::None;
    int32_t mSelectedCellIndex = 0;
    bool mDragSelectingCells = false;

   private:
    struct MOZ_STACK_CLASS FirstAndLastCell {
      nsCOMPtr<nsIContent> mFirst;
      nsCOMPtr<nsIContent> mLast;
    };

    [[nodiscard]] mozilla::Result<FirstAndLastCell, nsresult>
    FindFirstAndLastCellOfRowOrColumn(const nsIContent& aCellContent) const;

    [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleDragSelecting(
        mozilla::TableSelectionMode aTarget, nsIContent* aChildContent,
        const mozilla::WidgetMouseEvent* aMouseEvent,
        mozilla::dom::Selection& aNormalSelection);

    [[nodiscard]] MOZ_CAN_RUN_SCRIPT nsresult HandleMouseUpOrDown(
        mozilla::TableSelectionMode aTarget, bool aDragState,
        nsIContent* aChildContent, nsINode* aParentContent,
        int32_t aContentOffset, const mozilla::WidgetMouseEvent* aMouseEvent,
        mozilla::dom::Selection& aNormalSelection);

    class MOZ_STACK_CLASS RowAndColumnRelation;
  };

  TableSelection mTableSelection;

  struct MaintainedRange {
    /**
     * Ensure anchor and focus of aNormalSelection are ordered appropriately
     * relative to the maintained range.
     */
    MOZ_CAN_RUN_SCRIPT void AdjustNormalSelection(
        const nsIContent* aContent, int32_t aOffset,
        mozilla::dom::Selection& aNormalSelection) const;

    /**
     * @param aStopAtScroller   If yes, this will
     *                          set `PeekOffsetOption::StopAtScroller`.
     */
    enum class StopAtScroller : bool { No, Yes };
    void AdjustContentOffsets(nsIFrame::ContentOffsets& aOffsets,
                              StopAtScroller aStopAtScroller) const;

    void MaintainAnchorFocusRange(
        const mozilla::dom::Selection& aNormalSelection,
        nsSelectionAmount aAmount);

    RefPtr<nsRange> mRange;
    nsSelectionAmount mAmount = eSelectNoAmount;
  };

  MaintainedRange mMaintainedRange;

  struct Batching {
    uint32_t mCounter = 0;
  };

  Batching mBatching;

  mozilla::SelectionLimiters mLimiters;

  mozilla::PresShell* mPresShell = nullptr;
  // Reasons for notifications of selection changing.
  // Can be multiple of the reasons defined in nsISelectionListener.idl.
  int16_t mSelectionChangeReasons = nsISelectionListener::NO_REASON;
  // For visual display purposes.
  int16_t mDisplaySelection = nsISelectionController::SELECTION_OFF;
  nsSelectionAmount mCaretMoveAmount = eSelectNoAmount;

  struct Caret {
    // Hint to tell if the selection is at the end of this line or beginning of
    // next.
    CaretAssociationHint mHint = CaretAssociationHint::Before;
    mozilla::intl::BidiEmbeddingLevel mBidiLevel = BIDI_LEVEL_UNDEFINED;

    [[nodiscard]] static bool IsVisualMovement(
        ExtendSelection aExtendSelection, CaretMovementStyle aMovementStyle);
  };

  Caret mCaret;

  mozilla::intl::BidiEmbeddingLevel mKbdBidiLevel =
      mozilla::intl::BidiEmbeddingLevel::LTR();

  class DesiredCaretPos {
   public:
    // the position requested by the Key Handling for up down
    nsresult FetchPos(nsPoint& aDesiredCaretPos,
                      const mozilla::PresShell& aPresShell,
                      mozilla::dom::Selection& aNormalSelection) const;

    void Set(const nsPoint& aPos);

    void Invalidate();

    bool mIsSet = false;

   private:
    nsPoint mValue;
  };

  DesiredCaretPos mDesiredCaretPos;

  struct DelayedMouseEvent {
    bool mIsValid = false;
    // These values are not used since they are only valid when mIsValid is
    // true, and setting mIsValid  always overrides these values.
    bool mIsShift = false;
    uint32_t mClickCount = 0;
  };

  DelayedMouseEvent mDelayedMouseEvent;

  bool mDragState = false;  // for drag purposes
  bool mAccessibleCaretEnabled = false;

  // Records if a selection was created by doubleclicking or tripleclicking
  // a word. This information is needed later on to determine if a leading
  // or trailing whitespace needs to be removed as well to achieve
  // native behaviour on macOS.
  mozilla::dom::ClickSelectionType mClickSelectionType =
      mozilla::dom::ClickSelectionType::NotApplicable;
};

/**
 * Selection Batcher class that supports multiple FrameSelections.
 */
class MOZ_RAII AutoFrameSelectionBatcher final {
 public:
  MOZ_CAN_RUN_SCRIPT explicit AutoFrameSelectionBatcher(
      const char* aFunctionName, size_t aEstimatedSize = 1)
      : mFunctionName(aFunctionName) {
    mFrameSelections.SetCapacity(aEstimatedSize);
  }
  MOZ_CAN_RUN_SCRIPT ~AutoFrameSelectionBatcher() {
    for (const auto& frameSelection : mFrameSelections) {
      MOZ_KnownLive(frameSelection)->EndBatchChanges(mFunctionName);
    }
  }
  void AddFrameSelection(nsFrameSelection* aFrameSelection) {
    if (!aFrameSelection) {
      return;
    }
    aFrameSelection->StartBatchChanges(mFunctionName);
    mFrameSelections.AppendElement(aFrameSelection);
  }

 private:
  const char* mFunctionName;
  AutoTArray<RefPtr<nsFrameSelection>, 1> mFrameSelections;
};

namespace mozilla {

/**
 * A struct for sharing nsFrameSelection outside of its instance.
 */
struct LimitersAndCaretData : public SelectionLimiters {
  using Element = dom::Element;

  LimitersAndCaretData() = default;
  MOZ_IMPLICIT LimitersAndCaretData(const LimitersAndCaretData&) = default;
  LimitersAndCaretData(LimitersAndCaretData&&) = default;
  LimitersAndCaretData& operator=(const LimitersAndCaretData&) = default;
  LimitersAndCaretData& operator=(LimitersAndCaretData&&) = default;
  explicit LimitersAndCaretData(const nsFrameSelection& aFrameSelection)
      : SelectionLimiters(aFrameSelection.LimitersRef()),
        mCaretAssociationHint(aFrameSelection.GetHint()),
        mCaretBidiLevel(aFrameSelection.GetCaretBidiLevel()) {}

  // nsFrameSelection::GetHint
  CaretAssociationHint mCaretAssociationHint = CaretAssociationHint::Before;
  // nsFrameSelection::GetCaretBidiLevel
  intl::BidiEmbeddingLevel mCaretBidiLevel;
};

}  // namespace mozilla

#endif /* nsFrameSelection_h_ */