@lexical/selection 0.1.15

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Dominic Gannaway
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/LexicalSelection.dev.js

@@ -0,0 +1,579 @@
+/**
+ * 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.
+ */
+'use strict';
+
+var lexical = require('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 cssToStyles = new Map();
+
+function $cloneWithProperties(node) {
+  const latest = node.getLatest();
+  const constructor = latest.constructor;
+  const clone = constructor.clone(latest);
+  clone.__parent = latest.__parent;
+
+  if (lexical.$isElementNode(latest) && lexical.$isElementNode(clone)) {
+    clone.__children = Array.from(latest.__children);
+    clone.__format = latest.__format;
+    clone.__indent = latest.__indent;
+    clone.__dir = latest.__dir;
+  } else if (lexical.$isTextNode(latest) && lexical.$isTextNode(clone)) {
+    clone.__format = latest.__format;
+    clone.__style = latest.__style;
+    clone.__mode = latest.__mode;
+    clone.__detail = latest.__detail;
+  } else if (lexical.$isDecoratorNode(latest) && lexical.$isDecoratorNode(clone)) {
+    clone.__state = latest.__state;
+  } // $FlowFixMe
+
+
+  return clone;
+}
+
+function $getIndexFromPossibleClone(node, parent, nodeMap) {
+  const parentClone = nodeMap.get(parent.getKey());
+
+  if (lexical.$isElementNode(parentClone)) {
+    return parentClone.__children.indexOf(node.getKey());
+  }
+
+  return node.getIndexWithinParent();
+}
+
+function $getParentAvoidingExcludedElements(node) {
+  let parent = node.getParent();
+
+  while (parent !== null && parent.excludeFromCopy()) {
+    parent = parent.getParent();
+  }
+
+  return parent;
+}
+
+function $copyLeafNodeBranchToRoot(leaf, startingOffset, isLeftSide, range, nodeMap) {
+  let node = leaf;
+  let offset = startingOffset;
+
+  while (node !== null) {
+    const parent = $getParentAvoidingExcludedElements(node);
+
+    if (parent === null) {
+      break;
+    }
+
+    if (!lexical.$isElementNode(node) || !node.excludeFromCopy()) {
+      const key = node.getKey();
+      let clone = nodeMap.get(key);
+      const needsClone = clone === undefined;
+
+      if (needsClone) {
+        clone = $cloneWithProperties(node);
+        nodeMap.set(key, clone);
+      }
+
+      if (lexical.$isTextNode(clone) && !clone.isSegmented() && !clone.isToken()) {
+        clone.__text = clone.__text.slice(isLeftSide ? offset : 0, isLeftSide ? undefined : offset);
+      } else if (lexical.$isElementNode(clone)) {
+        clone.__children = clone.__children.slice(isLeftSide ? offset : 0, isLeftSide ? undefined : offset + 1);
+      }
+
+      if (lexical.$isRootNode(parent)) {
+        if (needsClone) {
+          // We only want to collect a range of top level nodes.
+          // So if the parent is the root, we know this is a top level.
+          range.push(key);
+        }
+
+        break;
+      }
+    }
+
+    offset = $getIndexFromPossibleClone(node, parent, nodeMap);
+    node = parent;
+  }
+}
+
+function $cloneContents(selection) {
+  if (!lexical.$isRangeSelection(selection)) {
+    {
+      throw Error(`TODO`);
+    }
+  }
+
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const anchorOffset = anchor.getCharacterOffset();
+  const focusOffset = focus.getCharacterOffset();
+  const anchorNode = anchor.getNode();
+  const focusNode = focus.getNode();
+  const anchorNodeParent = anchorNode.getParentOrThrow(); // Handle a single text node extraction
+
+  if (anchorNode === focusNode && lexical.$isTextNode(anchorNode) && (anchorNodeParent.canBeEmpty() || anchorNodeParent.getChildrenSize() > 1)) {
+    const clonedFirstNode = $cloneWithProperties(anchorNode);
+    const isBefore = focusOffset > anchorOffset;
+    const startOffset = isBefore ? anchorOffset : focusOffset;
+    const endOffset = isBefore ? focusOffset : anchorOffset;
+    clonedFirstNode.__text = clonedFirstNode.__text.slice(startOffset, endOffset);
+    const key = clonedFirstNode.getKey();
+    return {
+      nodeMap: [[key, clonedFirstNode]],
+      range: [key]
+    };
+  }
+
+  const nodes = selection.getNodes();
+
+  if (nodes.length === 0) {
+    return {
+      nodeMap: [],
+      range: []
+    };
+  } // Check if we can use the parent of the nodes, if the
+  // parent can't be empty, then it's important that we
+  // also copy that element node along with its children.
+
+
+  let nodesLength = nodes.length;
+  const firstNode = nodes[0];
+  const firstNodeParent = firstNode.getParent();
+
+  if (firstNodeParent !== null && (!firstNodeParent.canBeEmpty() || lexical.$isRootNode(firstNodeParent))) {
+    const parentChildren = firstNodeParent.__children;
+    const parentChildrenLength = parentChildren.length;
+
+    if (parentChildrenLength === nodesLength) {
+      let areTheSame = true;
+
+      for (let i = 0; i < parentChildren.length; i++) {
+        if (parentChildren[i] !== nodes[i].__key) {
+          areTheSame = false;
+          break;
+        }
+      }
+
+      if (areTheSame) {
+        nodesLength++;
+        nodes.push(firstNodeParent);
+      }
+    }
+  }
+
+  const lastNode = nodes[nodesLength - 1];
+  const isBefore = anchor.isBefore(focus);
+  const nodeMap = new Map();
+  const range = []; // Do first node to root
+
+  $copyLeafNodeBranchToRoot(firstNode, isBefore ? anchorOffset : focusOffset, true, range, nodeMap); // Copy all nodes between
+
+  for (let i = 0; i < nodesLength; i++) {
+    const node = nodes[i];
+    const key = node.getKey();
+
+    if (!nodeMap.has(key) && (!lexical.$isElementNode(node) || !node.excludeFromCopy())) {
+      const clone = $cloneWithProperties(node);
+
+      if (lexical.$isRootNode(node.getParent())) {
+        range.push(node.getKey());
+      }
+
+      nodeMap.set(key, clone);
+    }
+  } // Do last node to root
+
+
+  $copyLeafNodeBranchToRoot(lastNode, isBefore ? focusOffset : anchorOffset, false, range, nodeMap);
+  return {
+    nodeMap: Array.from(nodeMap.entries()),
+    range
+  };
+}
+function getStyleObjectFromCSS(css) {
+  return cssToStyles.get(css) || null;
+}
+
+function getCSSFromStyleObject(styles) {
+  let css = '';
+
+  for (const style in styles) {
+    if (style) {
+      css += `${style}: ${styles[style]};`;
+    }
+  }
+
+  return css;
+}
+
+function $patchNodeStyle(node, patch) {
+  const prevStyles = getStyleObjectFromCSS(node.getStyle());
+  const newStyles = prevStyles ? { ...prevStyles,
+    ...patch
+  } : patch;
+  const newCSSText = getCSSFromStyleObject(newStyles);
+  node.setStyle(newCSSText);
+  cssToStyles.set(newCSSText, newStyles);
+}
+
+function $patchStyleText(selection, patch) {
+  const selectedNodes = selection.getNodes();
+  const selectedNodesLength = selectedNodes.length;
+  const lastIndex = selectedNodesLength - 1;
+  let firstNode = selectedNodes[0];
+  let lastNode = selectedNodes[lastIndex];
+
+  if (selection.isCollapsed()) {
+    return;
+  }
+
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const firstNodeText = firstNode.getTextContent();
+  const firstNodeTextLength = firstNodeText.length;
+  const focusOffset = focus.offset;
+  let anchorOffset = anchor.offset;
+  let startOffset;
+  let endOffset;
+  const isBefore = anchor.isBefore(focus);
+  startOffset = isBefore ? anchorOffset : focusOffset;
+  endOffset = isBefore ? focusOffset : anchorOffset; // 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 (startOffset === firstNode.getTextContentSize()) {
+    const nextSibling = firstNode.getNextSibling();
+
+    if (lexical.$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 (firstNode.is(lastNode)) {
+    if (lexical.$isTextNode(firstNode)) {
+      startOffset = anchorOffset > focusOffset ? focusOffset : anchorOffset;
+      endOffset = 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) {
+        $patchNodeStyle(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];
+        $patchNodeStyle(replacement, patch);
+        replacement.select(0, endOffset - startOffset);
+      }
+    } // multiple nodes selected.
+
+  } else {
+    if (lexical.$isTextNode(firstNode)) {
+      if (startOffset !== 0) {
+        // the entire first node isn't selected, so split it
+        [, firstNode] = firstNode.splitText(startOffset);
+        startOffset = 0;
+      }
+
+      $patchNodeStyle(firstNode, patch);
+    }
+
+    if (lexical.$isTextNode(lastNode)) {
+      const lastNodeText = lastNode.getTextContent();
+      const lastNodeTextLength = lastNodeText.length; // if the entire last node isn't selected, split it
+
+      if (endOffset !== lastNodeTextLength) {
+        [lastNode] = lastNode.splitText(endOffset);
+      }
+
+      if (endOffset !== 0) {
+        $patchNodeStyle(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 (lexical.$isTextNode(selectedNode) && selectedNodeKey !== firstNode.getKey() && selectedNodeKey !== lastNode.getKey() && !selectedNode.isToken()) {
+        $patchNodeStyle(selectedNode, patch);
+      }
+    }
+  }
+}
+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();
+
+  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 (lexical.$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 font size.
+        styleValue = '';
+        break;
+      }
+    }
+  }
+
+  return styleValue === null ? defaultValue : styleValue;
+}
+
+function $getNodeStyleValueForProperty(node, styleProperty, defaultValue) {
+  const css = node.getStyle();
+  const styleObject = getStyleObjectFromCSS(css);
+
+  if (styleObject !== null) {
+    return styleObject[styleProperty] || defaultValue;
+  }
+
+  return defaultValue;
+}
+
+function $moveCaretSelection(selection, isHoldingShift, isBackward, granularity) {
+  selection.modify(isHoldingShift ? 'extend' : 'move', isBackward, granularity);
+}
+function $isParentElementRTL(selection) {
+  const anchorNode = selection.anchor.getNode();
+  const parent = lexical.$isRootNode(anchorNode) ? anchorNode : anchorNode.getParentOrThrow();
+  return parent.getDirection() === 'rtl';
+}
+function $moveCharacter(selection, isHoldingShift, isBackward) {
+  const isRTL = $isParentElementRTL(selection);
+  $moveCaretSelection(selection, isHoldingShift, isBackward ? !isRTL : isRTL, 'character');
+}
+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 (lexical.$isTextNode(firstNode)) {
+    firstType = 'text';
+  } else if (!lexical.$isElementNode(firstNode) && firstNode !== null) {
+    firstNode = firstNode.getParentOrThrow();
+  }
+
+  if (lexical.$isTextNode(lastNode)) {
+    lastType = 'text';
+    lastOffset = lastNode.getTextContentSize();
+  } else if (!lexical.$isElementNode(lastNode) && lastNode !== null) {
+    lastNode = lastNode.getParentOrThrow();
+    lastOffset = lastNode.getChildrenSize();
+  }
+
+  if (firstNode && lastNode) {
+    anchor.set(firstNode.getKey(), 0, firstType);
+    focus.set(lastNode.getKey(), lastOffset, lastType);
+  }
+}
+
+function $removeParentEmptyElements(startingNode) {
+  let node = startingNode;
+
+  while (node !== null && !lexical.$isRootNode(node)) {
+    const latest = node.getLatest();
+    const parentNode = node.getParent();
+
+    if (latest.__children.length === 0) {
+      node.remove();
+    }
+
+    node = parentNode;
+  }
+}
+
+function $wrapLeafNodesInElements(selection, createElement, wrappingElement) {
+  const nodes = selection.getNodes();
+  const nodesLength = nodes.length;
+
+  if (nodesLength === 0) {
+    const anchor = selection.anchor;
+    const target = anchor.type === 'text' ? anchor.getNode().getParentOrThrow() : anchor.getNode();
+    const children = target.getChildren();
+    let element = createElement();
+    children.forEach(child => element.append(child));
+
+    if (wrappingElement) {
+      element = wrappingElement.append(element);
+    }
+
+    target.replace(element);
+    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 = lexical.$isElementNode(firstNode) ? firstNode : firstNode.getParentOrThrow();
+
+  while (target !== null) {
+    const prevSibling = target.getPreviousSibling();
+
+    if (prevSibling !== null) {
+      target = prevSibling;
+      break;
+    }
+
+    target = target.getParentOrThrow();
+
+    if (lexical.$isRootNode(target)) {
+      break;
+    }
+  }
+
+  const emptyElements = new Set(); // Find any top level empty elements
+
+  for (let i = 0; i < nodesLength; i++) {
+    const node = nodes[i];
+
+    if (lexical.$isElementNode(node) && node.getChildrenSize() === 0) {
+      emptyElements.add(node.getKey());
+    }
+  }
+
+  const movedLeafNodes = 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];
+    const parent = node.getParent();
+
+    if (parent !== null && lexical.$isLeafNode(node) && !movedLeafNodes.has(node.getKey())) {
+      const parentKey = parent.getKey();
+
+      if (elementMapping.get(parentKey) === undefined) {
+        const targetElement = createElement();
+        elements.push(targetElement);
+        elementMapping.set(parentKey, targetElement); // Move node and its siblings to the new
+        // element.
+
+        parent.getChildren().forEach(child => {
+          targetElement.append(child);
+          movedLeafNodes.add(child.getKey());
+        });
+        $removeParentEmptyElements(parent);
+      }
+    } else if (emptyElements.has(node.getKey())) {
+      elements.push(createElement());
+      node.remove();
+    }
+  }
+
+  if (wrappingElement) {
+    for (let i = 0; i < elements.length; i++) {
+      const element = elements[i];
+      wrappingElement.append(element);
+    }
+  } // If our target is the root, let's see if we can re-adjust
+  // so that the target is the first child instead.
+
+
+  if (lexical.$isRootNode(target)) {
+    const firstChild = target.getFirstChild();
+
+    if (lexical.$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);
+        }
+      }
+    } else {
+      if (wrappingElement) {
+        firstChild.insertBefore(wrappingElement);
+      } else {
+        for (let i = 0; i < elements.length; i++) {
+          const element = elements[i];
+          firstChild.insertBefore(element);
+        }
+      }
+    }
+  } else {
+    if (wrappingElement) {
+      target.insertAfter(wrappingElement);
+    } else {
+      for (let i = elements.length - 1; i >= 0; i--) {
+        const element = elements[i];
+        target.insertAfter(element);
+      }
+    }
+  }
+
+  selection.dirty = true;
+}
+function $isAtNodeEnd(point) {
+  if (point.type === 'text') {
+    return point.offset === point.getNode().getTextContentSize();
+  }
+
+  return point.offset === point.getNode().getChildrenSize();
+}
+function $shouldOverrideDefaultCharacterSelection(selection, isBackward) {
+  const possibleNode = lexical.$getDecoratorNode(selection.focus, isBackward);
+  return lexical.$isDecoratorNode(possibleNode) && !possibleNode.isIsolated();
+}
+
+exports.$cloneContents = $cloneContents;
+exports.$getSelectionStyleValueForProperty = $getSelectionStyleValueForProperty;
+exports.$isAtNodeEnd = $isAtNodeEnd;
+exports.$isParentElementRTL = $isParentElementRTL;
+exports.$moveCaretSelection = $moveCaretSelection;
+exports.$moveCharacter = $moveCharacter;
+exports.$patchStyleText = $patchStyleText;
+exports.$selectAll = $selectAll;
+exports.$shouldOverrideDefaultCharacterSelection = $shouldOverrideDefaultCharacterSelection;
+exports.$wrapLeafNodesInElements = $wrapLeafNodesInElements;
+exports.getStyleObjectFromCSS = getStyleObjectFromCSS;

package/LexicalSelection.js

@@ -0,0 +1,9 @@
+/**
+ * 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.
+ */
+'use strict'
+const LexicalSelection = process.env.NODE_ENV === 'development' ? require('./LexicalSelection.dev.js') : require('./LexicalSelection.prod.js')
+module.exports = LexicalSelection;

package/LexicalSelection.prod.js

@@ -0,0 +1,21 @@
+/**
+ * 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.
+ */
+var k=require("lexical");const r=new Map;function v(a){a=a.getLatest();const c=a.constructor.clone(a);c.__parent=a.__parent;k.$isElementNode(a)&&k.$isElementNode(c)?(c.__children=Array.from(a.__children),c.__format=a.__format,c.__indent=a.__indent,c.__dir=a.__dir):k.$isTextNode(a)&&k.$isTextNode(c)?(c.__format=a.__format,c.__style=a.__style,c.__mode=a.__mode,c.__detail=a.__detail):k.$isDecoratorNode(a)&&k.$isDecoratorNode(c)&&(c.__state=a.__state);return c}
+function w(a,c,b,g,l){for(var e=c;null!==a;){for(c=a.getParent();null!==c&&c.excludeFromCopy();)c=c.getParent();if(null===c)break;if(!k.$isElementNode(a)||!a.excludeFromCopy()){const d=a.getKey();let f=l.get(d);const h=void 0===f;h&&(f=v(a),l.set(d,f));!k.$isTextNode(f)||f.isSegmented()||f.isToken()?k.$isElementNode(f)&&(f.__children=f.__children.slice(b?e:0,b?void 0:e+1)):f.__text=f.__text.slice(b?e:0,b?void 0:e);if(k.$isRootNode(c)){h&&g.push(d);break}}e=l.get(c.getKey());e=k.$isElementNode(e)?
+e.__children.indexOf(a.getKey()):a.getIndexWithinParent();a=c}}function x(a){return r.get(a)||null}function y(a,c){var b=x(a.getStyle());c=b?{...b,...c}:c;b="";for(g in c)g&&(b+=`${g}: ${c[g]};`);var g=b;a.setStyle(g);r.set(g,c)}function z(a,c,b,g){a.modify(c?"extend":"move",b,g)}function A(a){a=a.anchor.getNode();return"rtl"===(k.$isRootNode(a)?a:a.getParentOrThrow()).getDirection()}
+function B(a){for(;null!==a&&!k.$isRootNode(a);){const c=a.getLatest(),b=a.getParent();0===c.__children.length&&a.remove();a=b}}
+exports.$cloneContents=function(a){if(!k.$isRangeSelection(a))throw Error("Minified Lexical error #68; see codes.json for the full message or use the non-minified dev environment for full errors and additional helpful warnings.");var c=a.anchor,b=a.focus,g=c.getCharacterOffset();const l=b.getCharacterOffset();var e=c.getNode(),d=b.getNode(),f=e.getParentOrThrow();if(e===d&&k.$isTextNode(e)&&(f.canBeEmpty()||1<f.getChildrenSize()))return a=v(e),e=l>g,a.__text=a.__text.slice(e?g:l,e?l:g),g=a.getKey(),
+{nodeMap:[[g,a]],range:[g]};a=a.getNodes();if(0===a.length)return{nodeMap:[],range:[]};e=a.length;d=a[0];f=d.getParent();if(null!==f&&(!f.canBeEmpty()||k.$isRootNode(f))){var h=f.__children;if(h.length===e){var m=!0;for(var n=0;n<h.length;n++)if(h[n]!==a[n].__key){m=!1;break}m&&(e++,a.push(f))}}f=a[e-1];c=c.isBefore(b);b=new Map;h=[];w(d,c?g:l,!0,h,b);for(d=0;d<e;d++)if(m=a[d],n=m.getKey(),!(b.has(n)||k.$isElementNode(m)&&m.excludeFromCopy())){const t=v(m);k.$isRootNode(m.getParent())&&h.push(m.getKey());
+b.set(n,t)}w(f,c?l:g,!1,h,b);return{nodeMap:Array.from(b.entries()),range:h}};exports.$getSelectionStyleValueForProperty=function(a,c,b=""){let g=null;const l=a.getNodes();var e=a.anchor,d=a.focus,f=a.isBackward();a=f?d.offset:e.offset;e=f?d.getNode():e.getNode();for(d=0;d<l.length;d++){var h=l[d];if((0===d||0!==a||!h.is(e))&&k.$isTextNode(h)){f=c;var m=b;h=h.getStyle();h=x(h);f=null!==h?h[f]||m:m;if(null===g)g=f;else if(g!==f){g="";break}}}return null===g?b:g};
+exports.$isAtNodeEnd=function(a){return"text"===a.type?a.offset===a.getNode().getTextContentSize():a.offset===a.getNode().getChildrenSize()};exports.$isParentElementRTL=A;exports.$moveCaretSelection=z;exports.$moveCharacter=function(a,c,b){const g=A(a);z(a,c,b?!g:g,"character")};
+exports.$patchStyleText=function(a,c){var b=a.getNodes();const g=b.length-1;let l=b[0],e=b[g];if(!a.isCollapsed()){var d=a.anchor,f=a.focus;a=l.getTextContent().length;var h=f.offset,m=d.offset;d=(f=d.isBefore(f))?m:h;f=f?h:m;if(d===l.getTextContentSize()){const n=l.getNextSibling();k.$isTextNode(n)&&(d=m=0,l=n)}if(l.is(e))k.$isTextNode(l)&&(d=m>h?h:m,f=m>h?m:h,d!==f&&(0===d&&f===a?(y(l,c),l.select(d,f)):(b=l.splitText(d,f),b=0===d?b[0]:b[1],y(b,c),b.select(0,f-d))));else for(k.$isTextNode(l)&&(0!==
+d&&([,l]=l.splitText(d)),y(l,c)),k.$isTextNode(e)&&(a=e.getTextContent().length,f!==a&&([e]=e.splitText(f)),0!==f&&y(e,c)),a=1;a<g;a++)h=b[a],m=h.getKey(),k.$isTextNode(h)&&m!==l.getKey()&&m!==e.getKey()&&!h.isToken()&&y(h,c)}};
+exports.$selectAll=function(a){const c=a.anchor;a=a.focus;var b=c.getNode().getTopLevelElementOrThrow().getParentOrThrow();let g=b.getFirstDescendant();b=b.getLastDescendant();let l="element",e="element",d=0;k.$isTextNode(g)?l="text":k.$isElementNode(g)||null===g||(g=g.getParentOrThrow());k.$isTextNode(b)?(e="text",d=b.getTextContentSize()):k.$isElementNode(b)||null===b||(b=b.getParentOrThrow(),d=b.getChildrenSize());g&&b&&(c.set(g.getKey(),0,l),a.set(b.getKey(),d,e))};
+exports.$shouldOverrideDefaultCharacterSelection=function(a,c){a=k.$getDecoratorNode(a.focus,c);return k.$isDecoratorNode(a)&&!a.isIsolated()};
+exports.$wrapLeafNodesInElements=function(a,c,b){const g=a.getNodes(),l=g.length;if(0===l){a=a.anchor;a="text"===a.type?a.getNode().getParentOrThrow():a.getNode();var e=a.getChildren();let p=c();e.forEach(u=>p.append(u));b&&(p=b.append(p));a.replace(p)}else{var d=g[0],f=new Map;e=[];for(d=k.$isElementNode(d)?d:d.getParentOrThrow();null!==d;){var h=d.getPreviousSibling();if(null!==h){d=h;break}d=d.getParentOrThrow();if(k.$isRootNode(d))break}h=new Set;for(var m=0;m<l;m++){var n=g[m];k.$isElementNode(n)&&
+0===n.getChildrenSize()&&h.add(n.getKey())}var t=new Set;for(m=0;m<l;m++){var q=g[m];n=q.getParent();if(null!==n&&k.$isLeafNode(q)&&!t.has(q.getKey())){if(q=n.getKey(),void 0===f.get(q)){const p=c();e.push(p);f.set(q,p);n.getChildren().forEach(u=>{p.append(u);t.add(u.getKey())});B(n)}}else h.has(q.getKey())&&(e.push(c()),q.remove())}if(b)for(c=0;c<e.length;c++)b.append(e[c]);if(k.$isRootNode(d))if(c=d.getFirstChild(),k.$isElementNode(c)&&(d=c),null===c)if(b)d.append(b);else for(b=0;b<e.length;b++)d.append(e[b]);
+else if(b)c.insertBefore(b);else for(b=0;b<e.length;b++)c.insertBefore(e[b]);else if(b)d.insertAfter(b);else for(b=e.length-1;0<=b;b--)d.insertAfter(e[b]);a.dirty=!0}};exports.getStyleObjectFromCSS=x;

package/README.md

@@ -0,0 +1,3 @@
+# `@lexical/selection`
+
+This package contains utilities and helpers for handling Lexical selection.

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@lexical/selection",
+  "author": {
+    "name": "Dominic Gannaway",
+    "email": "dg@domgan.com"
+  },
+  "description": "This package contains utilities and helpers for handling Lexical selection.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "list",
+    "selection"
+  ],
+  "license": "MIT",
+  "version": "0.1.15",
+  "main": "LexicalSelection.js",
+  "peerDependencies": {
+    "lexical": "0.1.15"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-selection"
+  }
+}