@lexical/selection 0.13.1 → 0.14.1

package/LexicalSelection.dev.esm.js

@@ -0,0 +1,971 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import { $isTextNode, $isElementNode, $getCharacterOffsets, $isRootNode, $getNodeByKey, $getPreviousSelection, $createTextNode, $isRangeSelection, $getRoot, $isRootOrShadowRoot, $hasAncestor, $isLeafNode, $setSelection, $getAdjacentNode, $isDecoratorNode, $isLineBreakNode } from 'lexical';
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+const CSS_TO_STYLES = new Map();
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+function getDOMTextNode(element) {
+  let node = element;
+  while (node != null) {
+    if (node.nodeType === Node.TEXT_NODE) {
+      return node;
+    }
+    node = node.firstChild;
+  }
+  return null;
+}
+function getDOMIndexWithinParent(node) {
+  const parent = node.parentNode;
+  if (parent == null) {
+    throw new Error('Should never happen');
+  }
+  return [parent, Array.from(parent.childNodes).indexOf(node)];
+}
+
+/**
+ * Creates a selection range for the DOM.
+ * @param editor - The lexical editor.
+ * @param anchorNode - The anchor node of a selection.
+ * @param _anchorOffset - The amount of space offset from the anchor to the focus.
+ * @param focusNode - The current focus.
+ * @param _focusOffset - The amount of space offset from the focus to the anchor.
+ * @returns The range of selection for the DOM that was created.
+ */
+function createDOMRange(editor, anchorNode, _anchorOffset, focusNode, _focusOffset) {
+  const anchorKey = anchorNode.getKey();
+  const focusKey = focusNode.getKey();
+  const range = document.createRange();
+  let anchorDOM = editor.getElementByKey(anchorKey);
+  let focusDOM = editor.getElementByKey(focusKey);
+  let anchorOffset = _anchorOffset;
+  let focusOffset = _focusOffset;
+  if ($isTextNode(anchorNode)) {
+    anchorDOM = getDOMTextNode(anchorDOM);
+  }
+  if ($isTextNode(focusNode)) {
+    focusDOM = getDOMTextNode(focusDOM);
+  }
+  if (anchorNode === undefined || focusNode === undefined || anchorDOM === null || focusDOM === null) {
+    return null;
+  }
+  if (anchorDOM.nodeName === 'BR') {
+    [anchorDOM, anchorOffset] = getDOMIndexWithinParent(anchorDOM);
+  }
+  if (focusDOM.nodeName === 'BR') {
+    [focusDOM, focusOffset] = getDOMIndexWithinParent(focusDOM);
+  }
+  const firstChild = anchorDOM.firstChild;
+  if (anchorDOM === focusDOM && firstChild != null && firstChild.nodeName === 'BR' && anchorOffset === 0 && focusOffset === 0) {
+    focusOffset = 1;
+  }
+  try {
+    range.setStart(anchorDOM, anchorOffset);
+    range.setEnd(focusDOM, focusOffset);
+  } catch (e) {
+    return null;
+  }
+  if (range.collapsed && (anchorOffset !== focusOffset || anchorKey !== focusKey)) {
+    // Range is backwards, we need to reverse it
+    range.setStart(focusDOM, focusOffset);
+    range.setEnd(anchorDOM, anchorOffset);
+  }
+  return range;
+}
+
+/**
+ * Creates DOMRects, generally used to help the editor find a specific location on the screen.
+ * @param editor - The lexical editor
+ * @param range - A fragment of a document that can contain nodes and parts of text nodes.
+ * @returns The selectionRects as an array.
+ */
+function createRectsFromDOMRange(editor, range) {
+  const rootElement = editor.getRootElement();
+  if (rootElement === null) {
+    return [];
+  }
+  const rootRect = rootElement.getBoundingClientRect();
+  const computedStyle = getComputedStyle(rootElement);
+  const rootPadding = parseFloat(computedStyle.paddingLeft) + parseFloat(computedStyle.paddingRight);
+  const selectionRects = Array.from(range.getClientRects());
+  let selectionRectsLength = selectionRects.length;
+  //sort rects from top left to bottom right.
+  selectionRects.sort((a, b) => {
+    const top = a.top - b.top;
+    // Some rects match position closely, but not perfectly,
+    // so we give a 3px tolerance.
+    if (Math.abs(top) <= 3) {
+      return a.left - b.left;
+    }
+    return top;
+  });
+  let prevRect;
+  for (let i = 0; i < selectionRectsLength; i++) {
+    const selectionRect = selectionRects[i];
+    // Exclude rects that overlap preceding Rects in the sorted list.
+    const isOverlappingRect = prevRect && prevRect.top <= selectionRect.top && prevRect.top + prevRect.height > selectionRect.top && prevRect.left + prevRect.width > selectionRect.left;
+    // Exclude selections that span the entire element
+    const selectionSpansElement = selectionRect.width + rootPadding === rootRect.width;
+    if (isOverlappingRect || selectionSpansElement) {
+      selectionRects.splice(i--, 1);
+      selectionRectsLength--;
+      continue;
+    }
+    prevRect = selectionRect;
+  }
+  return selectionRects;
+}
+
+/**
+ * Creates an object containing all the styles and their values provided in the CSS string.
+ * @param css - The CSS string of styles and their values.
+ * @returns The styleObject containing all the styles and their values.
+ */
+function getStyleObjectFromRawCSS(css) {
+  const styleObject = {};
+  const styles = css.split(';');
+  for (const style of styles) {
+    if (style !== '') {
+      const [key, value] = style.split(/:([^]+)/); // split on first colon
+      if (key && value) {
+        styleObject[key.trim()] = value.trim();
+      }
+    }
+  }
+  return styleObject;
+}
+
+/**
+ * Given a CSS string, returns an object from the style cache.
+ * @param css - The CSS property as a string.
+ * @returns The value of the given CSS property.
+ */
+function getStyleObjectFromCSS(css) {
+  let value = CSS_TO_STYLES.get(css);
+  if (value === undefined) {
+    value = getStyleObjectFromRawCSS(css);
+    CSS_TO_STYLES.set(css, value);
+  }
+  {
+    // Freeze the value in DEV to prevent accidental mutations
+    Object.freeze(value);
+  }
+  return value;
+}
+
+/**
+ * Gets the CSS styles from the style object.
+ * @param styles - The style object containing the styles to get.
+ * @returns A string containing the CSS styles and their values.
+ */
+function getCSSFromStyleObject(styles) {
+  let css = '';
+  for (const style in styles) {
+    if (style) {
+      css += `${style}: ${styles[style]};`;
+    }
+  }
+  return css;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+function $updateElementNodeProperties(target, source) {
+  target.__first = source.__first;
+  target.__last = source.__last;
+  target.__size = source.__size;
+  target.__format = source.__format;
+  target.__indent = source.__indent;
+  target.__dir = source.__dir;
+  return target;
+}
+function $updateTextNodeProperties(target, source) {
+  target.__format = source.__format;
+  target.__style = source.__style;
+  target.__mode = source.__mode;
+  target.__detail = source.__detail;
+  return target;
+}
+
+/**
+ * Returns a copy of a node, but generates a new key for the copy.
+ * @param node - The node to be cloned.
+ * @returns The clone of the node.
+ */
+function $cloneWithProperties(node) {
+  const constructor = node.constructor;
+  // @ts-expect-error
+  const clone = constructor.clone(node);
+  clone.__parent = node.__parent;
+  clone.__next = node.__next;
+  clone.__prev = node.__prev;
+  if ($isElementNode(node) && $isElementNode(clone)) {
+    return $updateElementNodeProperties(clone, node);
+  }
+  if ($isTextNode(node) && $isTextNode(clone)) {
+    return $updateTextNodeProperties(clone, node);
+  }
+  return clone;
+}
+
+/**
+ * Generally used to append text content to HTML and JSON. Grabs the text content and "slices"
+ * it to be generated into the new TextNode.
+ * @param selection - The selection containing the node whose TextNode is to be edited.
+ * @param textNode - The TextNode to be edited.
+ * @returns The updated TextNode.
+ */
+function $sliceSelectedTextNodeContent(selection, textNode) {
+  const anchorAndFocus = selection.getStartEndPoints();
+  if (textNode.isSelected(selection) && !textNode.isSegmented() && !textNode.isToken() && anchorAndFocus !== null) {
+    const [anchor, focus] = anchorAndFocus;
+    const isBackward = selection.isBackward();
+    const anchorNode = anchor.getNode();
+    const focusNode = focus.getNode();
+    const isAnchor = textNode.is(anchorNode);
+    const isFocus = textNode.is(focusNode);
+    if (isAnchor || isFocus) {
+      const [anchorOffset, focusOffset] = $getCharacterOffsets(selection);
+      const isSame = anchorNode.is(focusNode);
+      const isFirst = textNode.is(isBackward ? focusNode : anchorNode);
+      const isLast = textNode.is(isBackward ? anchorNode : focusNode);
+      let startOffset = 0;
+      let endOffset = undefined;
+      if (isSame) {
+        startOffset = anchorOffset > focusOffset ? focusOffset : anchorOffset;
+        endOffset = anchorOffset > focusOffset ? anchorOffset : focusOffset;
+      } else if (isFirst) {
+        const offset = isBackward ? focusOffset : anchorOffset;
+        startOffset = offset;
+        endOffset = undefined;
+      } else if (isLast) {
+        const offset = isBackward ? anchorOffset : focusOffset;
+        startOffset = 0;
+        endOffset = offset;
+      }
+      textNode.__text = textNode.__text.slice(startOffset, endOffset);
+      return textNode;
+    }
+  }
+  return textNode;
+}
+
+/**
+ * Determines if the current selection is at the end of the node.
+ * @param point - The point of the selection to test.
+ * @returns true if the provided point offset is in the last possible position, false otherwise.
+ */
+function $isAtNodeEnd(point) {
+  if (point.type === 'text') {
+    return point.offset === point.getNode().getTextContentSize();
+  }
+  const node = point.getNode();
+  if (!$isElementNode(node)) {
+    throw Error(`isAtNodeEnd: node must be a TextNode or ElementNode`);
+  }
+  return point.offset === node.getChildrenSize();
+}
+
+/**
+ * Trims text from a node in order to shorten it, eg. to enforce a text's max length. If it deletes text
+ * that is an ancestor of the anchor then it will leave 2 indents, otherwise, if no text content exists, it deletes
+ * the TextNode. It will move the focus to either the end of any left over text or beginning of a new TextNode.
+ * @param editor - The lexical editor.
+ * @param anchor - The anchor of the current selection, where the selection should be pointing.
+ * @param delCount - The amount of characters to delete. Useful as a dynamic variable eg. textContentSize - maxLength;
+ */
+function trimTextContentFromAnchor(editor, anchor, delCount) {
+  // Work from the current selection anchor point
+  let currentNode = anchor.getNode();
+  let remaining = delCount;
+  if ($isElementNode(currentNode)) {
+    const descendantNode = currentNode.getDescendantByIndex(anchor.offset);
+    if (descendantNode !== null) {
+      currentNode = descendantNode;
+    }
+  }
+  while (remaining > 0 && currentNode !== null) {
+    if ($isElementNode(currentNode)) {
+      const lastDescendant = currentNode.getLastDescendant();
+      if (lastDescendant !== null) {
+        currentNode = lastDescendant;
+      }
+    }
+    let nextNode = currentNode.getPreviousSibling();
+    let additionalElementWhitespace = 0;
+    if (nextNode === null) {
+      let parent = currentNode.getParentOrThrow();
+      let parentSibling = parent.getPreviousSibling();
+      while (parentSibling === null) {
+        parent = parent.getParent();
+        if (parent === null) {
+          nextNode = null;
+          break;
+        }
+        parentSibling = parent.getPreviousSibling();
+      }
+      if (parent !== null) {
+        additionalElementWhitespace = parent.isInline() ? 0 : 2;
+        nextNode = parentSibling;
+      }
+    }
+    let text = currentNode.getTextContent();
+    // If the text is empty, we need to consider adding in two line breaks to match
+    // the content if we were to get it from its parent.
+    if (text === '' && $isElementNode(currentNode) && !currentNode.isInline()) {
+      // TODO: should this be handled in core?
+      text = '\n\n';
+    }
+    const currentNodeSize = text.length;
+    if (!$isTextNode(currentNode) || remaining >= currentNodeSize) {
+      const parent = currentNode.getParent();
+      currentNode.remove();
+      if (parent != null && parent.getChildrenSize() === 0 && !$isRootNode(parent)) {
+        parent.remove();
+      }
+      remaining -= currentNodeSize + additionalElementWhitespace;
+      currentNode = nextNode;
+    } else {
+      const key = currentNode.getKey();
+      // See if we can just revert it to what was in the last editor state
+      const prevTextContent = editor.getEditorState().read(() => {
+        const prevNode = $getNodeByKey(key);
+        if ($isTextNode(prevNode) && prevNode.isSimpleText()) {
+          return prevNode.getTextContent();
+        }
+        return null;
+      });
+      const offset = currentNodeSize - remaining;
+      const slicedText = text.slice(0, offset);
+      if (prevTextContent !== null && prevTextContent !== text) {
+        const prevSelection = $getPreviousSelection();
+        let target = currentNode;
+        if (!currentNode.isSimpleText()) {
+          const textNode = $createTextNode(prevTextContent);
+          currentNode.replace(textNode);
+          target = textNode;
+        } else {
+          currentNode.setTextContent(prevTextContent);
+        }
+        if ($isRangeSelection(prevSelection) && prevSelection.isCollapsed()) {
+          const prevOffset = prevSelection.anchor.offset;
+          target.select(prevOffset, prevOffset);
+        }
+      } else if (currentNode.isSimpleText()) {
+        // Split text
+        const isSelected = anchor.key === key;
+        let anchorOffset = anchor.offset;
+        // Move offset to end if it's less than the remaining number, otherwise
+        // we'll have a negative splitStart.
+        if (anchorOffset < remaining) {
+          anchorOffset = currentNodeSize;
+        }
+        const splitStart = isSelected ? anchorOffset - remaining : 0;
+        const splitEnd = isSelected ? anchorOffset : offset;
+        if (isSelected && splitStart === 0) {
+          const [excessNode] = currentNode.splitText(splitStart, splitEnd);
+          excessNode.remove();
+        } else {
+          const [, excessNode] = currentNode.splitText(splitStart, splitEnd);
+          excessNode.remove();
+        }
+      } else {
+        const textNode = $createTextNode(slicedText);
+        currentNode.replace(textNode);
+      }
+      remaining = 0;
+    }
+  }
+}
+
+/**
+ * Gets the TextNode's style object and adds the styles to the CSS.
+ * @param node - The TextNode to add styles to.
+ */
+function $addNodeStyle(node) {
+  const CSSText = node.getStyle();
+  const styles = getStyleObjectFromRawCSS(CSSText);
+  CSS_TO_STYLES.set(CSSText, styles);
+}
+function $patchStyle(target, patch) {
+  const prevStyles = getStyleObjectFromCSS('getStyle' in target ? target.getStyle() : target.style);
+  const newStyles = Object.entries(patch).reduce((styles, [key, value]) => {
+    if (value instanceof Function) {
+      styles[key] = value(prevStyles[key]);
+    } else if (value === null) {
+      delete styles[key];
+    } else {
+      styles[key] = value;
+    }
+    return styles;
+  }, {
+    ...prevStyles
+  } || {});
+  const newCSSText = getCSSFromStyleObject(newStyles);
+  target.setStyle(newCSSText);
+  CSS_TO_STYLES.set(newCSSText, newStyles);
+}
+
+/**
+ * Applies the provided styles to the TextNodes in the provided Selection.
+ * Will update partially selected TextNodes by splitting the TextNode and applying
+ * the styles to the appropriate one.
+ * @param selection - The selected node(s) to update.
+ * @param patch - The patch to apply, which can include multiple styles. { CSSProperty: value }. Can also accept a function that returns the new property value.
+ */
+function $patchStyleText(selection, patch) {
+  const selectedNodes = selection.getNodes();
+  const selectedNodesLength = selectedNodes.length;
+  const anchorAndFocus = selection.getStartEndPoints();
+  if (anchorAndFocus === null) {
+    return;
+  }
+  const [anchor, focus] = anchorAndFocus;
+  const lastIndex = selectedNodesLength - 1;
+  let firstNode = selectedNodes[0];
+  let lastNode = selectedNodes[lastIndex];
+  if (selection.isCollapsed() && $isRangeSelection(selection)) {
+    $patchStyle(selection, patch);
+    return;
+  }
+  const firstNodeText = firstNode.getTextContent();
+  const firstNodeTextLength = firstNodeText.length;
+  const focusOffset = focus.offset;
+  let anchorOffset = anchor.offset;
+  const isBefore = anchor.isBefore(focus);
+  let startOffset = isBefore ? anchorOffset : focusOffset;
+  let endOffset = isBefore ? focusOffset : anchorOffset;
+  const startType = isBefore ? anchor.type : focus.type;
+  const endType = isBefore ? focus.type : anchor.type;
+  const endKey = isBefore ? focus.key : anchor.key;
+
+  // This is the case where the user only selected the very end of the
+  // first node so we don't want to include it in the formatting change.
+  if ($isTextNode(firstNode) && startOffset === firstNodeTextLength) {
+    const nextSibling = firstNode.getNextSibling();
+    if ($isTextNode(nextSibling)) {
+      // we basically make the second node the firstNode, changing offsets accordingly
+      anchorOffset = 0;
+      startOffset = 0;
+      firstNode = nextSibling;
+    }
+  }
+
+  // This is the case where we only selected a single node
+  if (selectedNodes.length === 1) {
+    if ($isTextNode(firstNode) && firstNode.canHaveFormat()) {
+      startOffset = startType === 'element' ? 0 : anchorOffset > focusOffset ? focusOffset : anchorOffset;
+      endOffset = endType === 'element' ? firstNodeTextLength : anchorOffset > focusOffset ? anchorOffset : focusOffset;
+
+      // No actual text is selected, so do nothing.
+      if (startOffset === endOffset) {
+        return;
+      }
+
+      // The entire node is selected, so just format it
+      if (startOffset === 0 && endOffset === firstNodeTextLength) {
+        $patchStyle(firstNode, patch);
+        firstNode.select(startOffset, endOffset);
+      } else {
+        // The node is partially selected, so split it into two nodes
+        // and style the selected one.
+        const splitNodes = firstNode.splitText(startOffset, endOffset);
+        const replacement = startOffset === 0 ? splitNodes[0] : splitNodes[1];
+        $patchStyle(replacement, patch);
+        replacement.select(0, endOffset - startOffset);
+      }
+    } // multiple nodes selected.
+  } else {
+    if ($isTextNode(firstNode) && startOffset < firstNode.getTextContentSize() && firstNode.canHaveFormat()) {
+      if (startOffset !== 0) {
+        // the entire first node isn't selected, so split it
+        firstNode = firstNode.splitText(startOffset)[1];
+        startOffset = 0;
+        anchor.set(firstNode.getKey(), startOffset, 'text');
+      }
+      $patchStyle(firstNode, patch);
+    }
+    if ($isTextNode(lastNode) && lastNode.canHaveFormat()) {
+      const lastNodeText = lastNode.getTextContent();
+      const lastNodeTextLength = lastNodeText.length;
+
+      // The last node might not actually be the end node
+      //
+      // If not, assume the last node is fully-selected unless the end offset is
+      // zero.
+      if (lastNode.__key !== endKey && endOffset !== 0) {
+        endOffset = lastNodeTextLength;
+      }
+
+      // if the entire last node isn't selected, split it
+      if (endOffset !== lastNodeTextLength) {
+        [lastNode] = lastNode.splitText(endOffset);
+      }
+      if (endOffset !== 0 || endType === 'element') {
+        $patchStyle(lastNode, patch);
+      }
+    }
+
+    // style all the text nodes in between
+    for (let i = 1; i < lastIndex; i++) {
+      const selectedNode = selectedNodes[i];
+      const selectedNodeKey = selectedNode.getKey();
+      if ($isTextNode(selectedNode) && selectedNode.canHaveFormat() && selectedNodeKey !== firstNode.getKey() && selectedNodeKey !== lastNode.getKey() && !selectedNode.isToken()) {
+        $patchStyle(selectedNode, patch);
+      }
+    }
+  }
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * Converts all nodes in the selection that are of one block type to another.
+ * @param selection - The selected blocks to be converted.
+ * @param createElement - The function that creates the node. eg. $createParagraphNode.
+ */
+function $setBlocksType(selection, createElement) {
+  if (selection === null) {
+    return;
+  }
+  const anchorAndFocus = selection.getStartEndPoints();
+  const anchor = anchorAndFocus ? anchorAndFocus[0] : null;
+  if (anchor !== null && anchor.key === 'root') {
+    const element = createElement();
+    const root = $getRoot();
+    const firstChild = root.getFirstChild();
+    if (firstChild) {
+      firstChild.replace(element, true);
+    } else {
+      root.append(element);
+    }
+    return;
+  }
+  const nodes = selection.getNodes();
+  const firstSelectedBlock = anchor !== null ? $getAncestor(anchor.getNode(), INTERNAL_$isBlock) : false;
+  if (firstSelectedBlock && nodes.indexOf(firstSelectedBlock) === -1) {
+    nodes.push(firstSelectedBlock);
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    if (!INTERNAL_$isBlock(node)) {
+      continue;
+    }
+    if (!$isElementNode(node)) {
+      throw Error(`Expected block node to be an ElementNode`);
+    }
+    const targetElement = createElement();
+    targetElement.setFormat(node.getFormatType());
+    targetElement.setIndent(node.getIndent());
+    node.replace(targetElement, true);
+  }
+}
+function isPointAttached(point) {
+  return point.getNode().isAttached();
+}
+function $removeParentEmptyElements(startingNode) {
+  let node = startingNode;
+  while (node !== null && !$isRootOrShadowRoot(node)) {
+    const latest = node.getLatest();
+    const parentNode = node.getParent();
+    if (latest.getChildrenSize() === 0) {
+      node.remove(true);
+    }
+    node = parentNode;
+  }
+}
+
+/**
+ * @deprecated
+ * Wraps all nodes in the selection into another node of the type returned by createElement.
+ * @param selection - The selection of nodes to be wrapped.
+ * @param createElement - A function that creates the wrapping ElementNode. eg. $createParagraphNode.
+ * @param wrappingElement - An element to append the wrapped selection and its children to.
+ */
+function $wrapNodes(selection, createElement, wrappingElement = null) {
+  const anchorAndFocus = selection.getStartEndPoints();
+  const anchor = anchorAndFocus ? anchorAndFocus[0] : null;
+  const nodes = selection.getNodes();
+  const nodesLength = nodes.length;
+  if (anchor !== null && (nodesLength === 0 || nodesLength === 1 && anchor.type === 'element' && anchor.getNode().getChildrenSize() === 0)) {
+    const target = anchor.type === 'text' ? anchor.getNode().getParentOrThrow() : anchor.getNode();
+    const children = target.getChildren();
+    let element = createElement();
+    element.setFormat(target.getFormatType());
+    element.setIndent(target.getIndent());
+    children.forEach(child => element.append(child));
+    if (wrappingElement) {
+      element = wrappingElement.append(element);
+    }
+    target.replace(element);
+    return;
+  }
+  let topLevelNode = null;
+  let descendants = [];
+  for (let i = 0; i < nodesLength; i++) {
+    const node = nodes[i];
+    // Determine whether wrapping has to be broken down into multiple chunks. This can happen if the
+    // user selected multiple Root-like nodes that have to be treated separately as if they are
+    // their own branch. I.e. you don't want to wrap a whole table, but rather the contents of each
+    // of each of the cell nodes.
+    if ($isRootOrShadowRoot(node)) {
+      $wrapNodesImpl(selection, descendants, descendants.length, createElement, wrappingElement);
+      descendants = [];
+      topLevelNode = node;
+    } else if (topLevelNode === null || topLevelNode !== null && $hasAncestor(node, topLevelNode)) {
+      descendants.push(node);
+    } else {
+      $wrapNodesImpl(selection, descendants, descendants.length, createElement, wrappingElement);
+      descendants = [node];
+    }
+  }
+  $wrapNodesImpl(selection, descendants, descendants.length, createElement, wrappingElement);
+}
+
+/**
+ * Wraps each node into a new ElementNode.
+ * @param selection - The selection of nodes to wrap.
+ * @param nodes - An array of nodes, generally the descendants of the selection.
+ * @param nodesLength - The length of nodes.
+ * @param createElement - A function that creates the wrapping ElementNode. eg. $createParagraphNode.
+ * @param wrappingElement - An element to wrap all the nodes into.
+ * @returns
+ */
+function $wrapNodesImpl(selection, nodes, nodesLength, createElement, wrappingElement = null) {
+  if (nodes.length === 0) {
+    return;
+  }
+  const firstNode = nodes[0];
+  const elementMapping = new Map();
+  const elements = [];
+  // The below logic is to find the right target for us to
+  // either insertAfter/insertBefore/append the corresponding
+  // elements to. This is made more complicated due to nested
+  // structures.
+  let target = $isElementNode(firstNode) ? firstNode : firstNode.getParentOrThrow();
+  if (target.isInline()) {
+    target = target.getParentOrThrow();
+  }
+  let targetIsPrevSibling = false;
+  while (target !== null) {
+    const prevSibling = target.getPreviousSibling();
+    if (prevSibling !== null) {
+      target = prevSibling;
+      targetIsPrevSibling = true;
+      break;
+    }
+    target = target.getParentOrThrow();
+    if ($isRootOrShadowRoot(target)) {
+      break;
+    }
+  }
+  const emptyElements = new Set();
+
+  // Find any top level empty elements
+  for (let i = 0; i < nodesLength; i++) {
+    const node = nodes[i];
+    if ($isElementNode(node) && node.getChildrenSize() === 0) {
+      emptyElements.add(node.getKey());
+    }
+  }
+  const movedNodes = new Set();
+
+  // Move out all leaf nodes into our elements array.
+  // If we find a top level empty element, also move make
+  // an element for that.
+  for (let i = 0; i < nodesLength; i++) {
+    const node = nodes[i];
+    let parent = node.getParent();
+    if (parent !== null && parent.isInline()) {
+      parent = parent.getParent();
+    }
+    if (parent !== null && $isLeafNode(node) && !movedNodes.has(node.getKey())) {
+      const parentKey = parent.getKey();
+      if (elementMapping.get(parentKey) === undefined) {
+        const targetElement = createElement();
+        targetElement.setFormat(parent.getFormatType());
+        targetElement.setIndent(parent.getIndent());
+        elements.push(targetElement);
+        elementMapping.set(parentKey, targetElement);
+        // Move node and its siblings to the new
+        // element.
+        parent.getChildren().forEach(child => {
+          targetElement.append(child);
+          movedNodes.add(child.getKey());
+          if ($isElementNode(child)) {
+            // Skip nested leaf nodes if the parent has already been moved
+            child.getChildrenKeys().forEach(key => movedNodes.add(key));
+          }
+        });
+        $removeParentEmptyElements(parent);
+      }
+    } else if (emptyElements.has(node.getKey())) {
+      if (!$isElementNode(node)) {
+        throw Error(`Expected node in emptyElements to be an ElementNode`);
+      }
+      const targetElement = createElement();
+      targetElement.setFormat(node.getFormatType());
+      targetElement.setIndent(node.getIndent());
+      elements.push(targetElement);
+      node.remove(true);
+    }
+  }
+  if (wrappingElement !== null) {
+    for (let i = 0; i < elements.length; i++) {
+      const element = elements[i];
+      wrappingElement.append(element);
+    }
+  }
+  let lastElement = null;
+
+  // If our target is Root-like, let's see if we can re-adjust
+  // so that the target is the first child instead.
+  if ($isRootOrShadowRoot(target)) {
+    if (targetIsPrevSibling) {
+      if (wrappingElement !== null) {
+        target.insertAfter(wrappingElement);
+      } else {
+        for (let i = elements.length - 1; i >= 0; i--) {
+          const element = elements[i];
+          target.insertAfter(element);
+        }
+      }
+    } else {
+      const firstChild = target.getFirstChild();
+      if ($isElementNode(firstChild)) {
+        target = firstChild;
+      }
+      if (firstChild === null) {
+        if (wrappingElement) {
+          target.append(wrappingElement);
+        } else {
+          for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            target.append(element);
+            lastElement = element;
+          }
+        }
+      } else {
+        if (wrappingElement !== null) {
+          firstChild.insertBefore(wrappingElement);
+        } else {
+          for (let i = 0; i < elements.length; i++) {
+            const element = elements[i];
+            firstChild.insertBefore(element);
+            lastElement = element;
+          }
+        }
+      }
+    }
+  } else {
+    if (wrappingElement) {
+      target.insertAfter(wrappingElement);
+    } else {
+      for (let i = elements.length - 1; i >= 0; i--) {
+        const element = elements[i];
+        target.insertAfter(element);
+        lastElement = element;
+      }
+    }
+  }
+  const prevSelection = $getPreviousSelection();
+  if ($isRangeSelection(prevSelection) && isPointAttached(prevSelection.anchor) && isPointAttached(prevSelection.focus)) {
+    $setSelection(prevSelection.clone());
+  } else if (lastElement !== null) {
+    lastElement.selectEnd();
+  } else {
+    selection.dirty = true;
+  }
+}
+
+/**
+ * Determines if the default character selection should be overridden. Used with DecoratorNodes
+ * @param selection - The selection whose default character selection may need to be overridden.
+ * @param isBackward - Is the selection backwards (the focus comes before the anchor)?
+ * @returns true if it should be overridden, false if not.
+ */
+function $shouldOverrideDefaultCharacterSelection(selection, isBackward) {
+  const possibleNode = $getAdjacentNode(selection.focus, isBackward);
+  return $isDecoratorNode(possibleNode) && !possibleNode.isIsolated() || $isElementNode(possibleNode) && !possibleNode.isInline() && !possibleNode.canBeEmpty();
+}
+
+/**
+ * Moves the selection according to the arguments.
+ * @param selection - The selected text or nodes.
+ * @param isHoldingShift - Is the shift key being held down during the operation.
+ * @param isBackward - Is the selection selected backwards (the focus comes before the anchor)?
+ * @param granularity - The distance to adjust the current selection.
+ */
+function $moveCaretSelection(selection, isHoldingShift, isBackward, granularity) {
+  selection.modify(isHoldingShift ? 'extend' : 'move', isBackward, granularity);
+}
+
+/**
+ * Tests a parent element for right to left direction.
+ * @param selection - The selection whose parent is to be tested.
+ * @returns true if the selections' parent element has a direction of 'rtl' (right to left), false otherwise.
+ */
+function $isParentElementRTL(selection) {
+  const anchorNode = selection.anchor.getNode();
+  const parent = $isRootNode(anchorNode) ? anchorNode : anchorNode.getParentOrThrow();
+  return parent.getDirection() === 'rtl';
+}
+
+/**
+ * Moves selection by character according to arguments.
+ * @param selection - The selection of the characters to move.
+ * @param isHoldingShift - Is the shift key being held down during the operation.
+ * @param isBackward - Is the selection backward (the focus comes before the anchor)?
+ */
+function $moveCharacter(selection, isHoldingShift, isBackward) {
+  const isRTL = $isParentElementRTL(selection);
+  $moveCaretSelection(selection, isHoldingShift, isBackward ? !isRTL : isRTL, 'character');
+}
+
+/**
+ * Expands the current Selection to cover all of the content in the editor.
+ * @param selection - The current selection.
+ */
+function $selectAll(selection) {
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const anchorNode = anchor.getNode();
+  const topParent = anchorNode.getTopLevelElementOrThrow();
+  const root = topParent.getParentOrThrow();
+  let firstNode = root.getFirstDescendant();
+  let lastNode = root.getLastDescendant();
+  let firstType = 'element';
+  let lastType = 'element';
+  let lastOffset = 0;
+  if ($isTextNode(firstNode)) {
+    firstType = 'text';
+  } else if (!$isElementNode(firstNode) && firstNode !== null) {
+    firstNode = firstNode.getParentOrThrow();
+  }
+  if ($isTextNode(lastNode)) {
+    lastType = 'text';
+    lastOffset = lastNode.getTextContentSize();
+  } else if (!$isElementNode(lastNode) && lastNode !== null) {
+    lastNode = lastNode.getParentOrThrow();
+  }
+  if (firstNode && lastNode) {
+    anchor.set(firstNode.getKey(), 0, firstType);
+    focus.set(lastNode.getKey(), lastOffset, lastType);
+  }
+}
+
+/**
+ * Returns the current value of a CSS property for Nodes, if set. If not set, it returns the defaultValue.
+ * @param node - The node whose style value to get.
+ * @param styleProperty - The CSS style property.
+ * @param defaultValue - The default value for the property.
+ * @returns The value of the property for node.
+ */
+function $getNodeStyleValueForProperty(node, styleProperty, defaultValue) {
+  const css = node.getStyle();
+  const styleObject = getStyleObjectFromCSS(css);
+  if (styleObject !== null) {
+    return styleObject[styleProperty] || defaultValue;
+  }
+  return defaultValue;
+}
+
+/**
+ * Returns the current value of a CSS property for TextNodes in the Selection, if set. If not set, it returns the defaultValue.
+ * If all TextNodes do not have the same value, it returns an empty string.
+ * @param selection - The selection of TextNodes whose value to find.
+ * @param styleProperty - The CSS style property.
+ * @param defaultValue - The default value for the property, defaults to an empty string.
+ * @returns The value of the property for the selected TextNodes.
+ */
+function $getSelectionStyleValueForProperty(selection, styleProperty, defaultValue = '') {
+  let styleValue = null;
+  const nodes = selection.getNodes();
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const isBackward = selection.isBackward();
+  const endOffset = isBackward ? focus.offset : anchor.offset;
+  const endNode = isBackward ? focus.getNode() : anchor.getNode();
+  if (selection.isCollapsed() && selection.style !== '') {
+    const css = selection.style;
+    const styleObject = getStyleObjectFromCSS(css);
+    if (styleObject !== null && styleProperty in styleObject) {
+      return styleObject[styleProperty];
+    }
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+
+    // if no actual characters in the end node are selected, we don't
+    // include it in the selection for purposes of determining style
+    // value
+    if (i !== 0 && endOffset === 0 && node.is(endNode)) {
+      continue;
+    }
+    if ($isTextNode(node)) {
+      const nodeStyleValue = $getNodeStyleValueForProperty(node, styleProperty, defaultValue);
+      if (styleValue === null) {
+        styleValue = nodeStyleValue;
+      } else if (styleValue !== nodeStyleValue) {
+        // multiple text nodes are in the selection and they don't all
+        // have the same style.
+        styleValue = '';
+        break;
+      }
+    }
+  }
+  return styleValue === null ? defaultValue : styleValue;
+}
+
+/**
+ * This function is for internal use of the library.
+ * Please do not use it as it may change in the future.
+ */
+function INTERNAL_$isBlock(node) {
+  if ($isDecoratorNode(node)) {
+    return false;
+  }
+  if (!$isElementNode(node) || $isRootOrShadowRoot(node)) {
+    return false;
+  }
+  const firstChild = node.getFirstChild();
+  const isLeafElement = firstChild === null || $isLineBreakNode(firstChild) || $isTextNode(firstChild) || firstChild.isInline();
+  return !node.isInline() && node.canBeEmpty() !== false && isLeafElement;
+}
+function $getAncestor(node, predicate) {
+  let parent = node;
+  while (parent !== null && parent.getParent() !== null && !predicate(parent)) {
+    parent = parent.getParentOrThrow();
+  }
+  return predicate(parent) ? parent : null;
+}
+
+export { $addNodeStyle, $cloneWithProperties, $getSelectionStyleValueForProperty, $isAtNodeEnd, $isParentElementRTL, $moveCaretSelection, $moveCharacter, $patchStyleText, $selectAll, $setBlocksType, $shouldOverrideDefaultCharacterSelection, $sliceSelectedTextNodeContent, $wrapNodes, createDOMRange, createRectsFromDOMRange, getStyleObjectFromCSS, trimTextContentFromAnchor };

package/LexicalSelection.esm.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import * as modDev from './LexicalSelection.dev.esm.js';
+import * as modProd from './LexicalSelection.prod.esm.js';
+const mod = process.env.NODE_ENV === 'development' ? modDev : modProd;
+export const $addNodeStyle = mod.$addNodeStyle;
+export const $cloneWithProperties = mod.$cloneWithProperties;
+export const $getSelectionStyleValueForProperty = mod.$getSelectionStyleValueForProperty;
+export const $isAtNodeEnd = mod.$isAtNodeEnd;
+export const $isParentElementRTL = mod.$isParentElementRTL;
+export const $moveCaretSelection = mod.$moveCaretSelection;
+export const $moveCharacter = mod.$moveCharacter;
+export const $patchStyleText = mod.$patchStyleText;
+export const $selectAll = mod.$selectAll;
+export const $setBlocksType = mod.$setBlocksType;
+export const $shouldOverrideDefaultCharacterSelection = mod.$shouldOverrideDefaultCharacterSelection;
+export const $sliceSelectedTextNodeContent = mod.$sliceSelectedTextNodeContent;
+export const $wrapNodes = mod.$wrapNodes;
+export const createDOMRange = mod.createDOMRange;
+export const createRectsFromDOMRange = mod.createRectsFromDOMRange;
+export const getStyleObjectFromCSS = mod.getStyleObjectFromCSS;
+export const trimTextContentFromAnchor = mod.trimTextContentFromAnchor;

package/LexicalSelection.js

@@ -5,5 +5,5 @@
  * LICENSE file in the root directory of this source tree.
  */
 'use strict'
-const LexicalSelection = process.env.NODE_ENV === 'development' ? require('./LexicalSelection.dev.js') : require('./LexicalSelection.prod.js')
+const LexicalSelection = process.env.NODE_ENV === 'development' ? require('./LexicalSelection.dev.js') : require('./LexicalSelection.prod.js');
 module.exports = LexicalSelection;

package/LexicalSelection.prod.esm.js

@@ -0,0 +1,7 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+import{$isTextNode as e,$isElementNode as t,$getCharacterOffsets as n,$isRootNode as o,$getNodeByKey as l,$getPreviousSelection as r,$createTextNode as s,$isRangeSelection as i,$getRoot as c,$isRootOrShadowRoot as f,$hasAncestor as u,$isLeafNode as g,$setSelection as a,$getAdjacentNode as d,$isDecoratorNode as p,$isLineBreakNode as h}from"lexical";const m=new Map;function _(e){let t=e;for(;null!=t;){if(t.nodeType===Node.TEXT_NODE)return t;t=t.firstChild}return null}function y(e){const t=e.parentNode;if(null==t)throw new Error("Should never happen");return[t,Array.from(t.childNodes).indexOf(e)]}function T(t,n,o,l,r){const s=n.getKey(),i=l.getKey(),c=document.createRange();let f=t.getElementByKey(s),u=t.getElementByKey(i),g=o,a=r;if(e(n)&&(f=_(f)),e(l)&&(u=_(u)),void 0===n||void 0===l||null===f||null===u)return null;"BR"===f.nodeName&&([f,g]=y(f)),"BR"===u.nodeName&&([u,a]=y(u));const d=f.firstChild;f===u&&null!=d&&"BR"===d.nodeName&&0===g&&0===a&&(a=1);try{c.setStart(f,g),c.setEnd(u,a)}catch(e){return null}return!c.collapsed||g===a&&s===i||(c.setStart(u,a),c.setEnd(f,g)),c}function x(e,t){const n=e.getRootElement();if(null===n)return[];const o=n.getBoundingClientRect(),l=getComputedStyle(n),r=parseFloat(l.paddingLeft)+parseFloat(l.paddingRight),s=Array.from(t.getClientRects());let i,c=s.length;s.sort(((e,t)=>{const n=e.top-t.top;return Math.abs(n)<=3?e.left-t.left:n}));for(let e=0;e<c;e++){const t=s[e],n=i&&i.top<=t.top&&i.top+i.height>t.top&&i.left+i.width>t.left,l=t.width+r===o.width;n||l?(s.splice(e--,1),c--):i=t}return s}function S(e){const t={},n=e.split(";");for(const e of n)if(""!==e){const[n,o]=e.split(/:([^]+)/);n&&o&&(t[n.trim()]=o.trim())}return t}function N(e){let t=m.get(e);return void 0===t&&(t=S(e),m.set(e,t)),t}function E(n){const o=n.constructor.clone(n);return o.__parent=n.__parent,o.__next=n.__next,o.__prev=n.__prev,t(n)&&t(o)?(r=n,(l=o).__first=r.__first,l.__last=r.__last,l.__size=r.__size,l.__format=r.__format,l.__indent=r.__indent,l.__dir=r.__dir,l):e(n)&&e(o)?function(e,t){return e.__format=t.__format,e.__style=t.__style,e.__mode=t.__mode,e.__detail=t.__detail,e}(o,n):o;var l,r}function v(e,t){const o=e.getStartEndPoints();if(t.isSelected(e)&&!t.isSegmented()&&!t.isToken()&&null!==o){const[l,r]=o,s=e.isBackward(),i=l.getNode(),c=r.getNode(),f=t.is(i),u=t.is(c);if(f||u){const[o,l]=n(e),r=i.is(c),f=t.is(s?c:i),u=t.is(s?i:c);let g,a=0;if(r)a=o>l?l:o,g=o>l?o:l;else if(f){a=s?l:o,g=void 0}else if(u){a=0,g=s?o:l}return t.__text=t.__text.slice(a,g),t}}return t}function C(e){if("text"===e.type)return e.offset===e.getNode().getTextContentSize();const n=e.getNode();if(!t(n))throw Error("isAtNodeEnd: node must be a TextNode or ElementNode");return e.offset===n.getChildrenSize()}function w(n,c,f){let u=c.getNode(),g=f;if(t(u)){const e=u.getDescendantByIndex(c.offset);null!==e&&(u=e)}for(;g>0&&null!==u;){if(t(u)){const e=u.getLastDescendant();null!==e&&(u=e)}let f=u.getPreviousSibling(),a=0;if(null===f){let e=u.getParentOrThrow(),t=e.getPreviousSibling();for(;null===t;){if(e=e.getParent(),null===e){f=null;break}t=e.getPreviousSibling()}null!==e&&(a=e.isInline()?0:2,f=t)}let d=u.getTextContent();""===d&&t(u)&&!u.isInline()&&(d="\n\n");const p=d.length;if(!e(u)||g>=p){const e=u.getParent();u.remove(),null==e||0!==e.getChildrenSize()||o(e)||e.remove(),g-=p+a,u=f}else{const t=u.getKey(),o=n.getEditorState().read((()=>{const n=l(t);return e(n)&&n.isSimpleText()?n.getTextContent():null})),f=p-g,a=d.slice(0,f);if(null!==o&&o!==d){const e=r();let t=u;if(u.isSimpleText())u.setTextContent(o);else{const e=s(o);u.replace(e),t=e}if(i(e)&&e.isCollapsed()){const n=e.anchor.offset;t.select(n,n)}}else if(u.isSimpleText()){const e=c.key===t;let n=c.offset;n<g&&(n=p);const o=e?n-g:0,l=e?n:f;if(e&&0===o){const[e]=u.splitText(o,l);e.remove()}else{const[,e]=u.splitText(o,l);e.remove()}}else{const e=s(a);u.replace(e)}g=0}}}function P(e){const t=e.getStyle(),n=S(t);m.set(t,n)}function F(e,t){const n=N("getStyle"in e?e.getStyle():e.style),o=Object.entries(t).reduce(((e,[t,o])=>(o instanceof Function?e[t]=o(n[t]):null===o?delete e[t]:e[t]=o,e)),{...n}||{}),l=function(e){let t="";for(const n in e)n&&(t+=`${n}: ${e[n]};`);return t}(o);e.setStyle(l),m.set(l,o)}function I(t,n){const o=t.getNodes(),l=o.length,r=t.getStartEndPoints();if(null===r)return;const[s,c]=r,f=l-1;let u=o[0],g=o[f];if(t.isCollapsed()&&i(t))return void F(t,n);const a=u.getTextContent().length,d=c.offset;let p=s.offset;const h=s.isBefore(c);let m=h?p:d,_=h?d:p;const y=h?s.type:c.type,T=h?c.type:s.type,x=h?c.key:s.key;if(e(u)&&m===a){const t=u.getNextSibling();e(t)&&(p=0,m=0,u=t)}if(1===o.length){if(e(u)&&u.canHaveFormat()){if(m="element"===y?0:p>d?d:p,_="element"===T?a:p>d?p:d,m===_)return;if(0===m&&_===a)F(u,n),u.select(m,_);else{const e=u.splitText(m,_),t=0===m?e[0]:e[1];F(t,n),t.select(0,_-m)}}}else{if(e(u)&&m<u.getTextContentSize()&&u.canHaveFormat()&&(0!==m&&(u=u.splitText(m)[1],m=0,s.set(u.getKey(),m,"text")),F(u,n)),e(g)&&g.canHaveFormat()){const e=g.getTextContent().length;g.__key!==x&&0!==_&&(_=e),_!==e&&([g]=g.splitText(_)),0===_&&"element"!==T||F(g,n)}for(let t=1;t<f;t++){const l=o[t],r=l.getKey();e(l)&&l.canHaveFormat()&&r!==u.getKey()&&r!==g.getKey()&&!l.isToken()&&F(l,n)}}}function K(e,n){if(null===e)return;const o=e.getStartEndPoints(),l=o?o[0]:null;if(null!==l&&"root"===l.key){const e=n(),t=c(),o=t.getFirstChild();return void(o?o.replace(e,!0):t.append(e))}const r=e.getNodes(),s=null!==l&&function(e,t){let n=e;for(;null!==n&&null!==n.getParent()&&!t(n);)n=n.getParentOrThrow();return t(n)?n:null}(l.getNode(),$);s&&-1===r.indexOf(s)&&r.push(s);for(let e=0;e<r.length;e++){const o=r[e];if(!$(o))continue;if(!t(o))throw Error("Expected block node to be an ElementNode");const l=n();l.setFormat(o.getFormatType()),l.setIndent(o.getIndent()),o.replace(l,!0)}}function b(e){return e.getNode().isAttached()}function O(e){let t=e;for(;null!==t&&!f(t);){const e=t.getLatest(),n=t.getParent();0===e.getChildrenSize()&&t.remove(!0),t=n}}function k(e,t,n=null){const o=e.getStartEndPoints(),l=o?o[0]:null,r=e.getNodes(),s=r.length;if(null!==l&&(0===s||1===s&&"element"===l.type&&0===l.getNode().getChildrenSize())){const e="text"===l.type?l.getNode().getParentOrThrow():l.getNode(),o=e.getChildren();let r=t();return r.setFormat(e.getFormatType()),r.setIndent(e.getIndent()),o.forEach((e=>r.append(e))),n&&(r=n.append(r)),void e.replace(r)}let i=null,c=[];for(let o=0;o<s;o++){const l=r[o];f(l)?(B(e,c,c.length,t,n),c=[],i=l):null===i||null!==i&&u(l,i)?c.push(l):(B(e,c,c.length,t,n),c=[l])}B(e,c,c.length,t,n)}function B(e,n,o,l,s=null){if(0===n.length)return;const c=n[0],u=new Map,d=[];let p=t(c)?c:c.getParentOrThrow();p.isInline()&&(p=p.getParentOrThrow());let h=!1;for(;null!==p;){const e=p.getPreviousSibling();if(null!==e){p=e,h=!0;break}if(p=p.getParentOrThrow(),f(p))break}const m=new Set;for(let e=0;e<o;e++){const o=n[e];t(o)&&0===o.getChildrenSize()&&m.add(o.getKey())}const _=new Set;for(let e=0;e<o;e++){const o=n[e];let r=o.getParent();if(null!==r&&r.isInline()&&(r=r.getParent()),null!==r&&g(o)&&!_.has(o.getKey())){const e=r.getKey();if(void 0===u.get(e)){const n=l();n.setFormat(r.getFormatType()),n.setIndent(r.getIndent()),d.push(n),u.set(e,n),r.getChildren().forEach((e=>{n.append(e),_.add(e.getKey()),t(e)&&e.getChildrenKeys().forEach((e=>_.add(e)))})),O(r)}}else if(m.has(o.getKey())){if(!t(o))throw Error("Expected node in emptyElements to be an ElementNode");const e=l();e.setFormat(o.getFormatType()),e.setIndent(o.getIndent()),d.push(e),o.remove(!0)}}if(null!==s)for(let e=0;e<d.length;e++){const t=d[e];s.append(t)}let y=null;if(f(p))if(h)if(null!==s)p.insertAfter(s);else for(let e=d.length-1;e>=0;e--){const t=d[e];p.insertAfter(t)}else{const e=p.getFirstChild();if(t(e)&&(p=e),null===e)if(s)p.append(s);else for(let e=0;e<d.length;e++){const t=d[e];p.append(t),y=t}else if(null!==s)e.insertBefore(s);else for(let t=0;t<d.length;t++){const n=d[t];e.insertBefore(n),y=n}}else if(s)p.insertAfter(s);else for(let e=d.length-1;e>=0;e--){const t=d[e];p.insertAfter(t),y=t}const T=r();i(T)&&b(T.anchor)&&b(T.focus)?a(T.clone()):null!==y?y.selectEnd():e.dirty=!0}function z(e,n){const o=d(e.focus,n);return p(o)&&!o.isIsolated()||t(o)&&!o.isInline()&&!o.canBeEmpty()}function A(e,t,n,o){e.modify(t?"extend":"move",n,o)}function R(e){const t=e.anchor.getNode();return"rtl"===(o(t)?t:t.getParentOrThrow()).getDirection()}function D(e,t,n){const o=R(e);A(e,t,n?!o:o,"character")}function L(n){const o=n.anchor,l=n.focus,r=o.getNode().getTopLevelElementOrThrow().getParentOrThrow();let s=r.getFirstDescendant(),i=r.getLastDescendant(),c="element",f="element",u=0;e(s)?c="text":t(s)||null===s||(s=s.getParentOrThrow()),e(i)?(f="text",u=i.getTextContentSize()):t(i)||null===i||(i=i.getParentOrThrow()),s&&i&&(o.set(s.getKey(),0,c),l.set(i.getKey(),u,f))}function H(e,t,n){const o=N(e.getStyle());return null!==o&&o[t]||n}function M(t,n,o=""){let l=null;const r=t.getNodes(),s=t.anchor,i=t.focus,c=t.isBackward(),f=c?i.offset:s.offset,u=c?i.getNode():s.getNode();if(t.isCollapsed()&&""!==t.style){const e=N(t.style);if(null!==e&&n in e)return e[n]}for(let t=0;t<r.length;t++){const s=r[t];if((0===t||0!==f||!s.is(u))&&e(s)){const e=H(s,n,o);if(null===l)l=e;else if(l!==e){l="";break}}}return null===l?o:l}function $(n){if(p(n))return!1;if(!t(n)||f(n))return!1;const o=n.getFirstChild(),l=null===o||h(o)||e(o)||o.isInline();return!n.isInline()&&!1!==n.canBeEmpty()&&l}export{P as $addNodeStyle,E as $cloneWithProperties,M as $getSelectionStyleValueForProperty,C as $isAtNodeEnd,R as $isParentElementRTL,A as $moveCaretSelection,D as $moveCharacter,I as $patchStyleText,L as $selectAll,K as $setBlocksType,z as $shouldOverrideDefaultCharacterSelection,v as $sliceSelectedTextNodeContent,k as $wrapNodes,T as createDOMRange,x as createRectsFromDOMRange,N as getStyleObjectFromCSS,w as trimTextContentFromAnchor};

package/README.md

@@ -1,112 +1,5 @@
 # `@lexical/selection`
 
-This package contains selection helpers for Lexical.
-
-### Methods
-
-#### `getStyleObjectFromCSS`
-
-Given a CSS string, returns an object from the style cache.
-
-```ts
-export function getStyleObjectFromCSS(css: string): {
-  [key: string]: string;
-} | null;
-```
-
-#### `$patchStyleText`
-
-Applies the provided styles to the TextNodes in the provided Selection. Key names in the patch argument should be
-the valid CSS properties (i.e., kebab-case).
-
-```ts
-export function $patchStyleText(
-  selection: BaseSelection,
-  patch: {
-    [key: string]: string;
-  },
-): void;
-```
-
-#### `$getSelectionStyleValueForProperty`
-
-Given a selection and a valid CSS property name, returns the current value of that property for TextNodes in the Selection, if set. If not set, it returns the defaultValue. If all TextNodes do not have the same value, it returns an empty string.
-
-```ts
-export function $getSelectionStyleValueForProperty(
-  selection: RangeSelection,
-  styleProperty: string,
-  defaultValue: string,
-): string;
-```
-
-#### `$moveCaretSelection`
-
-Moves the selection according to the arguments.
-
-```ts
-export function $moveCaretSelection(
-  selection: RangeSelection,
-  isHoldingShift: boolean,
-  isBackward: boolean,
-  granularity: 'character' | 'word' | 'lineboundary',
-): void;
-```
-
-#### `$isParentElementRTL`
-
-Returns true if the parent of the Selection anchor node is in Right-To-Left mode, false if not.
+[![See API Documentation](https://lexical.dev/img/see-api-documentation.svg)](https://lexical.dev/docs/api/modules/lexical_selection)
 
-```ts
-export function $isParentElementRTL(selection: RangeSelection): boolean;
-```
-
-#### `$moveCharacter`
-
-Wraps $moveCaretSelection, using character granularity and accounting for RTL mode.
-
-```ts
-export function $moveCharacter(
-  selection: RangeSelection,
-  isHoldingShift: boolean,
-  isBackward: boolean,
-): void;
-```
-
-#### `$selectAll`
-
-Expands the current Selection to cover all of the content in the editor.
-
-```ts
-export function $selectAll(selection: RangeSelection): void;
-```
-
-#### `$setBlocksType`
-
-Converts all nodes in the selection that are of one block type to another specified by parameter
-
-```ts
-export function $setBlocksType(
-  selection: RangeSelection,
-  createElement: () => ElementNode,
-): void;
-```
-
-#### `$isAtNodeEnd`
-
-Returns true if the provided point offset is in the last possible position.
-
-```ts
-export function $isAtNodeEnd(point: Point): boolean;
-```
-
-#### `$shouldOverrideDefaultCharacterSelection`
-
-Returns true if default character selection should be overridden, false if not. Used with DecoratorNodes
-
-```ts
-export function $shouldOverrideDefaultCharacterSelection(
-  selection: RangeSelection,
-  isBackward: boolean,
-): boolean;
-```
+This package contains selection helpers for Lexical.

package/package.json

@@ -9,14 +9,16 @@
     "selection"
   ],
   "license": "MIT",
-  "version": "0.13.1",
+  "version": "0.14.1",
   "main": "LexicalSelection.js",
   "peerDependencies": {
-    "lexical": "0.13.1"
+    "lexical": "0.14.1"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/lexical",
     "directory": "packages/lexical-selection"
-  }
+  },
+  "module": "LexicalSelection.esm.js",
+  "sideEffects": false
 }