@lexical/clipboard 0.2.4 → 0.2.7

package/LexicalClipboard.d.ts

@@ -6,7 +6,12 @@
  *
  */
 
-import type {LexicalEditor, RangeSelection} from 'lexical';
+import type {
+  GridSelection,
+  LexicalEditor,
+  NodeSelection,
+  RangeSelection,
+} from 'lexical';
 
 /*
  * Rich Text
@@ -14,11 +19,11 @@ import type {LexicalEditor, RangeSelection} from 'lexical';
 
 export function $insertDataTransferForRichText(
   dataTransfer: DataTransfer,
-  selection: RangeSelection,
+  selection: RangeSelection | GridSelection | NodeSelection,
   editor: LexicalEditor,
 ): void;
 
-export function getHtmlContent(editor: LexicalEditor): string;
+export function $getHtmlContent(editor: LexicalEditor): string;
 export function $getLexicalContent(editor: LexicalEditor): string;
 
 /*

package/LexicalClipboard.dev.js

@@ -7,6 +7,7 @@
 'use strict';
 
 var selection = require('@lexical/selection');
+var utils = require('@lexical/utils');
 var lexical = require('lexical');
 
 /**
@@ -18,101 +19,176 @@ var lexical = require('lexical');
  * 
  */
 const IGNORE_TAGS = new Set(['STYLE']);
-function getHtmlContent(editor) {
-  const selection$1 = lexical.$getSelection();
+function $getHtmlContent(editor) {
+  const selection = lexical.$getSelection();
 
-  if (selection$1 == null) {
+  if (selection == null) {
     throw new Error('Expected valid LexicalSelection');
   } // If we haven't selected anything
 
 
-  if (lexical.$isRangeSelection(selection$1) && selection$1.isCollapsed() || selection$1.getNodes().length === 0) {
+  if (lexical.$isRangeSelection(selection) && selection.isCollapsed() || selection.getNodes().length === 0) {
     return null;
   }
 
-  const state = selection.$cloneContents(selection$1);
-  return $convertSelectedLexicalContentToHtml(editor, selection$1, state);
+  return $convertSelectedContentToHtml(editor, selection);
 }
-function $convertSelectedLexicalNodeToHTMLElement(editor, selection, node) {
-  let nodeToConvert = node;
-
-  if (lexical.$isRangeSelection(selection) || lexical.$isGridSelection(selection)) {
-    const anchor = selection.anchor.getNode();
-    const focus = selection.focus.getNode();
-    const isAnchor = node.is(anchor);
-    const isFocus = node.is(focus);
-
-    if (lexical.$isTextNode(node) && (isAnchor || isFocus)) {
-      const anchorOffset = selection.anchor.getCharacterOffset();
-      const focusOffset = selection.focus.getCharacterOffset();
-      const isBackward = selection.isBackward();
-      const isSame = anchor.is(focus);
-      const isFirst = node.is(isBackward ? focus : anchor);
-      const nodeText = node.getTextContent();
-      const nodeTextLength = nodeText.length;
+function $appendSelectedNodesToHTML(editor, selection$1, currentNode, parentElement) {
+  let shouldInclude = currentNode.isSelected();
+  const shouldExclude = lexical.$isElementNode(currentNode) && currentNode.excludeFromCopy('html');
+  let clone = selection.$cloneWithProperties(currentNode);
+  clone = lexical.$isTextNode(clone) ? $splitClonedTextNode(selection$1, clone) : clone;
+  const children = lexical.$isElementNode(clone) ? clone.getChildren() : [];
+  const {
+    element,
+    after
+  } = clone.exportDOM(editor);
 
-      if (isSame) {
-        const startOffset = anchorOffset > focusOffset ? focusOffset : anchorOffset;
-        const endOffset = anchorOffset > focusOffset ? anchorOffset : focusOffset;
-        const splitNodes = node.splitText(startOffset, endOffset);
-        nodeToConvert = startOffset === 0 ? splitNodes[0] : splitNodes[1];
-      } else {
-        let endOffset;
+  if (!element) {
+    return false;
+  }
 
-        if (isFirst) {
-          endOffset = isBackward ? focusOffset : anchorOffset;
-        } else {
-          endOffset = isBackward ? anchorOffset : focusOffset;
-        }
+  const fragment = new DocumentFragment();
 
-        if (!isBackward && endOffset === 0) {
-          return null;
-        } else if (endOffset !== nodeTextLength) {
-          nodeToConvert = node.splitText(endOffset)[isFirst && endOffset !== 0 ? 1 : 0];
-        }
-      }
+  for (let i = 0; i < children.length; i++) {
+    const childNode = children[i];
+    const shouldIncludeChild = $appendSelectedNodesToHTML(editor, selection$1, childNode, fragment);
+
+    if (!shouldInclude && lexical.$isElementNode(currentNode) && shouldIncludeChild && currentNode.extractWithChild(childNode, selection$1, 'html')) {
+      shouldInclude = true;
     }
   }
 
-  const {
-    element,
-    after
-  } = nodeToConvert.exportDOM(editor);
-  if (!element) return null;
-  const children = lexical.$isElementNode(nodeToConvert) ? nodeToConvert.getChildren() : [];
+  if (shouldInclude && !shouldExclude) {
+    element.append(fragment);
+    parentElement.append(element);
+
+    if (after) {
+      const newElement = after.call(clone, element);
+      if (newElement) element.replaceWith(newElement);
+    }
+  } else {
+    parentElement.append(fragment);
+  }
+
+  return shouldInclude;
+}
+function $convertSelectedContentToHtml(editor, selection) {
+  const container = document.createElement('div');
+  const root = lexical.$getRoot();
+  const topLevelChildren = root.getChildren();
+
+  for (let i = 0; i < topLevelChildren.length; i++) {
+    const topLevelNode = topLevelChildren[i];
+    $appendSelectedNodesToHTML(editor, selection, topLevelNode, container);
+  }
+
+  return container.innerHTML;
+}
+function $appendSelectedNodesToClone(editor, selection$1, currentNode, nodeMap, range, shouldIncludeInRange = true) {
+  let shouldInclude = currentNode.isSelected();
+  const shouldExclude = lexical.$isElementNode(currentNode) && currentNode.excludeFromCopy('clone');
+  let clone = selection.$cloneWithProperties(currentNode);
+  clone = lexical.$isTextNode(clone) ? $splitClonedTextNode(selection$1, clone) : clone;
+  const children = lexical.$isElementNode(clone) ? clone.getChildren() : [];
+  const nodeKeys = [];
+  let shouldIncludeChildrenInRange = shouldIncludeInRange;
+
+  if (shouldInclude && !shouldExclude) {
+    nodeMap.set(clone.getKey(), clone);
+
+    if (shouldIncludeInRange) {
+      shouldIncludeChildrenInRange = false;
+    }
+  }
 
   for (let i = 0; i < children.length; i++) {
     const childNode = children[i];
+    const childNodeKeys = $appendSelectedNodesToClone(editor, selection$1, childNode, nodeMap, range, shouldIncludeChildrenInRange);
+
+    for (let j = 0; j < childNodeKeys.length; j++) {
+      const childNodeKey = childNodeKeys[j];
+      nodeKeys.push(childNodeKey);
+    }
+
+    if (!shouldInclude && lexical.$isElementNode(currentNode) && nodeKeys.includes(childNode.getKey()) && currentNode.extractWithChild(childNode, selection$1, 'clone')) {
+      shouldInclude = true;
+    }
+  } // The tree is later built using $generateNodes which works
+  // by going through the nodes specified in the "range" & their children
+  // while filtering out nodes not found in the "nodeMap".
+  // This gets complicated when we want to "exclude" a node but
+  // keep it's children i.e. a MarkNode and it's Text children.
+  // The solution is to check if there's a cloned parent already in our map and
+  // splice the current node's children into the nearest parent.
+  // If there is no parent in the map already, the children will be added to the
+  // top level range be default.
+
+
+  if (lexical.$isElementNode(clone) && shouldExclude && shouldInclude) {
+    let nearestClonedParent;
+    let idxWithinClonedParent;
+    let prev = clone;
+    let curr = clone.getParent();
+    const root = lexical.$getRoot();
+
+    while (curr != null && !curr.is(root)) {
+      if (nodeMap.has(curr.getKey()) || curr.extractWithChild(currentNode, selection$1, 'clone')) {
+        nearestClonedParent = selection.$cloneWithProperties(curr);
+        idxWithinClonedParent = prev.getIndexWithinParent();
+        nodeMap.set(nearestClonedParent.getKey(), nearestClonedParent);
+        break;
+      }
+
+      prev = curr;
+      curr = curr.getParent();
+    } // Add children to nearest cloned parent at the correct position.
+
 
-    if (childNode.isSelected()) {
-      const newElement = $convertSelectedLexicalNodeToHTMLElement(editor, selection, childNode);
-      if (newElement) element.append(newElement);
+    if (lexical.$isElementNode(nearestClonedParent) && idxWithinClonedParent != null) {
+      nearestClonedParent.__children.splice(idxWithinClonedParent, 1, ...clone.__children);
     }
   }
 
-  return after ? after.call(nodeToConvert, element) : element;
-}
-function $convertSelectedLexicalContentToHtml(editor, selection, state) {
-  const container = document.createElement('div');
+  if (shouldInclude && !shouldExclude) {
+    if (!nodeMap.has(clone.getKey())) {
+      nodeMap.set(clone.getKey(), clone);
+    }
 
-  for (let i = 0; i < state.range.length; i++) {
-    const nodeKey = state.range[i];
-    const node = lexical.$getNodeByKey(nodeKey);
+    if (shouldIncludeInRange) {
+      return [clone.getKey()];
+    }
+  }
 
-    if (node && node.isSelected()) {
-      const element = $convertSelectedLexicalNodeToHTMLElement(editor, selection, node);
-      if (element) container.append(element);
+  return shouldIncludeChildrenInRange ? nodeKeys : [];
+}
+function $cloneSelectedContent(editor, selection) {
+  const root = lexical.$getRoot();
+  const nodeMap = new Map();
+  const range = [];
+  const topLevelChildren = root.getChildren();
+
+  for (let i = 0; i < topLevelChildren.length; i++) {
+    const topLevelNode = topLevelChildren[i];
+    const childNodeKeys = $appendSelectedNodesToClone(editor, selection, topLevelNode, nodeMap, range, true);
+
+    for (let j = 0; j < childNodeKeys.length; j++) {
+      const childNodeKey = childNodeKeys[j];
+      range.push(childNodeKey);
     }
   }
 
-  return container.innerHTML;
+  return {
+    nodeMap: Array.from(nodeMap),
+    range
+  };
 }
 function $getLexicalContent(editor) {
-  const selection$1 = lexical.$getSelection();
+  const selection = lexical.$getSelection();
 
-  if (selection$1 !== null) {
+  if (selection !== null) {
     const namespace = editor._config.namespace;
-    const state = selection.$cloneContents(selection$1);
+    const state = $cloneSelectedContent(editor, selection);
     return JSON.stringify({
       namespace,
       state
@@ -130,6 +206,7 @@ function $insertDataTransferForPlainText(dataTransfer, selection) {
 }
 function $insertDataTransferForRichText(dataTransfer, selection, editor) {
   const lexicalNodesString = dataTransfer.getData('application/x-lexical-editor');
+  const isSelectionInsideOfGrid = lexical.$isGridSelection(selection) || utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isGridCellNode(n)) !== null && utils.$findMatchingParent(selection.focus.getNode(), n => lexical.$isGridCellNode(n)) !== null;
 
   if (lexicalNodesString) {
     const namespace = editor._config.namespace;
@@ -140,7 +217,13 @@ function $insertDataTransferForRichText(dataTransfer, selection, editor) {
       if (lexicalClipboardData.namespace === namespace) {
         const nodeRange = lexicalClipboardData.state;
         const nodes = $generateNodes(nodeRange);
-        selection.insertNodes(nodes);
+
+        if (isSelectionInsideOfGrid && nodes.length === 1 && lexical.$isGridNode(nodes[0])) {
+          $mergeGridNodesStrategy(nodes, selection, false, editor);
+          return;
+        }
+
+        $basicInsertStrategy(nodes, selection, true);
         return;
       }
     } catch (e) {// Malformed, missing nodes..
@@ -153,8 +236,25 @@ function $insertDataTransferForRichText(dataTransfer, selection, editor) {
   if (htmlString) {
     const parser = new DOMParser();
     const dom = parser.parseFromString(htmlString, textHtmlMimeType);
-    const nodes = $generateNodesFromDOM(dom, editor); // Wrap text and inline nodes in paragraph nodes so we have all blocks at the top-level
+    const nodes = $generateNodesFromDOM(dom, editor);
 
+    if (isSelectionInsideOfGrid && nodes.length === 1 && lexical.$isGridNode(nodes[0])) {
+      $mergeGridNodesStrategy(nodes, selection, false, editor);
+      return;
+    }
+
+    $basicInsertStrategy(nodes, selection, false);
+    return;
+  }
+
+  $insertDataTransferForPlainText(dataTransfer, selection);
+}
+
+function $basicInsertStrategy(nodes, selection, isFromLexical) {
+  let nodesToInsert;
+
+  if (!isFromLexical) {
+    // Wrap text and inline nodes in paragraph nodes so we have all blocks at the top-level
     const topLevelBlocks = [];
     let currentBlock = null;
 
@@ -176,11 +276,128 @@ function $insertDataTransferForRichText(dataTransfer, selection, editor) {
       }
     }
 
-    selection.insertNodes(topLevelBlocks);
-    return;
+    nodesToInsert = topLevelBlocks;
+  } else {
+    nodesToInsert = nodes;
   }
 
-  $insertDataTransferForPlainText(dataTransfer, selection);
+  if (lexical.$isRangeSelection(selection)) {
+    selection.insertNodes(nodesToInsert);
+  } else if (lexical.$isGridSelection(selection)) {
+    // If there's an active grid selection and a non grid is pasted, add to the anchor.
+    const anchorCell = selection.anchor.getNode();
+
+    if (!lexical.$isGridCellNode(anchorCell)) {
+      {
+        throw Error(`Expected Grid Cell in Grid Selection`);
+      }
+    }
+
+    anchorCell.append(...nodesToInsert);
+  }
+}
+
+function $mergeGridNodesStrategy(nodes, selection, isFromLexical, editor) {
+  if (nodes.length !== 1 || !lexical.$isGridNode(nodes[0])) {
+    {
+      throw Error(`$mergeGridNodesStrategy: Expected Grid insertion.`);
+    }
+  }
+
+  const newGrid = nodes[0];
+  const newGridRows = newGrid.getChildren();
+  const newColumnCount = newGrid.getFirstChildOrThrow().getChildrenSize();
+  const newRowCount = newGrid.getChildrenSize();
+  const gridCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isGridCellNode(n));
+  const gridRowNode = gridCellNode && utils.$findMatchingParent(gridCellNode, n => lexical.$isGridRowNode(n));
+  const gridNode = gridRowNode && utils.$findMatchingParent(gridRowNode, n => lexical.$isGridNode(n));
+
+  if (!lexical.$isGridCellNode(gridCellNode) || !lexical.$isGridRowNode(gridRowNode) || !lexical.$isGridNode(gridNode)) {
+    {
+      throw Error(`$mergeGridNodesStrategy: Expected selection to be inside of a Grid.`);
+    }
+  }
+
+  const startY = gridRowNode.getIndexWithinParent();
+  const stopY = Math.min(gridNode.getChildrenSize() - 1, startY + newRowCount - 1);
+  const startX = gridCellNode.getIndexWithinParent();
+  const stopX = Math.min(gridRowNode.getChildrenSize() - 1, startX + newColumnCount - 1);
+  const fromX = Math.min(startX, stopX);
+  const fromY = Math.min(startY, stopY);
+  const toX = Math.max(startX, stopX);
+  const toY = Math.max(startY, stopY);
+  const gridRowNodes = gridNode.getChildren();
+  let newRowIdx = 0;
+  let newAnchorCellKey;
+  let newFocusCellKey;
+
+  for (let r = fromY; r <= toY; r++) {
+    const currentGridRowNode = gridRowNodes[r];
+
+    if (!lexical.$isGridRowNode(currentGridRowNode)) {
+      {
+        throw Error(`getNodes: expected to find GridRowNode`);
+      }
+    }
+
+    const newGridRowNode = newGridRows[newRowIdx];
+
+    if (!lexical.$isGridRowNode(newGridRowNode)) {
+      {
+        throw Error(`getNodes: expected to find GridRowNode`);
+      }
+    }
+
+    const gridCellNodes = currentGridRowNode.getChildren();
+    const newGridCellNodes = newGridRowNode.getChildren();
+    let newColumnIdx = 0;
+
+    for (let c = fromX; c <= toX; c++) {
+      const currentGridCellNode = gridCellNodes[c];
+
+      if (!lexical.$isGridCellNode(currentGridCellNode)) {
+        {
+          throw Error(`getNodes: expected to find GridCellNode`);
+        }
+      }
+
+      const newGridCellNode = newGridCellNodes[newColumnIdx];
+
+      if (!lexical.$isGridCellNode(newGridCellNode)) {
+        {
+          throw Error(`getNodes: expected to find GridCellNode`);
+        }
+      }
+
+      if (r === fromY && c === fromX) {
+        newAnchorCellKey = currentGridCellNode.getKey();
+      } else if (r === toY && c === toX) {
+        newFocusCellKey = currentGridCellNode.getKey();
+      }
+
+      const originalChildren = currentGridCellNode.getChildren();
+      newGridCellNode.getChildren().forEach(child => {
+        if (lexical.$isTextNode(child)) {
+          const paragraphNode = lexical.$createParagraphNode();
+          paragraphNode.append(child);
+          currentGridCellNode.append(child);
+        } else {
+          currentGridCellNode.append(child);
+        }
+      });
+      originalChildren.forEach(n => n.remove());
+      newColumnIdx++;
+    }
+
+    newRowIdx++;
+  }
+
+  if (newAnchorCellKey && newFocusCellKey) {
+    const newGridSelection = lexical.$createGridSelection();
+    newGridSelection.set(gridNode.getKey(), newAnchorCellKey, newFocusCellKey);
+    lexical.$setSelection(newGridSelection);
+    editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
+  }
 }
 
 function $generateNodes(nodeRange) {
@@ -310,8 +527,44 @@ function $generateNodesFromDOM(dom, editor) {
 
   return lexicalNodes;
 }
+function $splitClonedTextNode(selection, clone) {
+  if (clone.isSelected() && !clone.isSegmented() && !clone.isToken() && (lexical.$isRangeSelection(selection) || lexical.$isGridSelection(selection))) {
+    const anchorNode = selection.anchor.getNode();
+    const focusNode = selection.focus.getNode();
+    const isAnchor = clone.is(anchorNode);
+    const isFocus = clone.is(focusNode);
+
+    if (isAnchor || isFocus) {
+      const isBackward = selection.isBackward();
+      const [anchorOffset, focusOffset] = selection.getCharacterOffsets();
+      const isSame = anchorNode.is(focusNode);
+      const isFirst = clone.is(isBackward ? focusNode : anchorNode);
+      const isLast = clone.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;
+      }
+
+      clone.__text = clone.__text.slice(startOffset, endOffset);
+      return clone;
+    }
+  }
+
+  return clone;
+}
 
+exports.$getHtmlContent = $getHtmlContent;
 exports.$getLexicalContent = $getLexicalContent;
 exports.$insertDataTransferForPlainText = $insertDataTransferForPlainText;
 exports.$insertDataTransferForRichText = $insertDataTransferForRichText;
-exports.getHtmlContent = getHtmlContent;

package/LexicalClipboard.js.flow

@@ -7,7 +7,12 @@
  * @flow strict
  */
 
-import type {LexicalEditor, RangeSelection} from 'lexical';
+import type {
+  GridSelection,
+  LexicalEditor,
+  NodeSelection,
+  RangeSelection,
+} from 'lexical';
 
 /*
  * Rich Text
@@ -15,11 +20,11 @@ import type {LexicalEditor, RangeSelection} from 'lexical';
 
 declare export function $insertDataTransferForRichText(
   dataTransfer: DataTransfer,
-  selection: RangeSelection,
+  selection: RangeSelection | GridSelection | NodeSelection,
   editor: LexicalEditor,
 ): void;
 
-declare export function getHtmlContent(editor: LexicalEditor): string;
+declare export function $getHtmlContent(editor: LexicalEditor): string;
 declare export function $getLexicalContent(editor: LexicalEditor): string;
 
 /*

package/LexicalClipboard.prod.js

@@ -4,11 +4,19 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
-var l=require("@lexical/selection"),p=require("lexical");const q=new Set(["STYLE"]);
-function r(c,d,h){var b=h;if(p.$isRangeSelection(d)||p.$isGridSelection(d)){var f=d.anchor.getNode(),a=d.focus.getNode(),e=h.is(f),g=h.is(a);if(p.$isTextNode(h)&&(e||g)){e=d.anchor.getCharacterOffset();g=d.focus.getCharacterOffset();const m=d.isBackward(),v=f.is(a);f=h.is(m?a:f);a=h.getTextContent().length;if(v)b=e>g?g:e,h=h.splitText(b,e>g?e:g),b=0===b?h[0]:h[1];else if(e=f?m?g:e:m?e:g,m||0!==e)e!==a&&(b=h.splitText(e)[f&&0!==e?1:0]);else return null}}const {element:k,after:n}=b.exportDOM(c);if(!k)return null;
-h=p.$isElementNode(b)?b.getChildren():[];for(e=0;e<h.length;e++)g=h[e],g.isSelected()&&(g=r(c,d,g))&&k.append(g);return n?n.call(b,k):k}function t(c,d){c=c.getData("text/plain");null!=c&&d.insertRawText(c)}function u(c,d){const {nodeName:h}=c;d=d._htmlConversions.get(h.toLowerCase());let b=null;void 0!==d&&d.forEach(f=>{f=f(c);null!==f&&(null===b||b.priority<f.priority)&&(b=f)});return null!==b?b.conversion:null}
-function w(c,d,h=new Map,b){let f=[];if(q.has(c.nodeName))return f;let a=null;var e=u(c,d);const g=e?e(c):null;e=null;if(null!==g){e=g.after;a=g.node;if(null!==a){for(var [,k]of h)if(a=k(a,b),!a)break;a&&f.push(a)}null!=g.forChild&&h.set(c.nodeName,g.forChild)}c=c.childNodes;b=[];for(k=0;k<c.length;k++)b.push(...w(c[k],d,h,a));null!=e&&(b=e(b));null==a?f=f.concat(b):p.$isElementNode(a)&&a.append(...b);return f}
-exports.$getLexicalContent=function(c){var d=p.$getSelection();return null!==d?(c=c._config.namespace,d=l.$cloneContents(d),JSON.stringify({namespace:c,state:d})):null};exports.$insertDataTransferForPlainText=t;
-exports.$insertDataTransferForRichText=function(c,d,h){var b=c.getData("application/x-lexical-editor");if(b){var f=h._config.namespace;try{const k=JSON.parse(b);if(k.namespace===f){const {range:n,nodeMap:m}=k.state;var a=new Map(m);b=[];for(f=0;f<n.length;f++){var e=a.get(n[f]);if(void 0!==e){var g=p.$createNodeFromParse(e,a);b.push(g)}}d.insertNodes(b);return}}catch(k){}}if(a=c.getData("text/html")){a=(new DOMParser).parseFromString(a,"text/html");c=[];a=a.body?Array.from(a.body.childNodes):[];e=
-a.length;for(g=0;g<e;g++)b=a[g],q.has(b.nodeName)||(b=w(b,h),null!==b&&(c=c.concat(b)));h=c;c=[];a=null;for(e=0;e<h.length;e++)g=h[e],!p.$isElementNode(g)||g.isInline()?(null===a&&(a=p.$createParagraphNode(),c.push(a)),null!==a&&a.append(g)):(c.push(g),a=null);d.insertNodes(c)}else t(c,d)};
-exports.getHtmlContent=function(c){const d=p.$getSelection();if(null==d)throw Error("Expected valid LexicalSelection");if(p.$isRangeSelection(d)&&d.isCollapsed()||0===d.getNodes().length)return null;var h=l.$cloneContents(d);const b=document.createElement("div");for(let a=0;a<h.range.length;a++){var f=p.$getNodeByKey(h.range[a]);f&&f.isSelected()&&(f=r(c,d,f))&&b.append(f)}return b.innerHTML};
+var h=require("@lexical/selection"),u=require("@lexical/utils"),v=require("lexical");function z(a){throw Error(`Minified Lexical error #${a}; see codes.json for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}const A=new Set(["STYLE"]);
+function B(a,c,d,e){let b=d.isSelected();const f=v.$isElementNode(d)&&d.excludeFromCopy("html");let g=h.$cloneWithProperties(d);g=v.$isTextNode(g)?C(c,g):g;const l=v.$isElementNode(g)?g.getChildren():[],{element:k,after:q}=g.exportDOM(a);if(!k)return!1;const r=new DocumentFragment;for(let p=0;p<l.length;p++){const n=l[p],m=B(a,c,n,r);!b&&v.$isElementNode(d)&&m&&d.extractWithChild(n,c,"html")&&(b=!0)}b&&!f?(k.append(r),e.append(k),q&&(a=q.call(g,k))&&k.replaceWith(a)):e.append(r);return b}
+function D(a,c,d,e,b,f=!0){let g=d.isSelected();const l=v.$isElementNode(d)&&d.excludeFromCopy("clone");let k=h.$cloneWithProperties(d);k=v.$isTextNode(k)?C(c,k):k;var q=v.$isElementNode(k)?k.getChildren():[];const r=[];let p=f;g&&!l&&(e.set(k.getKey(),k),f&&(p=!1));for(let n=0;n<q.length;n++){const m=q[n],w=D(a,c,m,e,b,p);for(let t=0;t<w.length;t++)r.push(w[t]);!g&&v.$isElementNode(d)&&r.includes(m.getKey())&&d.extractWithChild(m,c,"clone")&&(g=!0)}if(v.$isElementNode(k)&&l&&g){let n,m;a=k;b=k.getParent();
+for(q=v.$getRoot();null!=b&&!b.is(q);){if(e.has(b.getKey())||b.extractWithChild(d,c,"clone")){n=h.$cloneWithProperties(b);m=a.getIndexWithinParent();e.set(n.getKey(),n);break}a=b;b=b.getParent()}v.$isElementNode(n)&&null!=m&&n.__children.splice(m,1,...k.__children)}return g&&!l&&(e.has(k.getKey())||e.set(k.getKey(),k),f)?[k.getKey()]:p?r:[]}function E(a,c){a=a.getData("text/plain");null!=a&&c.insertRawText(a)}
+function F(a,c,d){if(!d){d=[];let e=null;for(let b=0;b<a.length;b++){const f=a[b];!v.$isElementNode(f)||f.isInline()?(null===e&&(e=v.$createParagraphNode(),d.push(e)),null!==e&&e.append(f)):(d.push(f),e=null)}a=d}v.$isRangeSelection(c)?c.insertNodes(a):v.$isGridSelection(c)&&(c=c.anchor.getNode(),v.$isGridCellNode(c)||z(15),c.append(...a))}
+function G(a,c,d,e){1===a.length&&v.$isGridNode(a[0])||z(16);var b=a[0];a=b.getChildren();d=b.getFirstChildOrThrow().getChildrenSize();var f=b.getChildrenSize(),g=u.$findMatchingParent(c.anchor.getNode(),m=>v.$isGridCellNode(m));c=(b=g&&u.$findMatchingParent(g,m=>v.$isGridRowNode(m)))&&u.$findMatchingParent(b,m=>v.$isGridNode(m));v.$isGridCellNode(g)&&v.$isGridRowNode(b)&&v.$isGridNode(c)||z(17);var l=b.getIndexWithinParent(),k=Math.min(c.getChildrenSize()-1,l+f-1);f=g.getIndexWithinParent();g=Math.min(b.getChildrenSize()-
+1,f+d-1);d=Math.min(f,g);b=Math.min(l,k);f=Math.max(f,g);l=Math.max(l,k);k=c.getChildren();g=0;let q,r;for(let m=b;m<=l;m++){var p=k[m];v.$isGridRowNode(p)||z(18);var n=a[g];v.$isGridRowNode(n)||z(18);p=p.getChildren();n=n.getChildren();let w=0;for(let t=d;t<=f;t++){const x=p[t];v.$isGridCellNode(x)||z(19);const H=n[w];v.$isGridCellNode(H)||z(19);m===b&&t===d?q=x.getKey():m===l&&t===f&&(r=x.getKey());const J=x.getChildren();H.getChildren().forEach(y=>{v.$isTextNode(y)&&v.$createParagraphNode().append(y);
+x.append(y)});J.forEach(y=>y.remove());w++}g++}q&&r&&(a=v.$createGridSelection(),a.set(c.getKey(),q,r),v.$setSelection(a),e.dispatchCommand(v.SELECTION_CHANGE_COMMAND))}function I(a){const {range:c,nodeMap:d}=a;a=new Map(d);const e=[];for(let f=0;f<c.length;f++){var b=a.get(c[f]);void 0!==b&&(b=v.$createNodeFromParse(b,a),e.push(b))}return e}
+function K(a,c){const {nodeName:d}=a;c=c._htmlConversions.get(d.toLowerCase());let e=null;void 0!==c&&c.forEach(b=>{b=b(a);null!==b&&(null===e||e.priority<b.priority)&&(e=b)});return null!==e?e.conversion:null}
+function L(a,c,d=new Map,e){let b=[];if(A.has(a.nodeName))return b;let f=null;var g=K(a,c);const l=g?g(a):null;g=null;if(null!==l){g=l.after;f=l.node;if(null!==f){for(var [,k]of d)if(f=k(f,e),!f)break;f&&b.push(f)}null!=l.forChild&&d.set(a.nodeName,l.forChild)}a=a.childNodes;e=[];for(k=0;k<a.length;k++)e.push(...L(a[k],c,d,f));null!=g&&(e=g(e));null==f?b=b.concat(e):v.$isElementNode(f)&&f.append(...e);return b}
+function M(a,c){let d=[];a=a.body?Array.from(a.body.childNodes):[];const e=a.length;for(let f=0;f<e;f++){var b=a[f];A.has(b.nodeName)||(b=L(b,c),null!==b&&(d=d.concat(b)))}return d}
+function C(a,c){if(c.isSelected()&&!c.isSegmented()&&!c.isToken()&&(v.$isRangeSelection(a)||v.$isGridSelection(a))){var d=a.anchor.getNode(),e=a.focus.getNode(),b=c.is(d),f=c.is(e);if(b||f){b=a.isBackward();const [g,l]=a.getCharacterOffsets();a=d.is(e);f=c.is(b?e:d);e=c.is(b?d:e);d=0;let k=void 0;a?(d=g>l?l:g,k=g>l?g:l):f?(d=b?l:g,k=void 0):e&&(b=b?g:l,d=0,k=b);c.__text=c.__text.slice(d,k)}}return c}
+exports.$getHtmlContent=function(a){const c=v.$getSelection();if(null==c)throw Error("Expected valid LexicalSelection");if(v.$isRangeSelection(c)&&c.isCollapsed()||0===c.getNodes().length)return null;const d=document.createElement("div"),e=v.$getRoot().getChildren();for(let b=0;b<e.length;b++)B(a,c,e[b],d);return d.innerHTML};
+exports.$getLexicalContent=function(a){const c=v.$getSelection();if(null!==c){const e=a._config.namespace;var d=v.$getRoot();const b=new Map,f=[];d=d.getChildren();for(let g=0;g<d.length;g++){const l=D(a,c,d[g],b,f,!0);for(let k=0;k<l.length;k++)f.push(l[k])}a={nodeMap:Array.from(b),range:f};return JSON.stringify({namespace:e,state:a})}return null};exports.$insertDataTransferForPlainText=E;
+exports.$insertDataTransferForRichText=function(a,c,d){var e=a.getData("application/x-lexical-editor");const b=v.$isGridSelection(c)||null!==u.$findMatchingParent(c.anchor.getNode(),f=>v.$isGridCellNode(f))&&null!==u.$findMatchingParent(c.focus.getNode(),f=>v.$isGridCellNode(f));if(e){const f=d._config.namespace;try{const g=JSON.parse(e);if(g.namespace===f){const l=I(g.state);if(b&&1===l.length&&v.$isGridNode(l[0])){G(l,c,!1,d);return}F(l,c,!0);return}}catch(g){}}(e=a.getData("text/html"))?(a=(new DOMParser).parseFromString(e,
+"text/html"),a=M(a,d),b&&1===a.length&&v.$isGridNode(a[0])?G(a,c,!1,d):F(a,c,!1)):E(a,c)};

package/package.json

@@ -9,14 +9,14 @@
     "paste"
   ],
   "license": "MIT",
-  "version": "0.2.4",
+  "version": "0.2.7",
   "main": "LexicalClipboard.js",
   "peerDependencies": {
-    "lexical": "0.2.4"
+    "lexical": "0.2.7"
   },
   "dependencies": {
-    "@lexical/utils": "0.2.4",
-    "@lexical/selection": "0.2.4"
+    "@lexical/utils": "0.2.7",
+    "@lexical/selection": "0.2.7"
   },
   "repository": {
     "type": "git",