@lexical/rich-text 0.8.1 → 0.9.1

package/LexicalRichText.dev.js

@@ -18,24 +18,26 @@ var lexical = require('lexical');
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function caretFromPoint(x, y) {
   if (typeof document.caretRangeFromPoint !== 'undefined') {
     const range = document.caretRangeFromPoint(x, y);
+
     if (range === null) {
       return null;
     }
+
     return {
       node: range.startContainer,
       offset: range.startOffset
-    };
-    // @ts-ignore
+    }; // @ts-ignore
   } else if (document.caretPositionFromPoint !== 'undefined') {
     // @ts-ignore FF - no types
     const range = document.caretPositionFromPoint(x, y);
+
     if (range === null) {
       return null;
     }
+
     return {
       node: range.offsetNode,
       offset: range.offset
@@ -53,7 +55,6 @@ function caretFromPoint(x, y) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 const CAN_USE_DOM = typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined';
 
 /**
@@ -68,39 +69,41 @@ CAN_USE_DOM && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
 CAN_USE_DOM && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
 const CAN_USE_BEFORE_INPUT = CAN_USE_DOM && 'InputEvent' in window && !documentMode ? 'getTargetRanges' in new window.InputEvent('input') : false;
 const IS_SAFARI = CAN_USE_DOM && /Version\/[\d.]+.*Safari/.test(navigator.userAgent);
-const IS_IOS = CAN_USE_DOM && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream;
-
-// Keep these in case we need to use them in the future.
+const IS_IOS = CAN_USE_DOM && /iPad|iPhone|iPod/.test(navigator.userAgent) && !window.MSStream; // Keep these in case we need to use them in the future.
 // export const IS_WINDOWS: boolean = CAN_USE_DOM && /Win/.test(navigator.platform);
-const IS_CHROME = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent);
-// export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
+
+const IS_CHROME = CAN_USE_DOM && /^(?=.*Chrome).*/i.test(navigator.userAgent); // export const canUseTextInputEvent: boolean = CAN_USE_DOM && 'TextEvent' in window && !documentMode;
 
 const IS_APPLE_WEBKIT = CAN_USE_DOM && /AppleWebKit\/[\d.]+/.test(navigator.userAgent) && !IS_CHROME;
 
 /** @module @lexical/rich-text */
 const DRAG_DROP_PASTE = lexical.createCommand('DRAG_DROP_PASTE_FILE');
+
 /** @noInheritDoc */
 class QuoteNode extends lexical.ElementNode {
   static getType() {
     return 'quote';
   }
+
   static clone(node) {
     return new QuoteNode(node.__key);
   }
+
   constructor(key) {
     super(key);
-  }
+  } // View
 
-  // View
 
   createDOM(config) {
     const element = document.createElement('blockquote');
     utils.addClassNamesToElement(element, config.theme.quote);
     return element;
   }
+
   updateDOM(prevNode, dom) {
     return false;
   }
+
   static importDOM() {
     return {
       blockquote: node => ({
@@ -109,6 +112,7 @@ class QuoteNode extends lexical.ElementNode {
       })
     };
   }
+
   static importJSON(serializedNode) {
     const node = $createQuoteNode();
     node.setFormat(serializedNode.format);
@@ -116,14 +120,13 @@ class QuoteNode extends lexical.ElementNode {
     node.setDirection(serializedNode.direction);
     return node;
   }
+
   exportJSON() {
-    return {
-      ...super.exportJSON(),
+    return { ...super.exportJSON(),
       type: 'quote'
     };
-  }
+  } // Mutation
 
-  // Mutation
 
   insertNewAfter(_, restoreSelection) {
     const newBlock = lexical.$createParagraphNode();
@@ -132,6 +135,7 @@ class QuoteNode extends lexical.ElementNode {
     this.insertAfter(newBlock, restoreSelection);
     return newBlock;
   }
+
   collapseAtStart() {
     const paragraph = lexical.$createParagraphNode();
     const children = this.getChildren();
@@ -139,6 +143,7 @@ class QuoteNode extends lexical.ElementNode {
     this.replace(paragraph);
     return true;
   }
+
 }
 function $createQuoteNode() {
   return lexical.$applyNodeReplacement(new QuoteNode());
@@ -146,40 +151,46 @@ function $createQuoteNode() {
 function $isQuoteNode(node) {
   return node instanceof QuoteNode;
 }
+
 /** @noInheritDoc */
 class HeadingNode extends lexical.ElementNode {
   /** @internal */
-
   static getType() {
     return 'heading';
   }
+
   static clone(node) {
     return new HeadingNode(node.__tag, node.__key);
   }
+
   constructor(tag, key) {
     super(key);
     this.__tag = tag;
   }
+
   getTag() {
     return this.__tag;
-  }
+  } // View
 
-  // View
 
   createDOM(config) {
     const tag = this.__tag;
     const element = document.createElement(tag);
     const theme = config.theme;
     const classNames = theme.heading;
+
     if (classNames !== undefined) {
       const className = classNames[tag];
       utils.addClassNamesToElement(element, className);
     }
+
     return element;
   }
+
   updateDOM(prevNode, dom) {
     return false;
   }
+
   static importDOM() {
     return {
       h1: node => ({
@@ -210,6 +221,7 @@ class HeadingNode extends lexical.ElementNode {
         // domNode is a <p> since we matched it by nodeName
         const paragraph = node;
         const firstChild = paragraph.firstChild;
+
         if (firstChild !== null && isGoogleDocsTitle(firstChild)) {
           return {
             conversion: () => ({
@@ -218,6 +230,7 @@ class HeadingNode extends lexical.ElementNode {
             priority: 3
           };
         }
+
         return null;
       },
       span: node => {
@@ -231,10 +244,12 @@ class HeadingNode extends lexical.ElementNode {
             priority: 3
           };
         }
+
         return null;
       }
     };
   }
+
   static importJSON(serializedNode) {
     const node = $createHeadingNode(serializedNode.tag);
     node.setFormat(serializedNode.format);
@@ -242,16 +257,16 @@ class HeadingNode extends lexical.ElementNode {
     node.setDirection(serializedNode.direction);
     return node;
   }
+
   exportJSON() {
-    return {
-      ...super.exportJSON(),
+    return { ...super.exportJSON(),
       tag: this.getTag(),
       type: 'heading',
       version: 1
     };
-  }
+  } // Mutation
+
 
-  // Mutation
   insertNewAfter(selection, restoreSelection = true) {
     const anchorOffet = selection ? selection.anchor.offset : 0;
     const newElement = anchorOffet > 0 && anchorOffet < this.getTextContentSize() ? $createHeadingNode(this.getTag()) : lexical.$createParagraphNode();
@@ -260,6 +275,7 @@ class HeadingNode extends lexical.ElementNode {
     this.insertAfter(newElement, restoreSelection);
     return newElement;
   }
+
   collapseAtStart() {
     const newElement = !this.isEmpty() ? $createHeadingNode(this.getTag()) : lexical.$createParagraphNode();
     const children = this.getChildren();
@@ -267,43 +283,54 @@ class HeadingNode extends lexical.ElementNode {
     this.replace(newElement);
     return true;
   }
+
   extractWithChild() {
     return true;
   }
+
 }
+
 function isGoogleDocsTitle(domNode) {
   if (domNode.nodeName.toLowerCase() === 'span') {
     return domNode.style.fontSize === '26pt';
   }
+
   return false;
 }
+
 function convertHeadingElement(domNode) {
   const nodeName = domNode.nodeName.toLowerCase();
   let node = null;
+
   if (nodeName === 'h1' || nodeName === 'h2' || nodeName === 'h3' || nodeName === 'h4' || nodeName === 'h5' || nodeName === 'h6') {
     node = $createHeadingNode(nodeName);
   }
+
   return {
     node
   };
 }
+
 function convertBlockquoteElement() {
   const node = $createQuoteNode();
   return {
     node
   };
 }
+
 function $createHeadingNode(headingTag) {
   return lexical.$applyNodeReplacement(new HeadingNode(headingTag));
 }
 function $isHeadingNode(node) {
   return node instanceof HeadingNode;
 }
+
 function onPasteForRichText(event, editor) {
   event.preventDefault();
   editor.update(() => {
     const selection = lexical.$getSelection();
     const clipboardData = event instanceof InputEvent || event instanceof KeyboardEvent ? null : event.clipboardData;
+
     if (clipboardData != null && (lexical.$isRangeSelection(selection) || lexical.DEPRECATED_$isGridSelection(selection))) {
       clipboard.$insertDataTransferForRichText(clipboardData, selection, editor);
     }
@@ -311,51 +338,63 @@ function onPasteForRichText(event, editor) {
     tag: 'paste'
   });
 }
+
 async function onCutForRichText(event, editor) {
-  await clipboard.copyToClipboard__EXPERIMENTAL(editor, event instanceof ClipboardEvent ? event : null);
+  await clipboard.copyToClipboard(editor, event instanceof ClipboardEvent ? event : null);
   editor.update(() => {
     const selection = lexical.$getSelection();
+
     if (lexical.$isRangeSelection(selection)) {
       selection.removeText();
     } else if (lexical.$isNodeSelection(selection)) {
       selection.getNodes().forEach(node => node.remove());
     }
   });
-}
-
-// Clipboard may contain files that we aren't allowed to read. While the event is arguably useless,
+} // Clipboard may contain files that we aren't allowed to read. While the event is arguably useless,
 // in certain ocassions, we want to know whether it was a file transfer, as opposed to text. We
 // control this with the first boolean flag.
+
+
 function eventFiles(event) {
   let dataTransfer = null;
+
   if (event instanceof DragEvent) {
     dataTransfer = event.dataTransfer;
   } else if (event instanceof ClipboardEvent) {
     dataTransfer = event.clipboardData;
   }
+
   if (dataTransfer === null) {
     return [false, [], false];
   }
+
   const types = dataTransfer.types;
   const hasFiles = types.includes('Files');
   const hasContent = types.includes('text/html') || types.includes('text/plain');
   return [hasFiles, Array.from(dataTransfer.files), hasContent];
 }
+
 function handleIndentAndOutdent(insertTab, indentOrOutdent) {
   const selection = lexical.$getSelection();
+
   if (!lexical.$isRangeSelection(selection)) {
     return;
   }
+
   const alreadyHandled = new Set();
   const nodes = selection.getNodes();
+
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
     const key = node.getKey();
+
     if (alreadyHandled.has(key)) {
       continue;
     }
+
     const parentBlock = utils.$getNearestBlockElementAncestorOrThrow(node);
     const parentKey = parentBlock.getKey();
+
     if (parentBlock.canInsertTab()) {
       insertTab(node);
       alreadyHandled.add(key);
@@ -365,45 +404,57 @@ function handleIndentAndOutdent(insertTab, indentOrOutdent) {
     }
   }
 }
+
 function $isTargetWithinDecorator(target) {
   const node = lexical.$getNearestNodeFromDOMNode(target);
   return lexical.$isDecoratorNode(node);
 }
+
 function $isSelectionAtEndOfRoot(selection) {
   const focus = selection.focus;
   return focus.key === 'root' && focus.offset === lexical.$getRoot().getChildrenSize();
 }
+
 function registerRichText(editor) {
   const removeListener = utils.mergeRegister(editor.registerCommand(lexical.CLICK_COMMAND, payload => {
     const selection = lexical.$getSelection();
+
     if (lexical.$isNodeSelection(selection)) {
       selection.clear();
       return true;
     }
+
     return false;
   }, 0), editor.registerCommand(lexical.DELETE_CHARACTER_COMMAND, isBackward => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     selection.deleteCharacter(isBackward);
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DELETE_WORD_COMMAND, isBackward => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     selection.deleteWord(isBackward);
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DELETE_LINE_COMMAND, isBackward => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     selection.deleteLine(isBackward);
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.CONTROLLED_TEXT_INSERTION_COMMAND, eventOrText => {
     const selection = lexical.$getSelection();
+
     if (typeof eventOrText === 'string') {
       if (lexical.$isRangeSelection(selection)) {
         selection.insertText(eventOrText);
@@ -412,55 +463,72 @@ function registerRichText(editor) {
       if (!lexical.$isRangeSelection(selection) && !lexical.DEPRECATED_$isGridSelection(selection)) {
         return false;
       }
+
       const dataTransfer = eventOrText.dataTransfer;
+
       if (dataTransfer != null) {
         clipboard.$insertDataTransferForRichText(dataTransfer, selection, editor);
       } else if (lexical.$isRangeSelection(selection)) {
         const data = eventOrText.data;
+
         if (data) {
           selection.insertText(data);
         }
+
         return true;
       }
     }
+
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.REMOVE_TEXT_COMMAND, () => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     selection.removeText();
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.FORMAT_TEXT_COMMAND, format => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     selection.formatText(format);
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.FORMAT_ELEMENT_COMMAND, format => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection) && !lexical.$isNodeSelection(selection)) {
       return false;
     }
+
     const nodes = selection.getNodes();
+
     for (const node of nodes) {
       const element = utils.$getNearestBlockElementAncestorOrThrow(node);
       element.setFormat(format);
     }
+
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.INSERT_LINE_BREAK_COMMAND, selectStart => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     selection.insertLineBreak(selectStart);
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.INSERT_PARAGRAPH_COMMAND, () => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     selection.insertParagraph();
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.INDENT_CONTENT_COMMAND, () => {
@@ -468,6 +536,7 @@ function registerRichText(editor) {
       editor.dispatchCommand(lexical.CONTROLLED_TEXT_INSERTION_COMMAND, '\t');
     }, block => {
       const indent = block.getIndent();
+
       if (indent !== 10) {
         block.setIndent(indent + 1);
       }
@@ -478,12 +547,14 @@ function registerRichText(editor) {
       if (lexical.$isTextNode(node)) {
         const textContent = node.getTextContent();
         const character = textContent[textContent.length - 1];
+
         if (character === '\t') {
           editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, true);
         }
       }
     }, block => {
       const indent = block.getIndent();
+
       if (indent !== 0) {
         block.setIndent(indent - 1);
       }
@@ -491,16 +562,19 @@ function registerRichText(editor) {
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ARROW_UP_COMMAND, event => {
     const selection = lexical.$getSelection();
+
     if (lexical.$isNodeSelection(selection) && !$isTargetWithinDecorator(event.target)) {
       // If selection is on a node, let's try and move selection
       // back to being a range selection.
       const nodes = selection.getNodes();
+
       if (nodes.length > 0) {
         nodes[0].selectPrevious();
         return true;
       }
     } else if (lexical.$isRangeSelection(selection)) {
       const possibleNode = lexical.$getAdjacentNode(selection.focus, true);
+
       if (lexical.$isDecoratorNode(possibleNode) && !possibleNode.isIsolated() && !possibleNode.isInline()) {
         possibleNode.selectPrevious();
         event.preventDefault();
@@ -511,13 +585,16 @@ function registerRichText(editor) {
         return true;
       }
     }
+
     return false;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ARROW_DOWN_COMMAND, event => {
     const selection = lexical.$getSelection();
+
     if (lexical.$isNodeSelection(selection)) {
       // If selection is on a node, let's try and move selection
       // back to being a range selection.
       const nodes = selection.getNodes();
+
       if (nodes.length > 0) {
         nodes[0].selectNext(0, 0);
         return true;
@@ -527,93 +604,118 @@ function registerRichText(editor) {
         event.preventDefault();
         return true;
       }
+
       const possibleNode = lexical.$getAdjacentNode(selection.focus, false);
+
       if (lexical.$isDecoratorNode(possibleNode) && !possibleNode.isIsolated() && !possibleNode.isInline()) {
         possibleNode.selectNext();
         event.preventDefault();
         return true;
       }
     }
+
     return false;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ARROW_LEFT_COMMAND, event => {
     const selection$1 = lexical.$getSelection();
+
     if (lexical.$isNodeSelection(selection$1)) {
       // If selection is on a node, let's try and move selection
       // back to being a range selection.
       const nodes = selection$1.getNodes();
+
       if (nodes.length > 0) {
         event.preventDefault();
         nodes[0].selectPrevious();
         return true;
       }
     }
+
     if (!lexical.$isRangeSelection(selection$1)) {
       return false;
     }
+
     if (selection.$shouldOverrideDefaultCharacterSelection(selection$1, true)) {
       const isHoldingShift = event.shiftKey;
       event.preventDefault();
       selection.$moveCharacter(selection$1, isHoldingShift, true);
       return true;
     }
+
     return false;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ARROW_RIGHT_COMMAND, event => {
     const selection$1 = lexical.$getSelection();
+
     if (lexical.$isNodeSelection(selection$1) && !$isTargetWithinDecorator(event.target)) {
       // If selection is on a node, let's try and move selection
       // back to being a range selection.
       const nodes = selection$1.getNodes();
+
       if (nodes.length > 0) {
         event.preventDefault();
         nodes[0].selectNext(0, 0);
         return true;
       }
     }
+
     if (!lexical.$isRangeSelection(selection$1)) {
       return false;
     }
+
     const isHoldingShift = event.shiftKey;
+
     if (selection.$shouldOverrideDefaultCharacterSelection(selection$1, false)) {
       event.preventDefault();
       selection.$moveCharacter(selection$1, isHoldingShift, false);
       return true;
     }
+
     return false;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_BACKSPACE_COMMAND, event => {
     if ($isTargetWithinDecorator(event.target)) {
       return false;
     }
+
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     event.preventDefault();
     const {
       anchor
     } = selection;
     const anchorNode = anchor.getNode();
+
     if (selection.isCollapsed() && anchor.offset === 0 && !lexical.$isRootNode(anchorNode)) {
       const element = utils.$getNearestBlockElementAncestorOrThrow(anchorNode);
+
       if (element.getIndent() > 0) {
         return editor.dispatchCommand(lexical.OUTDENT_CONTENT_COMMAND, undefined);
       }
     }
+
     return editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, true);
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_DELETE_COMMAND, event => {
     if ($isTargetWithinDecorator(event.target)) {
       return false;
     }
+
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     event.preventDefault();
     return editor.dispatchCommand(lexical.DELETE_CHARACTER_COMMAND, false);
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ENTER_COMMAND, event => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     if (event !== null) {
       // If we have beforeinput, then we can avoid blocking
       // the default behavior. This ensures that the iOS can
@@ -625,33 +727,42 @@ function registerRichText(editor) {
       if ((IS_IOS || IS_SAFARI || IS_APPLE_WEBKIT) && CAN_USE_BEFORE_INPUT) {
         return false;
       }
+
       event.preventDefault();
+
       if (event.shiftKey) {
         return editor.dispatchCommand(lexical.INSERT_LINE_BREAK_COMMAND, false);
       }
     }
+
     return editor.dispatchCommand(lexical.INSERT_PARAGRAPH_COMMAND, undefined);
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.KEY_ESCAPE_COMMAND, () => {
     const selection = lexical.$getSelection();
+
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     editor.blur();
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DROP_COMMAND, event => {
     const [, files] = eventFiles(event);
+
     if (files.length > 0) {
       const x = event.clientX;
       const y = event.clientY;
       const eventRange = caretFromPoint(x, y);
+
       if (eventRange !== null) {
         const {
           offset: domOffset,
           node: domNode
         } = eventRange;
         const node = lexical.$getNearestNodeFromDOMNode(domNode);
+
         if (node !== null) {
           const selection = lexical.$createRangeSelection();
+
           if (lexical.$isTextNode(node)) {
             selection.anchor.set(node.getKey(), domOffset, 'text');
             selection.focus.set(node.getKey(), domOffset, 'text');
@@ -661,61 +772,78 @@ function registerRichText(editor) {
             selection.anchor.set(parentKey, offset, 'element');
             selection.focus.set(parentKey, offset, 'element');
           }
+
           const normalizedSelection = lexical.$normalizeSelection__EXPERIMENTAL(selection);
           lexical.$setSelection(normalizedSelection);
         }
+
         editor.dispatchCommand(DRAG_DROP_PASTE, files);
       }
+
       event.preventDefault();
       return true;
     }
+
     const selection = lexical.$getSelection();
+
     if (lexical.$isRangeSelection(selection)) {
       return true;
     }
+
     return false;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DRAGSTART_COMMAND, event => {
     const [isFileTransfer] = eventFiles(event);
     const selection = lexical.$getSelection();
+
     if (isFileTransfer && !lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.DRAGOVER_COMMAND, event => {
     const [isFileTransfer] = eventFiles(event);
     const selection = lexical.$getSelection();
+
     if (isFileTransfer && !lexical.$isRangeSelection(selection)) {
       return false;
     }
+
     const x = event.clientX;
     const y = event.clientY;
     const eventRange = caretFromPoint(x, y);
+
     if (eventRange !== null) {
       const node = lexical.$getNearestNodeFromDOMNode(eventRange.node);
+
       if (lexical.$isDecoratorNode(node)) {
         // Show browser caret as the user is dragging the media across the screen. Won't work
         // for DecoratorNode nor it's relevant.
         event.preventDefault();
       }
     }
+
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.COPY_COMMAND, event => {
-    clipboard.copyToClipboard__EXPERIMENTAL(editor, event instanceof ClipboardEvent ? event : null);
+    clipboard.copyToClipboard(editor, event instanceof ClipboardEvent ? event : null);
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.CUT_COMMAND, event => {
     onCutForRichText(event, editor);
     return true;
   }, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.PASTE_COMMAND, event => {
     const [, files, hasTextContent] = eventFiles(event);
+
     if (files.length > 0 && !hasTextContent) {
       editor.dispatchCommand(DRAG_DROP_PASTE, files);
       return true;
     }
+
     const selection = lexical.$getSelection();
+
     if (lexical.$isRangeSelection(selection) || lexical.DEPRECATED_$isGridSelection(selection)) {
       onPasteForRichText(event, editor);
       return true;
     }
+
     return false;
   }, lexical.COMMAND_PRIORITY_EDITOR));
   return removeListener;

package/LexicalRichText.prod.js

@@ -13,7 +13,7 @@ class D extends l.ElementNode{static getType(){return"heading"}static clone(c){r
 priority:0}),h6:()=>({conversion:E,priority:0}),p:c=>{c=c.firstChild;return null!==c&&F(c)?{conversion:()=>({node:null}),priority:3}:null},span:c=>F(c)?{conversion:()=>({node:G("h1")}),priority:3}:null}}static importJSON(c){let b=G(c.tag);b.setFormat(c.format);b.setIndent(c.indent);b.setDirection(c.direction);return b}exportJSON(){return{...super.exportJSON(),tag:this.getTag(),type:"heading",version:1}}insertNewAfter(c,b=!0){c=c?c.anchor.offset:0;c=0<c&&c<this.getTextContentSize()?G(this.getTag()):
 l.$createParagraphNode();let d=this.getDirection();c.setDirection(d);this.insertAfter(c,b);return c}collapseAtStart(){let c=this.isEmpty()?l.$createParagraphNode():G(this.getTag());this.getChildren().forEach(b=>c.append(b));this.replace(c);return!0}extractWithChild(){return!0}}function F(c){return"span"===c.nodeName.toLowerCase()?"26pt"===c.style.fontSize:!1}function E(c){c=c.nodeName.toLowerCase();let b=null;if("h1"===c||"h2"===c||"h3"===c||"h4"===c||"h5"===c||"h6"===c)b=G(c);return{node:b}}
 function A(){return{node:B()}}function G(c){return l.$applyNodeReplacement(new D(c))}function H(c,b){c.preventDefault();b.update(()=>{let d=l.$getSelection(),e=c instanceof InputEvent||c instanceof KeyboardEvent?null:c.clipboardData;null!=e&&(l.$isRangeSelection(d)||l.DEPRECATED_$isGridSelection(d))&&a.$insertDataTransferForRichText(e,d,b)},{tag:"paste"})}
-async function I(c,b){await a.copyToClipboard__EXPERIMENTAL(b,c instanceof ClipboardEvent?c:null);b.update(()=>{let d=l.$getSelection();l.$isRangeSelection(d)?d.removeText():l.$isNodeSelection(d)&&d.getNodes().forEach(e=>e.remove())})}function J(c){let b=null;c instanceof DragEvent?b=c.dataTransfer:c instanceof ClipboardEvent&&(b=c.clipboardData);if(null===b)return[!1,[],!1];var d=b.types;c=d.includes("Files");d=d.includes("text/html")||d.includes("text/plain");return[c,Array.from(b.files),d]}
+async function I(c,b){await a.copyToClipboard(b,c instanceof ClipboardEvent?c:null);b.update(()=>{let d=l.$getSelection();l.$isRangeSelection(d)?d.removeText():l.$isNodeSelection(d)&&d.getNodes().forEach(e=>e.remove())})}function J(c){let b=null;c instanceof DragEvent?b=c.dataTransfer:c instanceof ClipboardEvent&&(b=c.clipboardData);if(null===b)return[!1,[],!1];var d=b.types;c=d.includes("Files");d=d.includes("text/html")||d.includes("text/plain");return[c,Array.from(b.files),d]}
 function K(c,b){var d=l.$getSelection();if(l.$isRangeSelection(d)){var e=new Set;d=d.getNodes();for(let f=0;f<d.length;f++){let n=d[f],v=n.getKey();if(e.has(v))continue;let h=k.$getNearestBlockElementAncestorOrThrow(n),C=h.getKey();h.canInsertTab()?(c(n),e.add(v)):h.canIndent()&&!e.has(C)&&(e.add(C),b(h))}}}function L(c){c=l.$getNearestNodeFromDOMNode(c);return l.$isDecoratorNode(c)}exports.$createHeadingNode=G;exports.$createQuoteNode=B;exports.$isHeadingNode=function(c){return c instanceof D};
 exports.$isQuoteNode=function(c){return c instanceof z};exports.DRAG_DROP_PASTE=y;exports.HeadingNode=D;exports.QuoteNode=z;exports.eventFiles=J;
 exports.registerRichText=function(c){return k.mergeRegister(c.registerCommand(l.CLICK_COMMAND,()=>{const b=l.$getSelection();return l.$isNodeSelection(b)?(b.clear(),!0):!1},0),c.registerCommand(l.DELETE_CHARACTER_COMMAND,b=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;d.deleteCharacter(b);return!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.DELETE_WORD_COMMAND,b=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;d.deleteWord(b);return!0},l.COMMAND_PRIORITY_EDITOR),
@@ -28,5 +28,5 @@ c.registerCommand(l.KEY_BACKSPACE_COMMAND,b=>{if(L(b.target))return!1;const d=l.
 l.$getSelection();if(!l.$isRangeSelection(d))return!1;b.preventDefault();return c.dispatchCommand(l.DELETE_CHARACTER_COMMAND,!1)},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.KEY_ENTER_COMMAND,b=>{const d=l.$getSelection();if(!l.$isRangeSelection(d))return!1;if(null!==b){if((u||t||x)&&r)return!1;b.preventDefault();if(b.shiftKey)return c.dispatchCommand(l.INSERT_LINE_BREAK_COMMAND,!1)}return c.dispatchCommand(l.INSERT_PARAGRAPH_COMMAND,void 0)},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.KEY_ESCAPE_COMMAND,
 ()=>{const b=l.$getSelection();if(!l.$isRangeSelection(b))return!1;c.blur();return!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.DROP_COMMAND,b=>{const [,d]=J(b);if(0<d.length){var e=m(b.clientX,b.clientY);if(null!==e){const {offset:n,node:v}=e;var f=l.$getNearestNodeFromDOMNode(v);if(null!==f){e=l.$createRangeSelection();if(l.$isTextNode(f))e.anchor.set(f.getKey(),n,"text"),e.focus.set(f.getKey(),n,"text");else{const h=f.getParentOrThrow().getKey();f=f.getIndexWithinParent()+1;e.anchor.set(h,
 f,"element");e.focus.set(h,f,"element")}e=l.$normalizeSelection__EXPERIMENTAL(e);l.$setSelection(e)}c.dispatchCommand(y,d)}b.preventDefault();return!0}b=l.$getSelection();return l.$isRangeSelection(b)?!0:!1},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.DRAGSTART_COMMAND,b=>{[b]=J(b);const d=l.$getSelection();return b&&!l.$isRangeSelection(d)?!1:!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.DRAGOVER_COMMAND,b=>{var [d]=J(b);const e=l.$getSelection();if(d&&!l.$isRangeSelection(e))return!1;d=
-m(b.clientX,b.clientY);null!==d&&(d=l.$getNearestNodeFromDOMNode(d.node),l.$isDecoratorNode(d)&&b.preventDefault());return!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.COPY_COMMAND,b=>{a.copyToClipboard__EXPERIMENTAL(c,b instanceof ClipboardEvent?b:null);return!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.CUT_COMMAND,b=>{I(b,c);return!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.PASTE_COMMAND,b=>{const [,d,e]=J(b);if(0<d.length&&!e)return c.dispatchCommand(y,d),!0;const f=l.$getSelection();
-return l.$isRangeSelection(f)||l.DEPRECATED_$isGridSelection(f)?(H(b,c),!0):!1},l.COMMAND_PRIORITY_EDITOR))}
+m(b.clientX,b.clientY);null!==d&&(d=l.$getNearestNodeFromDOMNode(d.node),l.$isDecoratorNode(d)&&b.preventDefault());return!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.COPY_COMMAND,b=>{a.copyToClipboard(c,b instanceof ClipboardEvent?b:null);return!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.CUT_COMMAND,b=>{I(b,c);return!0},l.COMMAND_PRIORITY_EDITOR),c.registerCommand(l.PASTE_COMMAND,b=>{const [,d,e]=J(b);if(0<d.length&&!e)return c.dispatchCommand(y,d),!0;const f=l.$getSelection();return l.$isRangeSelection(f)||
+l.DEPRECATED_$isGridSelection(f)?(H(b,c),!0):!1},l.COMMAND_PRIORITY_EDITOR))}

package/package.json

@@ -7,13 +7,13 @@
     "rich-text"
   ],
   "license": "MIT",
-  "version": "0.8.1",
+  "version": "0.9.1",
   "main": "LexicalRichText.js",
   "peerDependencies": {
-    "lexical": "0.8.1",
-    "@lexical/selection": "0.8.1",
-    "@lexical/clipboard": "0.8.1",
-    "@lexical/utils": "0.8.1"
+    "lexical": "0.9.1",
+    "@lexical/selection": "0.9.1",
+    "@lexical/clipboard": "0.9.1",
+    "@lexical/utils": "0.9.1"
   },
   "repository": {
     "type": "git",