@lexical/table 0.1.16 → 0.1.19

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2020 Dominic Gannaway
+Copyright (c) Meta Platforms, Inc. and affiliates.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/LexicalTable.d.ts

@@ -1,3 +1,12 @@
+/**
+ * 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 type {
   EditorConfig,
   LexicalNode,
@@ -73,6 +82,8 @@ export declare class TableNode extends ElementNode {
   canInsertTab(): true;
   collapseAtStart(): true;
   getCordsFromCellNode(tableCellNode: TableCellNode): {x: number; y: number};
+  getCellFromCords(x: number, y: number, grid: Grid): ?Cell;
+  getCellFromCordsOrThrow(x: number, y: number, grid: Grid): Cell;
   getCellNodeFromCords(x: number, y: number): TableCellNode | null;
   getCellNodeFromCordsOrThrow(x: number, y: number): TableCellNode;
   setGrid(grid?: Grid): TableNode;
@@ -219,3 +230,8 @@ declare class TableSelection {
   formatCells(type: TextFormatType): void;
   clearText(): void;
 }
+
+export var INSERT_TABLE_COMMAND: LexicalCommand<{
+  rows: string;
+  columns: string;
+}>;

package/LexicalTable.dev.js

@@ -6,8 +6,8 @@
  */
 'use strict';
 
-var utils = require('@lexical/utils');
 var lexical = require('lexical');
+var utils = require('@lexical/utils');
 
 /* eslint-disable sort-keys-fix/sort-keys-fix */
 const TableCellHeaderStates = {
@@ -25,6 +25,19 @@ class TableCellNode extends lexical.GridCellNode {
     return new TableCellNode(node.__headerState, node.__colSpan, node.__width, node.__key);
   }
 
+  static convertDOM() {
+    return {
+      td: node => ({
+        conversion: convertTableCellNodeElement,
+        priority: 0
+      }),
+      th: node => ({
+        conversion: convertTableCellNodeElement,
+        priority: 0
+      })
+    };
+  }
+
   constructor(headerState = TableCellHeaderStates.NO_STATUS, colSpan = 1, width, key) {
     super(colSpan, key);
     this.__headerState = headerState;
@@ -100,6 +113,27 @@ class TableCellNode extends lexical.GridCellNode {
   }
 
 }
+function convertTableCellNodeElement(domNode) {
+  const nodeName = domNode.nodeName.toLowerCase();
+  const tableCellNode = $createTableCellNode(nodeName === 'th' ? TableCellHeaderStates.ROW : TableCellHeaderStates.NO_STATUS);
+  return {
+    node: tableCellNode,
+    forChild: (lexicalNode, parentLexicalNode) => {
+      if ($isTableCellNode(parentLexicalNode) && !lexical.$isElementNode(lexicalNode)) {
+        const paragraphNode = lexical.$createParagraphNode();
+
+        if (lexical.$isLineBreakNode(lexicalNode) && lexicalNode.getTextContent() === '\n') {
+          return null;
+        }
+
+        paragraphNode.append(lexicalNode);
+        return paragraphNode;
+      }
+
+      return lexicalNode;
+    }
+  };
+}
 function $createTableCellNode(headerState, colSpan = 1, width) {
   return new TableCellNode(headerState, colSpan, width);
 }
@@ -131,7 +165,6 @@ const removeHighlightStyle = document.createElement('style');
 removeHighlightStyle.appendChild(document.createTextNode('::selection{background-color: transparent}'));
 class TableSelection {
   constructor(editor, tableNodeKey) {
-    this.isMouseDown = false;
     this.isHighlightingCells = false;
     this.startX = -1;
     this.startY = -1;
@@ -148,6 +181,8 @@ class TableSelection {
     this.gridSelection = null;
     this.anchorCellNodeKey = null;
     this.focusCellNodeKey = null;
+    this.anchorCell = null;
+    this.focusCell = null;
     this.trackTableGrid();
   }
 
@@ -219,14 +254,18 @@ class TableSelection {
 
       const grid = getTableGrid(tableElement);
       this.isHighlightingCells = false;
-      this.isMouseDown = false;
       this.startX = -1;
       this.startY = -1;
       this.currentX = -1;
       this.currentY = -1;
-      $updateDOMForSelection(grid, null);
       this.gridSelection = null;
+      this.anchorCellNodeKey = null;
+      this.focusCellNodeKey = null;
+      this.anchorCell = null;
+      this.focusCell = null;
+      $updateDOMForSelection(grid, null);
       lexical.$setSelection(null);
+      this.editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
       const parent = removeHighlightStyle.parentNode;
 
       if (parent != null) {
@@ -237,7 +276,6 @@ class TableSelection {
 
   adjustFocusCellForSelection(cell, ignoreStart = false) {
     this.editor.update(() => {
-      this.isMouseDown = true;
       const tableNode = lexical.$getNodeByKey(this.tableNodeKey);
 
       if (!$isTableNode(tableNode)) {
@@ -252,16 +290,15 @@ class TableSelection {
 
       const cellX = cell.x;
       const cellY = cell.y;
+      this.focusCell = cell;
+      const domSelection = getDOMSelection();
 
-      if (!this.isHighlightingCells && (this.startX !== cellX || this.startY !== cellY || ignoreStart)) {
-        const domSelection = getDOMSelection();
-        const anchorNode = domSelection.anchorNode;
-
-        if (anchorNode !== null) {
-          // Collapse the selection
-          domSelection.setBaseAndExtent(anchorNode, 0, anchorNode, 0);
-        }
+      if (this.anchorCell !== null) {
+        // Collapse the selection
+        domSelection.setBaseAndExtent(this.anchorCell.elem, 0, cell.elem, 0);
+      }
 
+      if (!this.isHighlightingCells && (this.startX !== cellX || this.startY !== cellY || ignoreStart)) {
         this.isHighlightingCells = true;
 
         if (document.body) {
@@ -284,6 +321,7 @@ class TableSelection {
           this.gridSelection.set(this.tableNodeKey, // $FlowFixMe This is not null, as you can see in the statement above.
           this.anchorCellNodeKey, this.focusCellNodeKey);
           lexical.$setSelection(this.gridSelection);
+          this.editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
           $updateDOMForSelection(this.grid, this.gridSelection);
         }
       }
@@ -292,9 +330,11 @@ class TableSelection {
 
   setAnchorCellForSelection(cell) {
     this.editor.update(() => {
+      this.anchorCell = cell;
       this.startX = cell.x;
       this.startY = cell.y;
-      this.isMouseDown = true;
+      const domSelection = getDOMSelection();
+      domSelection.setBaseAndExtent(cell.elem, 0, cell.elem, 0);
       const anchorTableCellNode = lexical.$getNearestNodeFromDOMNode(cell.elem);
 
       if ($isTableCellNode(anchorTableCellNode)) {
@@ -303,12 +343,6 @@ class TableSelection {
         this.anchorCellNodeKey = anchorNodeKey;
       }
     });
-    document.addEventListener('mouseup', () => {
-      this.isMouseDown = false;
-    }, {
-      capture: true,
-      once: true
-    });
   }
 
   formatCells(type) {
@@ -326,13 +360,14 @@ class TableSelection {
       const anchor = formatSelection.anchor;
       const focus = formatSelection.focus;
       selection.getNodes().forEach(cellNode => {
-        if (lexical.$isElementNode(cellNode) && cellNode.getTextContentSize() !== 0) {
+        if ($isTableCellNode(cellNode) && cellNode.getTextContentSize() !== 0) {
           anchor.set(cellNode.getKey(), 0, 'element');
           focus.set(cellNode.getKey(), cellNode.getChildrenSize(), 'element');
           formatSelection.formatText(type);
         }
       });
       lexical.$setSelection(selection);
+      this.editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
     });
   }
 
@@ -352,7 +387,7 @@ class TableSelection {
         }
       }
 
-      const selectedNodes = selection.getNodes();
+      const selectedNodes = selection.getNodes().filter($isTableCellNode);
 
       if (selectedNodes.length === this.grid.columns * this.grid.rows) {
         tableNode.selectPrevious(); // Delete entire table
@@ -377,6 +412,7 @@ class TableSelection {
       });
       $updateDOMForSelection(this.grid, null);
       lexical.$setSelection(null);
+      this.editor.dispatchCommand(lexical.SELECTION_CHANGE_COMMAND);
     });
   }
 
@@ -401,6 +437,7 @@ function applyTableHandlers(tableNode, tableElement, editor) {
 
   const tableSelection = new TableSelection(editor, tableNode.getKey());
   attachTableSelectionToTableElement(tableElement, tableSelection);
+  let isMouseDown = false;
   tableElement.addEventListener('dblclick', event => {
     // $FlowFixMe: event.target is always a Node on the DOM
     const cell = getCellFromTarget(event.target);
@@ -411,23 +448,34 @@ function applyTableHandlers(tableNode, tableElement, editor) {
       event.stopPropagation();
       tableSelection.setAnchorCellForSelection(cell);
       tableSelection.adjustFocusCellForSelection(cell, true);
-      tableSelection.isMouseDown = false;
+      isMouseDown = false;
     }
   }); // This is the anchor of the selection.
 
   tableElement.addEventListener('mousedown', event => {
     setTimeout(() => {
-      // $FlowFixMe: event.target is always a Node on the DOM
+      if (event.button !== 0) {
+        return;
+      } // $FlowFixMe: event.target is always a Node on the DOM
+
+
       const cell = getCellFromTarget(event.target);
 
       if (cell !== null) {
+        isMouseDown = true;
         tableSelection.setAnchorCellForSelection(cell);
+        document.addEventListener('mouseup', () => {
+          isMouseDown = false;
+        }, {
+          capture: true,
+          once: true
+        });
       }
     }, 0);
   }); // This is adjusting the focus of the selection.
 
   tableElement.addEventListener('mousemove', event => {
-    if (tableSelection.isMouseDown) {
+    if (isMouseDown) {
       // $FlowFixMe: event.target is always a Node on the DOM
       const cell = getCellFromTarget(event.target);
 
@@ -435,30 +483,35 @@ function applyTableHandlers(tableNode, tableElement, editor) {
         const cellX = cell.x;
         const cellY = cell.y;
 
-        if (tableSelection.isMouseDown && (tableSelection.startX !== cellX || tableSelection.startY !== cellY || tableSelection.isHighlightingCells)) {
+        if (isMouseDown && (tableSelection.startX !== cellX || tableSelection.startY !== cellY || tableSelection.isHighlightingCells)) {
           event.preventDefault();
+          isMouseDown = true;
           tableSelection.adjustFocusCellForSelection(cell);
         }
       }
     }
   });
   tableElement.addEventListener('mouseup', event => {
-    if (tableSelection.isMouseDown) {
-      tableSelection.isMouseDown = false;
+    if (isMouseDown) {
+      isMouseDown = false;
     }
   }); // Select entire table at this point, when grid selection is ready.
 
   tableElement.addEventListener('mouseleave', event => {
-    if (tableSelection.isMouseDown) {
+    if (isMouseDown) {
       return;
     }
   }); // Clear selection when clicking outside of dom.
 
-  const mouseDownCallback = e => {
+  const mouseDownCallback = event => {
+    if (event.button !== 0) {
+      return;
+    }
+
     editor.update(() => {
       const selection = lexical.$getSelection();
 
-      if (lexical.$isGridSelection(selection) && selection.gridKey === tableSelection.tableNodeKey && rootElement.contains(e.target)) {
+      if (lexical.$isGridSelection(selection) && selection.gridKey === tableSelection.tableNodeKey && rootElement.contains(event.target)) {
         return tableSelection.clearHighlight();
       }
     });
@@ -466,80 +519,297 @@ function applyTableHandlers(tableNode, tableElement, editor) {
 
   window.addEventListener('mousedown', mouseDownCallback);
   tableSelection.listenersToRemove.add(() => window.removeEventListener('mousedown', mouseDownCallback));
-  tableSelection.listenersToRemove.add(editor.addListener('command', (type, payload) => {
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_ARROW_DOWN_COMMAND, payload => {
     const selection = lexical.$getSelection();
+    const event = payload;
+    const direction = 'down';
 
-    if (lexical.$isGridSelection(selection)) {
-      if (type === 'deleteCharacter' || type === 'keyBackspace') {
-        const event = payload;
-        event.preventDefault();
-        event.stopPropagation();
-        tableSelection.clearText();
-        return true;
-      } else if (type === 'formatText') {
-        tableSelection.formatCells(payload);
-        return true;
-      } else if (type === 'insertText') {
-        tableSelection.clearHighlight();
-        return false;
+    if (lexical.$isRangeSelection(selection)) {
+      if (selection.isCollapsed()) {
+        const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+        if (!$isTableCellNode(tableCellNode)) {
+          return false;
+        }
+
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+
+        if (elementParentNode == null) {
+          throw new Error('Expected BlockNode Parent');
+        }
+
+        const lastChild = tableCellNode.getLastChild();
+        const isSelectionInLastBlock = lastChild && elementParentNode.isParentOf(lastChild) || elementParentNode === lastChild;
+
+        if (isSelectionInLastBlock || event.shiftKey) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          event.stopPropagation(); // Start Selection
+
+          if (event.shiftKey) {
+            tableSelection.setAnchorCellForSelection(tableNode.getCellFromCordsOrThrow(currentCords.x, currentCords.y, tableSelection.grid));
+            return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+          }
+
+          return selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+        }
       }
-    } else if (lexical.$isRangeSelection(selection)) {
-      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+    } else if (lexical.$isGridSelection(selection) && event.shiftKey) {
+      const tableCellNode = selection.focus.getNode();
 
       if (!$isTableCellNode(tableCellNode)) {
         return false;
       }
 
-      if (type === 'deleteCharacter') {
-        if (selection.isCollapsed() && selection.anchor.offset === 0 && selection.anchor.getNode().getPreviousSiblings().length === 0) {
-          return true;
+      const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_ARROW_UP_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+    const event = payload;
+    const direction = 'up';
+
+    if (lexical.$isRangeSelection(selection)) {
+      if (selection.isCollapsed()) {
+        const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+        if (!$isTableCellNode(tableCellNode)) {
+          return false;
         }
-      }
 
-      if (type === 'keyTab') {
-        const event = payload;
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+
+        if (elementParentNode == null) {
+          throw new Error('Expected BlockNode Parent');
+        }
+
+        const lastChild = tableCellNode.getLastChild();
+        const isSelectionInLastBlock = lastChild && elementParentNode.isParentOf(lastChild) || elementParentNode === lastChild;
 
-        if (selection.isCollapsed()) {
-          const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        if (isSelectionInLastBlock || event.shiftKey) {
           event.preventDefault();
-          selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, !event.shiftKey && type === 'keyTab' ? 'forward' : 'backward');
-          return true;
+          event.stopImmediatePropagation();
+          event.stopPropagation(); // Start Selection
+
+          if (event.shiftKey) {
+            tableSelection.setAnchorCellForSelection(tableNode.getCellFromCordsOrThrow(currentCords.x, currentCords.y, tableSelection.grid));
+            return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+          }
+
+          return selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
         }
       }
+    } else if (lexical.$isGridSelection(selection) && event.shiftKey) {
+      const tableCellNode = selection.focus.getNode();
 
-      if (type === 'keyArrowDown' || type === 'keyArrowUp' || type === 'keyArrowLeft' || type === 'keyArrowRight') {
-        const event = payload;
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
 
-        if (selection.isCollapsed()) {
-          const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
-          const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+      const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+    }
 
-          if (elementParentNode == null) {
-            throw new Error('Expected BlockNode Parent');
-          }
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_ARROW_LEFT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+    const event = payload;
+    const direction = 'backward';
+
+    if (lexical.$isRangeSelection(selection)) {
+      if (selection.isCollapsed()) {
+        const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+        if (!$isTableCellNode(tableCellNode)) {
+          return false;
+        }
+
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
 
-          const firstChild = tableCellNode.getFirstChild();
-          const lastChild = tableCellNode.getLastChild();
-          const isSelectionInFirstBlock = firstChild && elementParentNode.isParentOf(firstChild) || elementParentNode === firstChild;
-          const isSelectionInLastBlock = lastChild && elementParentNode.isParentOf(lastChild) || elementParentNode === lastChild;
-
-          if (type === 'keyArrowUp' && isSelectionInFirstBlock || type === 'keyArrowDown' && isSelectionInLastBlock) {
-            event.preventDefault();
-            event.stopImmediatePropagation();
-            event.stopPropagation();
-            selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, type === 'keyArrowUp' ? 'up' : 'down');
-            return true;
+        if (elementParentNode == null) {
+          throw new Error('Expected BlockNode Parent');
+        }
+
+        if (selection.anchor.offset === 0 || event.shiftKey) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          event.stopPropagation(); // Start Selection
+
+          if (event.shiftKey) {
+            tableSelection.setAnchorCellForSelection(tableNode.getCellFromCordsOrThrow(currentCords.x, currentCords.y, tableSelection.grid));
+            return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
           }
 
-          if (type === 'keyArrowLeft' && selection.anchor.offset === 0 || type === 'keyArrowRight' && selection.anchor.offset === selection.anchor.getNode().getTextContentSize()) {
-            event.preventDefault();
-            event.stopImmediatePropagation();
-            event.stopPropagation();
-            selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, type === 'keyArrowLeft' ? 'backward' : 'forward');
-            return true;
+          return selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+        }
+      }
+    } else if (lexical.$isGridSelection(selection) && event.shiftKey) {
+      const tableCellNode = selection.focus.getNode();
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_ARROW_RIGHT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+    const event = payload;
+    const direction = 'forward';
+
+    if (lexical.$isRangeSelection(selection)) {
+      if (selection.isCollapsed()) {
+        const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+        if (!$isTableCellNode(tableCellNode)) {
+          return false;
+        }
+
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        const elementParentNode = utils.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
+
+        if (elementParentNode == null) {
+          throw new Error('Expected BlockNode Parent');
+        }
+
+        if (selection.anchor.offset === selection.anchor.getNode().getTextContentSize() || event.shiftKey) {
+          event.preventDefault();
+          event.stopImmediatePropagation();
+          event.stopPropagation(); // Start Selection
+
+          if (event.shiftKey) {
+            tableSelection.setAnchorCellForSelection(tableNode.getCellFromCordsOrThrow(currentCords.x, currentCords.y, tableSelection.grid));
+            return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
           }
+
+          return selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
         }
       }
+    } else if (lexical.$isGridSelection(selection) && event.shiftKey) {
+      const tableCellNode = selection.focus.getNode();
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+      event.preventDefault();
+      event.stopImmediatePropagation();
+      event.stopPropagation();
+      return adjustFocusNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, direction);
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.DELETE_CHARACTER_COMMAND, () => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isGridSelection(selection)) {
+      tableSelection.clearText();
+      return true;
+    } else if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      if (selection.isCollapsed() && selection.anchor.offset === 0 && selection.anchor.getNode().getPreviousSiblings().length === 0) {
+        return true;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_BACKSPACE_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isGridSelection(selection)) {
+      const event = payload;
+      event.preventDefault();
+      event.stopPropagation();
+      tableSelection.clearText();
+      return true;
+    } else if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.FORMAT_TEXT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isGridSelection(selection)) {
+      tableSelection.formatCells(payload);
+      return true;
+    } else if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.INSERT_TEXT_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isGridSelection(selection)) {
+      tableSelection.clearHighlight();
+      return false;
+    } else if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+    }
+
+    return false;
+  }, CriticalPriority));
+  tableSelection.listenersToRemove.add(editor.registerCommand(lexical.KEY_TAB_COMMAND, payload => {
+    const selection = lexical.$getSelection();
+
+    if (lexical.$isRangeSelection(selection)) {
+      const tableCellNode = utils.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
+
+      if (!$isTableCellNode(tableCellNode)) {
+        return false;
+      }
+
+      const event = payload;
+
+      if (selection.isCollapsed()) {
+        const currentCords = tableNode.getCordsFromCellNode(tableCellNode, tableSelection.grid);
+        event.preventDefault();
+        selectGridNodeInDirection(tableSelection, tableNode, currentCords.x, currentCords.y, !event.shiftKey ? 'forward' : 'backward');
+        return true;
+      }
     }
 
     return false;
@@ -727,6 +997,44 @@ const selectGridNodeInDirection = (tableSelection, tableNode, x, y, direction) =
   return false;
 };
 
+const adjustFocusNodeInDirection = (tableSelection, tableNode, x, y, direction) => {
+  switch (direction) {
+    case 'backward':
+    case 'forward':
+      {
+        const isForward = direction === 'forward';
+
+        if (x !== (isForward ? tableSelection.grid.columns - 1 : 0)) {
+          tableSelection.adjustFocusCellForSelection(tableNode.getCellFromCordsOrThrow(x + (isForward ? 1 : -1), y, tableSelection.grid));
+        }
+
+        return true;
+      }
+
+    case 'up':
+      {
+        if (y !== 0) {
+          tableSelection.adjustFocusCellForSelection(tableNode.getCellFromCordsOrThrow(x, y - 1, tableSelection.grid));
+          return true;
+        } else {
+          return false;
+        }
+      }
+
+    case 'down':
+      {
+        if (y !== tableSelection.grid.rows - 1) {
+          tableSelection.adjustFocusCellForSelection(tableNode.getCellFromCordsOrThrow(x, y + 1, tableSelection.grid));
+          return true;
+        } else {
+          return false;
+        }
+      }
+  }
+
+  return false;
+};
+
 function selectTableCellNode(tableCell) {
   const possibleParagraph = tableCell.getChildren().find(n => lexical.$isParagraphNode(n));
 
@@ -754,6 +1062,15 @@ class TableNode extends lexical.GridNode {
     return new TableNode(node.__key);
   }
 
+  static convertDOM() {
+    return {
+      table: node => ({
+        conversion: convertTableElement,
+        priority: 0
+      })
+    };
+  }
+
   constructor(key) {
     super(key);
   }
@@ -811,7 +1128,7 @@ class TableNode extends lexical.GridNode {
     throw new Error('Cell not found in table.');
   }
 
-  getCellNodeFromCords(x, y, grid) {
+  getCellFromCords(x, y, grid) {
     if (!grid) {
       throw Error(`Grid not found.`);
     }
@@ -831,6 +1148,26 @@ class TableNode extends lexical.GridNode {
       return null;
     }
 
+    return cell;
+  }
+
+  getCellFromCordsOrThrow(x, y, grid) {
+    const cell = this.getCellFromCords(x, y, grid);
+
+    if (!cell) {
+      throw new Error('Cell not found at cords.');
+    }
+
+    return cell;
+  }
+
+  getCellNodeFromCords(x, y, grid) {
+    const cell = this.getCellFromCords(x, y, grid);
+
+    if (cell == null) {
+      return null;
+    }
+
     const node = lexical.$getNearestNodeFromDOMNode(cell.elem);
 
     if ($isTableCellNode(node)) {
@@ -864,6 +1201,11 @@ function $getElementGridForTableNode(editor, tableNode) {
 
   return getTableGrid(tableElement);
 }
+function convertTableElement(domNode) {
+  return {
+    node: $createTableNode()
+  };
+}
 function $createTableNode() {
   return new TableNode();
 }
@@ -888,6 +1230,15 @@ class TableRowNode extends lexical.GridRowNode {
     return new TableRowNode(node.__height, node.__key);
   }
 
+  static convertDOM() {
+    return {
+      tr: node => ({
+        conversion: convertTableRowElement,
+        priority: 0
+      })
+    };
+  }
+
   constructor(height, key) {
     super(key);
     this.__height = height;
@@ -923,6 +1274,11 @@ class TableRowNode extends lexical.GridRowNode {
   }
 
 }
+function convertTableRowElement(domNode) {
+  return {
+    node: $createTableRowNode()
+  };
+}
 function $createTableRowNode(height) {
   return new TableRowNode(height);
 }
@@ -1129,6 +1485,16 @@ function $deleteTableColumn(tableNode, targetIndex) {
   return tableNode;
 }
 
+/**
+ * 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 INSERT_TABLE_COMMAND = lexical.createCommand();
+
 exports.$createTableCellNode = $createTableCellNode;
 exports.$createTableNode = $createTableNode;
 exports.$createTableNodeWithDimensions = $createTableNodeWithDimensions;
@@ -1146,6 +1512,7 @@ exports.$isTableCellNode = $isTableCellNode;
 exports.$isTableNode = $isTableNode;
 exports.$isTableRowNode = $isTableRowNode;
 exports.$removeTableRowAtIndex = $removeTableRowAtIndex;
+exports.INSERT_TABLE_COMMAND = INSERT_TABLE_COMMAND;
 exports.TableCellHeaderStates = TableCellHeaderStates;
 exports.TableCellNode = TableCellNode;
 exports.TableNode = TableNode;

package/LexicalTable.js.flow

@@ -0,0 +1,246 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+import type {
+  EditorConfig,
+  LexicalNode,
+  NodeKey,
+  ParagraphNode,
+  RangeSelection,
+  LexicalEditor,
+  TextFormatType,
+  LexicalCommand,
+} from 'lexical';
+
+import {ElementNode} from 'lexical';
+
+/**
+ * LexicalTableCellNode
+ */
+
+export const TableCellHeaderStates = {
+  NO_STATUS: 0,
+  ROW: 1,
+  COLUMN: 2,
+  BOTH: 3,
+};
+
+export type TableCellHeaderState = $Values<typeof TableCellHeaderStates>;
+
+declare export class TableCellNode extends ElementNode {
+  static getType(): string;
+  static clone(node: TableCellNode): TableCellNode;
+  constructor(
+    headerState?: TableCellHeaderState,
+    colSpan?: number,
+    width?: ?number,
+    key?: NodeKey,
+  ): void;
+  __headerState: TableCellHeaderState;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM(prevNode: TableCellNode, dom: HTMLElement): boolean;
+  insertNewAfter(
+    selection: RangeSelection,
+  ): null | ParagraphNode | TableCellNode;
+  canInsertTab(): true;
+  collapseAtStart(): true;
+  getTag(): string;
+  setHeaderStyles(headerState: TableCellHeaderState): TableCellHeaderState;
+  getHeaderStyles(): TableCellHeaderState;
+  setWidth(width: number): ?number;
+  getWidth(): ?number;
+  toggleHeaderStyle(headerState: TableCellHeaderState): TableCellNode;
+  hasHeader(): boolean;
+  updateDOM(prevNode: TableCellNode): boolean;
+  collapseAtStart(): true;
+  canBeEmpty(): false;
+}
+declare export function $createTableCellNode(
+  headerState: TableCellHeaderState,
+  colSpan?: number,
+  width?: ?number,
+): TableCellNode;
+declare export function $isTableCellNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof TableCellNode);
+
+/**
+ * LexicalTableNode
+ */
+
+declare export class TableNode extends ElementNode {
+  static getType(): string;
+  static clone(node: TableNode): TableNode;
+  constructor(grid: ?Grid, key?: NodeKey): void;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM(prevNode: TableNode, dom: HTMLElement): boolean;
+  insertNewAfter(selection: RangeSelection): null | ParagraphNode | TableNode;
+  canInsertTab(): true;
+  collapseAtStart(): true;
+  getCordsFromCellNode(
+    tableCellNode: TableCellNode,
+    grid: Grid,
+  ): {x: number, y: number};
+  getCellFromCords(x: number, y: number, grid: Grid): ?Cell;
+  getCellFromCordsOrThrow(x: number, y: number, grid: Grid): Cell;
+  getCellNodeFromCords(x: number, y: number, grid: Grid): ?TableCellNode;
+  getCellNodeFromCordsOrThrow(x: number, y: number, grid: Grid): TableCellNode;
+  setGrid(grid: ?Grid): TableNode;
+  getGrid(): ?Grid;
+  canSelectBefore(): true;
+}
+declare export function $createTableNode(): TableNode;
+declare export function $isTableNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof TableNode);
+
+/**
+ * LexicalTableRowNode
+ */
+
+declare export class TableRowNode extends ElementNode {
+  static getType(): string;
+  static clone(node: TableRowNode): TableRowNode;
+  constructor(height?: ?number, key?: NodeKey): void;
+  createDOM<EditorContext>(config: EditorConfig<EditorContext>): HTMLElement;
+  updateDOM(prevNode: TableRowNode, dom: HTMLElement): boolean;
+  setHeight(height: number): ?number;
+  getHeight(): ?number;
+  insertNewAfter(
+    selection: RangeSelection,
+  ): null | ParagraphNode | TableRowNode;
+  canInsertTab(): true;
+  collapseAtStart(): true;
+}
+declare export function $createTableRowNode(): TableRowNode;
+declare export function $isTableRowNode(
+  node: ?LexicalNode,
+): boolean %checks(node instanceof TableRowNode);
+
+/**
+ * LexicalTableSelectionHelpers
+ */
+
+export type Cell = {
+  elem: HTMLElement,
+  highlighted: boolean,
+  x: number,
+  y: number,
+};
+
+export type Cells = Array<Array<Cell>>;
+
+export type Grid = {
+  cells: Cells,
+  columns: number,
+  rows: number,
+};
+
+declare export function applyTableHandlers(
+  tableNode: TableNode,
+  tableElement: HTMLElement,
+  editor: LexicalEditor,
+): TableSelection;
+
+declare export function $getElementGridForTableNode(
+  editor: LexicalEditor,
+  tableNode: TableNode,
+): Grid;
+
+declare export function getTableSelectionFromTableElement(
+  tableElement: HTMLElement,
+): TableSelection;
+
+declare export function getCellFromTarget(node: Node): Cell | null;
+
+/**
+ * LexicalTableUtils
+ */
+
+declare export function $createTableNodeWithDimensions(
+  rowCount: number,
+  columnCount: number,
+  includeHeaders?: boolean,
+): TableNode;
+
+declare export function $getTableCellNodeFromLexicalNode(
+  startingNode: LexicalNode,
+): TableCellNode | null;
+
+declare export function $getTableRowNodeFromTableCellNodeOrThrow(
+  startingNode: LexicalNode,
+): TableRowNode;
+
+declare export function $getTableNodeFromLexicalNodeOrThrow(
+  startingNode: LexicalNode,
+): TableNode;
+
+declare export function $getTableRowIndexFromTableCellNode(
+  tableCellNode: TableCellNode,
+): number;
+
+declare export function $getTableColumnIndexFromTableCellNode(
+  tableCellNode: TableCellNode,
+): number;
+
+declare export function $removeTableRowAtIndex(
+  tableNode: TableNode,
+  indexToDelete: number,
+): TableNode;
+
+declare export function $insertTableRow(
+  tableNode: TableNode,
+  targetIndex: number,
+  shouldInsertAfter?: boolean,
+  rowCount: number,
+  grid: Grid,
+): TableNode;
+
+declare export function $insertTableColumn(
+  tableNode: TableNode,
+  targetIndex: number,
+  shouldInsertAfter?: boolean,
+  columnCount: number,
+): TableNode;
+
+declare export function $deleteTableColumn(
+  tableNode: TableNode,
+  targetIndex: number,
+): TableNode;
+
+/**
+ * LexicalTableSelection.js
+ */
+declare export class TableSelection {
+  currentX: number;
+  currentY: number;
+  listenersToRemove: Set<() => void>;
+  domListeners: Set<() => void>;
+  grid: Grid;
+  isHighlightingCells: boolean;
+  isMouseDown: boolean;
+  startX: number;
+  startY: number;
+  nodeKey: string;
+  editor: LexicalEditor;
+  constructor(editor: LexicalEditor, nodeKey: string): void;
+  getGrid(): Grid;
+  removeListeners(): void;
+  trackTableGrid(): void;
+  clearHighlight(): void;
+  adjustFocusCellForSelection(cell: Cell): void;
+  setAnchorCellForSelection(cell: Cell): void;
+  formatCells(type: TextFormatType): void;
+  clearText(): void;
+}
+
+declare export var INSERT_TABLE_COMMAND: LexicalCommand<{
+  rows: string,
+  columns: string,
+}>;

package/LexicalTable.prod.js

@@ -4,35 +4,45 @@
  * 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/utils"),n=require("lexical");const r={NO_STATUS:0,ROW:1,COLUMN:2,BOTH:3};
-class u extends n.GridCellNode{static getType(){return"tablecell"}static clone(a){return new u(a.__headerState,a.__colSpan,a.__width,a.__key)}constructor(a=r.NO_STATUS,b=1,d,f){super(b,f);this.__headerState=a;this.__width=d}createDOM(a){const b=document.createElement(this.getTag());this.__width&&(b.style.width=`${this.__width}px`);k.addClassNamesToElement(b,a.theme.tableCell,this.hasHeader()&&a.theme.tableCellHeader);return b}getTag(){return this.hasHeader()?"th":"td"}setHeaderStyles(a){this.getWritable().__headerState=
-a;return this.__headerState}getHeaderStyles(){return this.getLatest().__headerState}setWidth(a){this.getWritable().__width=a;return this.__width}getWidth(){return this.getLatest().__width}toggleHeaderStyle(a){const b=this.getWritable();b.__headerState=(b.__headerState&a)===a?b.__headerState-a:b.__headerState+a;b.__headerState=b.__headerState;return b}hasHeaderState(a){return(this.getHeaderStyles()&a)===a}hasHeader(){return this.getLatest().__headerState!==r.NO_STATUS}updateDOM(a){return a.__headerState!==
-this.__headerState||a.__width!==this.__width}collapseAtStart(){return!0}canBeEmpty(){return!1}}function v(a,b=1,d){return new u(a,b,d)}function w(a){return a instanceof u}function y(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 z=document.createElement("style");z.appendChild(document.createTextNode("::selection{background-color: transparent}"));
-class A{constructor(a,b){this.isHighlightingCells=this.isMouseDown=!1;this.currentY=this.currentX=this.startY=this.startX=-1;this.listenersToRemove=new Set;this.tableNodeKey=b;this.editor=a;this.grid={cells:[],columns:0,rows:0};this.focusCellNodeKey=this.anchorCellNodeKey=this.gridSelection=null;this.trackTableGrid()}getGrid(){return this.grid}removeListeners(){Array.from(this.listenersToRemove).forEach(a=>a())}trackTableGrid(){const a=new MutationObserver(b=>{this.editor.update(()=>{var d=!1;for(let f=
-0;f<b.length;f++){const c=b[f].target.nodeName;if("TABLE"===c||"TR"===c){d=!0;break}}if(d){d=this.editor.getElementByKey(this.tableNodeKey);if(!d)throw Error("Expected to find TableElement in DOM");this.grid=B(d)}})});this.editor.update(()=>{const b=this.editor.getElementByKey(this.tableNodeKey);if(!b)throw Error("Expected to find TableElement in DOM");this.grid=B(b);a.observe(b,{childList:!0,subtree:!0})})}clearHighlight(){this.editor.update(()=>{var a=n.$getNodeByKey(this.tableNodeKey);if(!C(a))throw Error("Expected TableNode.");
-a=this.editor.getElementByKey(this.tableNodeKey);if(!a)throw Error("Expected to find TableElement in DOM");a=B(a);this.isMouseDown=this.isHighlightingCells=!1;this.currentY=this.currentX=this.startY=this.startX=-1;D(a,null);this.gridSelection=null;n.$setSelection(null);a=z.parentNode;null!=a&&a.removeChild(z)})}adjustFocusCellForSelection(a,b=!1){this.editor.update(()=>{this.isMouseDown=!0;var d=n.$getNodeByKey(this.tableNodeKey);if(!C(d))throw Error("Expected TableNode.");if(!this.editor.getElementByKey(this.tableNodeKey))throw Error("Expected to find TableElement in DOM");
-d=a.x;const f=a.y;if(!this.isHighlightingCells&&(this.startX!==d||this.startY!==f||b)){const c=window.getSelection(),g=c.anchorNode;null!==g&&c.setBaseAndExtent(g,0,g,0);this.isHighlightingCells=!0;document.body&&document.body.appendChild(z)}else if(d===this.currentX&&f===this.currentY)return;this.currentX=d;this.currentY=f;this.isHighlightingCells&&(d=n.$getNearestNodeFromDOMNode(a.elem),null!=this.gridSelection&&null!=this.anchorCellNodeKey&&w(d)&&(d=d.getKey(),this.gridSelection=n.$createGridSelection(),
-this.focusCellNodeKey=d,this.gridSelection.set(this.tableNodeKey,this.anchorCellNodeKey,this.focusCellNodeKey),n.$setSelection(this.gridSelection),D(this.grid,this.gridSelection)))})}setAnchorCellForSelection(a){this.editor.update(()=>{this.startX=a.x;this.startY=a.y;this.isMouseDown=!0;var b=n.$getNearestNodeFromDOMNode(a.elem);w(b)&&(b=b.getKey(),this.gridSelection=n.$createGridSelection(),this.anchorCellNodeKey=b)});document.addEventListener("mouseup",()=>{this.isMouseDown=!1},{capture:!0,once:!0})}formatCells(a){this.editor.update(()=>
-{const b=n.$getSelection();if(!n.$isGridSelection(b))throw Error("Expected grid selection");const d=n.$createRangeSelection(),f=d.anchor,c=d.focus;b.getNodes().forEach(g=>{n.$isElementNode(g)&&0!==g.getTextContentSize()&&(f.set(g.getKey(),0,"element"),c.set(g.getKey(),g.getChildrenSize(),"element"),d.formatText(a))});n.$setSelection(b)})}clearText(){this.editor.update(()=>{const a=n.$getNodeByKey(this.tableNodeKey);if(!C(a))throw Error("Expected TableNode.");var b=n.$getSelection();if(!n.$isGridSelection(b))throw Error("Expected grid selection");
-b=b.getNodes();b.length===this.grid.columns*this.grid.rows?(a.selectPrevious(),a.remove(),this.clearHighlight()):(b.forEach(d=>{if(n.$isElementNode(d)){const f=n.$createParagraphNode(),c=n.$createTextNode();f.append(c);d.append(f);d.getChildren().forEach(g=>{g!==f&&g.remove()})}}),D(this.grid,null),n.$setSelection(null))})}}function E(a){for(;null!=a;){const b=a.nodeName;if("TD"===b||"TH"===b){a=a._cell;if(void 0===a)break;return a}a=a.parentNode}return null}
-function B(a){const b=[],d={cells:b,columns:0,rows:0};var f=a.firstChild;let c=a=0;for(b.length=0;null!=f;){var g=f.nodeName;if("TD"===g||"TH"===g)g={elem:f,highlighted:!1,x:a,y:c},f._cell=g,void 0===b[c]&&(b[c]=[]),b[c][a]=g;else if(g=f.firstChild,null!=g){f=g;continue}g=f.nextSibling;if(null!=g)a++,f=g;else if(g=f.parentNode,null!=g){f=g.nextSibling;if(null==f)break;c++;a=0}}d.columns=a+1;d.rows=c+1;return d}
-function D(a,b){const d=[];({cells:a}=a);b=new Set(b?b.getNodes():[]);for(let f=0;f<a.length;f++){const c=a[f];for(let g=0;g<c.length;g++){const e=c[g],h=e.elem.style,l=n.$getNearestNodeFromDOMNode(e.elem);l&&b.has(l)?(e.highlighted=!0,h.setProperty("background-color","rgb(163, 187, 255)"),h.setProperty("caret-color","transparent"),d.push(e)):(e.highlighted=!1,h.removeProperty("background-color"),h.removeProperty("caret-color"),e.elem.getAttribute("style")||e.elem.removeAttribute("style"))}}return d}
-const J=(a,b,d,f,c)=>{switch(c){case "backward":case "forward":return c="forward"===c,d!==(c?a.grid.columns-1:0)?F(b.getCellNodeFromCordsOrThrow(d+(c?1:-1),f,a.grid)):f!==(c?a.grid.rows-1:0)?F(b.getCellNodeFromCordsOrThrow(c?0:a.grid.columns-1,f+(c?1:-1),a.grid)):c?b.selectNext():b.selectPrevious(),!0;case "up":return 0!==f?F(b.getCellNodeFromCordsOrThrow(d,f-1,a.grid)):b.selectPrevious(),!0;case "down":return f!==a.grid.rows-1?F(b.getCellNodeFromCordsOrThrow(d,f+1,a.grid)):b.selectNext(),!0}return!1};
-function F(a){const b=a.getChildren().find(d=>n.$isParagraphNode(d));n.$isParagraphNode(b)?b.selectEnd():a.selectEnd()}
-class K extends n.GridNode{static getType(){return"table"}static clone(a){return new K(a.__key)}constructor(a){super(a)}createDOM(a){const b=document.createElement("table");k.addClassNamesToElement(b,a.theme.table);return b}updateDOM(){return!1}canExtractContents(){return!1}canBeEmpty(){return!1}getCordsFromCellNode(a,b){b||y(55);const {rows:d,cells:f}=b;for(b=0;b<d;b++){var c=f[b];if(null==c)throw Error(`Row not found at y:${b}`);c=c.findIndex(({elem:g})=>n.$getNearestNodeFromDOMNode(g)===a);if(-1!==
-c)return{x:c,y:b}}throw Error("Cell not found in table.");}getCellNodeFromCords(a,b,d){d||y(55);({cells:d}=d);b=d[b];if(null==b)return null;a=b[a];if(null==a)return null;a=n.$getNearestNodeFromDOMNode(a.elem);return w(a)?a:null}getCellNodeFromCordsOrThrow(a,b,d){a=this.getCellNodeFromCords(a,b,d);if(!a)throw Error("Node at cords not TableCellNode.");return a}canSelectBefore(){return!0}}function L(){return new K}function C(a){return a instanceof K}
-class M extends n.GridRowNode{static getType(){return"tablerow"}static clone(a){return new M(a.__height,a.__key)}constructor(a,b){super(b);this.__height=a}createDOM(a){const b=document.createElement("tr");this.__height&&(b.style.height=`${this.__height}px`);k.addClassNamesToElement(b,a.theme.tableRow);return b}setHeight(a){this.getWritable().__height=a;return this.__height}getHeight(){return this.getLatest().__height}updateDOM(a){return a.__height!==this.__height}canBeEmpty(){return!1}}
-function N(a){return new M(a)}function O(a){return a instanceof M}function P(a){a=k.$findMatchingParent(a,b=>O(b));if(O(a))return a;throw Error("Expected table cell to be inside of table row.");}function Q(a){a=k.$findMatchingParent(a,b=>C(b));if(C(a))return a;throw Error("Expected table cell to be inside of table.");}exports.$createTableCellNode=v;exports.$createTableNode=L;
-exports.$createTableNodeWithDimensions=function(a,b,d=!0){const f=L();for(let g=0;g<a;g++){const e=N();for(let h=0;h<b;h++){var c=r.NO_STATUS;d&&(0===g&&(c|=r.ROW),0===h&&(c|=r.COLUMN));c=v(c);const l=n.$createParagraphNode();l.append(n.$createTextNode());c.append(l);e.append(c)}f.append(e)}return f};exports.$createTableRowNode=N;
-exports.$deleteTableColumn=function(a,b){const d=a.getChildren();for(let c=0;c<d.length;c++){var f=d[c];if(O(f)){f=f.getChildren();if(b>=f.length||0>b)throw Error("Table column target index out of range");f[b].remove()}}return a};exports.$getElementGridForTableNode=function(a,b){a=a.getElementByKey(b.getKey());if(null==a)throw Error("Table Element Not Found");return B(a)};exports.$getTableCellNodeFromLexicalNode=function(a){a=k.$findMatchingParent(a,b=>w(b));return w(a)?a:null};
-exports.$getTableColumnIndexFromTableCellNode=function(a){return P(a).getChildren().findIndex(b=>b.is(a))};exports.$getTableNodeFromLexicalNodeOrThrow=Q;exports.$getTableRowIndexFromTableCellNode=function(a){const b=P(a);return Q(b).getChildren().findIndex(d=>d.is(b))};exports.$getTableRowNodeFromTableCellNodeOrThrow=P;
-exports.$insertTableColumn=function(a,b,d=!0,f){const c=a.getChildren();for(let h=0;h<c.length;h++){const l=c[h];if(O(l))for(let m=0;m<f;m++){var g=r.NO_STATUS;0===h&&(g|=r.ROW);g=v(g);g.append(n.$createParagraphNode());var e=l.getChildren();if(b>=e.length||0>b)throw Error("Table column target index out of range");e=e[b];d?e.insertAfter(g):e.insertBefore(g)}}return a};
-exports.$insertTableRow=function(a,b,d=!0,f,c){var g=a.getChildren();if(b>=g.length||0>b)throw Error("Table row target index out of range");b=g[b];if(O(b))for(g=0;g<f;g++){const l=b.getChildren(),m=l.length,q=N();for(let t=0;t<m;t++){var e=l[t];if(!w(e))throw Error("Expected table cell");var h=c;const p=Q(e),{x,y:G}=p.getCordsFromCellNode(e,h);e={above:p.getCellNodeFromCords(x,G-1,h),below:p.getCellNodeFromCords(x,G+1,h),left:p.getCellNodeFromCords(x-1,G,h),right:p.getCellNodeFromCords(x+1,G,h)};
-const {above:H,below:I}=e;e=r.NO_STATUS;h=H&&H.getWidth()||I&&I.getWidth()||null;if(H&&H.hasHeaderState(r.COLUMN)||I&&I.hasHeaderState(r.COLUMN))e|=r.COLUMN;e=v(e,1,h);e.append(n.$createParagraphNode());q.append(e)}d?b.insertAfter(q):b.insertBefore(q)}else throw Error("Row before insertion index does not exist.");return a};exports.$isTableCellNode=w;exports.$isTableNode=C;exports.$isTableRowNode=O;
-exports.$removeTableRowAtIndex=function(a,b){const d=a.getChildren();if(b>=d.length||0>b)throw Error("Expected table cell to be inside of table row.");d[b].remove();return a};exports.TableCellHeaderStates=r;exports.TableCellNode=u;exports.TableNode=K;exports.TableRowNode=M;exports.TableSelection=A;
-exports.applyTableHandlers=function(a,b,d){const f=d.getRootElement();if(null===f)throw Error("No root element.");const c=new A(d,a.getKey());b.__lexicalTableSelection=c;b.addEventListener("dblclick",e=>{const h=E(e.target);null!==h&&(e.preventDefault(),e.stopImmediatePropagation(),e.stopPropagation(),c.setAnchorCellForSelection(h),c.adjustFocusCellForSelection(h,!0),c.isMouseDown=!1)});b.addEventListener("mousedown",e=>{setTimeout(()=>{const h=E(e.target);null!==h&&c.setAnchorCellForSelection(h)},
-0)});b.addEventListener("mousemove",e=>{if(c.isMouseDown){const h=E(e.target);if(null!==h){const l=h.x,m=h.y;c.isMouseDown&&(c.startX!==l||c.startY!==m||c.isHighlightingCells)&&(e.preventDefault(),c.adjustFocusCellForSelection(h))}}});b.addEventListener("mouseup",()=>{c.isMouseDown&&(c.isMouseDown=!1)});b.addEventListener("mouseleave",()=>{});const g=e=>{d.update(()=>{const h=n.$getSelection();if(n.$isGridSelection(h)&&h.gridKey===c.tableNodeKey&&f.contains(e.target))return c.clearHighlight()})};
-window.addEventListener("mousedown",g);c.listenersToRemove.add(()=>window.removeEventListener("mousedown",g));c.listenersToRemove.add(d.addListener("command",(e,h)=>{var l=n.$getSelection();if(n.$isGridSelection(l)){if("deleteCharacter"===e||"keyBackspace"===e)return h.preventDefault(),h.stopPropagation(),c.clearText(),!0;if("formatText"===e)return c.formatCells(h),!0;"insertText"===e&&c.clearHighlight()}else if(n.$isRangeSelection(l)){var m=k.$findMatchingParent(l.anchor.getNode(),p=>w(p));if(!w(m))return!1;
-if("deleteCharacter"===e&&l.isCollapsed()&&0===l.anchor.offset&&0===l.anchor.getNode().getPreviousSiblings().length)return!0;if("keyTab"===e&&l.isCollapsed())return l=a.getCordsFromCellNode(m,c.grid),h.preventDefault(),J(c,a,l.x,l.y,h.shiftKey||"keyTab"!==e?"backward":"forward"),!0;if(("keyArrowDown"===e||"keyArrowUp"===e||"keyArrowLeft"===e||"keyArrowRight"===e)&&l.isCollapsed()){const p=a.getCordsFromCellNode(m,c.grid);var q=k.$findMatchingParent(l.anchor.getNode(),x=>n.$isElementNode(x));if(null==
-q)throw Error("Expected BlockNode Parent");var t=m.getFirstChild();m=m.getLastChild();t=t&&q.isParentOf(t)||q===t;q=m&&q.isParentOf(m)||q===m;if("keyArrowUp"===e&&t||"keyArrowDown"===e&&q)return h.preventDefault(),h.stopImmediatePropagation(),h.stopPropagation(),J(c,a,p.x,p.y,"keyArrowUp"===e?"up":"down"),!0;if("keyArrowLeft"===e&&0===l.anchor.offset||"keyArrowRight"===e&&l.anchor.offset===l.anchor.getNode().getTextContentSize())return h.preventDefault(),h.stopImmediatePropagation(),h.stopPropagation(),
-J(c,a,p.x,p.y,"keyArrowLeft"===e?"backward":"forward"),!0}}return!1},4));return c};exports.getCellFromTarget=E;exports.getTableSelectionFromTableElement=function(a){return a.__lexicalTableSelection};
+var g=require("lexical"),n=require("@lexical/utils");const q={NO_STATUS:0,ROW:1,COLUMN:2,BOTH:3};
+class r extends g.GridCellNode{static getType(){return"tablecell"}static clone(a){return new r(a.__headerState,a.__colSpan,a.__width,a.__key)}static convertDOM(){return{td:()=>({conversion:u,priority:0}),th:()=>({conversion:u,priority:0})}}constructor(a=q.NO_STATUS,b=1,f,h){super(b,h);this.__headerState=a;this.__width=f}createDOM(a){const b=document.createElement(this.getTag());this.__width&&(b.style.width=`${this.__width}px`);n.addClassNamesToElement(b,a.theme.tableCell,this.hasHeader()&&a.theme.tableCellHeader);
+return b}getTag(){return this.hasHeader()?"th":"td"}setHeaderStyles(a){this.getWritable().__headerState=a;return this.__headerState}getHeaderStyles(){return this.getLatest().__headerState}setWidth(a){this.getWritable().__width=a;return this.__width}getWidth(){return this.getLatest().__width}toggleHeaderStyle(a){const b=this.getWritable();b.__headerState=(b.__headerState&a)===a?b.__headerState-a:b.__headerState+a;b.__headerState=b.__headerState;return b}hasHeaderState(a){return(this.getHeaderStyles()&
+a)===a}hasHeader(){return this.getLatest().__headerState!==q.NO_STATUS}updateDOM(a){return a.__headerState!==this.__headerState||a.__width!==this.__width}collapseAtStart(){return!0}canBeEmpty(){return!1}}function u(a){a=a.nodeName.toLowerCase();return{node:v("th"===a?q.ROW:q.NO_STATUS),forChild:(b,f)=>{if(w(f)&&!g.$isElementNode(b)){f=g.$createParagraphNode();if(g.$isLineBreakNode(b)&&"\n"===b.getTextContent())return null;f.append(b);return f}return b}}}function v(a,b=1,f){return new r(a,b,f)}
+function w(a){return a instanceof r}function x(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 y=document.createElement("style");y.appendChild(document.createTextNode("::selection{background-color: transparent}"));
+class z{constructor(a,b){this.isHighlightingCells=!1;this.currentY=this.currentX=this.startY=this.startX=-1;this.listenersToRemove=new Set;this.tableNodeKey=b;this.editor=a;this.grid={cells:[],columns:0,rows:0};this.focusCell=this.anchorCell=this.focusCellNodeKey=this.anchorCellNodeKey=this.gridSelection=null;this.trackTableGrid()}getGrid(){return this.grid}removeListeners(){Array.from(this.listenersToRemove).forEach(a=>a())}trackTableGrid(){const a=new MutationObserver(b=>{this.editor.update(()=>
+{var f=!1;for(let h=0;h<b.length;h++){const c=b[h].target.nodeName;if("TABLE"===c||"TR"===c){f=!0;break}}if(f){f=this.editor.getElementByKey(this.tableNodeKey);if(!f)throw Error("Expected to find TableElement in DOM");this.grid=B(f)}})});this.editor.update(()=>{const b=this.editor.getElementByKey(this.tableNodeKey);if(!b)throw Error("Expected to find TableElement in DOM");this.grid=B(b);a.observe(b,{childList:!0,subtree:!0})})}clearHighlight(){this.editor.update(()=>{var a=g.$getNodeByKey(this.tableNodeKey);
+if(!C(a))throw Error("Expected TableNode.");a=this.editor.getElementByKey(this.tableNodeKey);if(!a)throw Error("Expected to find TableElement in DOM");a=B(a);this.isHighlightingCells=!1;this.currentY=this.currentX=this.startY=this.startX=-1;this.focusCell=this.anchorCell=this.focusCellNodeKey=this.anchorCellNodeKey=this.gridSelection=null;D(a,null);g.$setSelection(null);this.editor.dispatchCommand(g.SELECTION_CHANGE_COMMAND);a=y.parentNode;null!=a&&a.removeChild(y)})}adjustFocusCellForSelection(a,
+b=!1){this.editor.update(()=>{var f=g.$getNodeByKey(this.tableNodeKey);if(!C(f))throw Error("Expected TableNode.");if(!this.editor.getElementByKey(this.tableNodeKey))throw Error("Expected to find TableElement in DOM");f=a.x;const h=a.y;this.focusCell=a;const c=window.getSelection();null!==this.anchorCell&&c.setBaseAndExtent(this.anchorCell.elem,0,a.elem,0);if(!this.isHighlightingCells&&(this.startX!==f||this.startY!==h||b))this.isHighlightingCells=!0,document.body&&document.body.appendChild(y);else if(f===
+this.currentX&&h===this.currentY)return;this.currentX=f;this.currentY=h;this.isHighlightingCells&&(f=g.$getNearestNodeFromDOMNode(a.elem),null!=this.gridSelection&&null!=this.anchorCellNodeKey&&w(f)&&(f=f.getKey(),this.gridSelection=g.$createGridSelection(),this.focusCellNodeKey=f,this.gridSelection.set(this.tableNodeKey,this.anchorCellNodeKey,this.focusCellNodeKey),g.$setSelection(this.gridSelection),this.editor.dispatchCommand(g.SELECTION_CHANGE_COMMAND),D(this.grid,this.gridSelection)))})}setAnchorCellForSelection(a){this.editor.update(()=>
+{this.anchorCell=a;this.startX=a.x;this.startY=a.y;window.getSelection().setBaseAndExtent(a.elem,0,a.elem,0);var b=g.$getNearestNodeFromDOMNode(a.elem);w(b)&&(b=b.getKey(),this.gridSelection=g.$createGridSelection(),this.anchorCellNodeKey=b)})}formatCells(a){this.editor.update(()=>{const b=g.$getSelection();g.$isGridSelection(b)||x(79);const f=g.$createRangeSelection(),h=f.anchor,c=f.focus;b.getNodes().forEach(k=>{w(k)&&0!==k.getTextContentSize()&&(h.set(k.getKey(),0,"element"),c.set(k.getKey(),k.getChildrenSize(),
+"element"),f.formatText(a))});g.$setSelection(b);this.editor.dispatchCommand(g.SELECTION_CHANGE_COMMAND)})}clearText(){this.editor.update(()=>{const a=g.$getNodeByKey(this.tableNodeKey);if(!C(a))throw Error("Expected TableNode.");var b=g.$getSelection();g.$isGridSelection(b)||x(79);b=b.getNodes().filter(w);b.length===this.grid.columns*this.grid.rows?(a.selectPrevious(),a.remove(),this.clearHighlight()):(b.forEach(f=>{if(g.$isElementNode(f)){const h=g.$createParagraphNode(),c=g.$createTextNode();h.append(c);
+f.append(h);f.getChildren().forEach(k=>{k!==h&&k.remove()})}}),D(this.grid,null),g.$setSelection(null),this.editor.dispatchCommand(g.SELECTION_CHANGE_COMMAND))})}}function E(a){for(;null!=a;){const b=a.nodeName;if("TD"===b||"TH"===b){a=a._cell;if(void 0===a)break;return a}a=a.parentNode}return null}
+function B(a){const b=[],f={cells:b,columns:0,rows:0};var h=a.firstChild;let c=a=0;for(b.length=0;null!=h;){var k=h.nodeName;if("TD"===k||"TH"===k)k={elem:h,highlighted:!1,x:a,y:c},h._cell=k,void 0===b[c]&&(b[c]=[]),b[c][a]=k;else if(k=h.firstChild,null!=k){h=k;continue}k=h.nextSibling;if(null!=k)a++,h=k;else if(k=h.parentNode,null!=k){h=k.nextSibling;if(null==h)break;c++;a=0}}f.columns=a+1;f.rows=c+1;return f}
+function D(a,b){const f=[];({cells:a}=a);b=new Set(b?b.getNodes():[]);for(let h=0;h<a.length;h++){const c=a[h];for(let k=0;k<c.length;k++){const p=c[k],d=p.elem.style,e=g.$getNearestNodeFromDOMNode(p.elem);e&&b.has(e)?(p.highlighted=!0,d.setProperty("background-color","rgb(163, 187, 255)"),d.setProperty("caret-color","transparent"),f.push(p)):(p.highlighted=!1,d.removeProperty("background-color"),d.removeProperty("caret-color"),p.elem.getAttribute("style")||p.elem.removeAttribute("style"))}}return f}
+const G=(a,b,f,h,c)=>{switch(c){case "backward":case "forward":return c="forward"===c,f!==(c?a.grid.columns-1:0)?F(b.getCellNodeFromCordsOrThrow(f+(c?1:-1),h,a.grid)):h!==(c?a.grid.rows-1:0)?F(b.getCellNodeFromCordsOrThrow(c?0:a.grid.columns-1,h+(c?1:-1),a.grid)):c?b.selectNext():b.selectPrevious(),!0;case "up":return 0!==h?F(b.getCellNodeFromCordsOrThrow(f,h-1,a.grid)):b.selectPrevious(),!0;case "down":return h!==a.grid.rows-1?F(b.getCellNodeFromCordsOrThrow(f,h+1,a.grid)):b.selectNext(),!0}return!1},
+H=(a,b,f,h,c)=>{switch(c){case "backward":case "forward":return c="forward"===c,f!==(c?a.grid.columns-1:0)&&a.adjustFocusCellForSelection(b.getCellFromCordsOrThrow(f+(c?1:-1),h,a.grid)),!0;case "up":if(0!==h)return a.adjustFocusCellForSelection(b.getCellFromCordsOrThrow(f,h-1,a.grid)),!0;break;case "down":if(h!==a.grid.rows-1)return a.adjustFocusCellForSelection(b.getCellFromCordsOrThrow(f,h+1,a.grid)),!0}return!1};
+function F(a){const b=a.getChildren().find(f=>g.$isParagraphNode(f));g.$isParagraphNode(b)?b.selectEnd():a.selectEnd()}
+class I extends g.GridNode{static getType(){return"table"}static clone(a){return new I(a.__key)}static convertDOM(){return{table:()=>({conversion:N,priority:0})}}constructor(a){super(a)}createDOM(a){const b=document.createElement("table");n.addClassNamesToElement(b,a.theme.table);return b}updateDOM(){return!1}canExtractContents(){return!1}canBeEmpty(){return!1}getCordsFromCellNode(a,b){b||x(55);const {rows:f,cells:h}=b;for(b=0;b<f;b++){var c=h[b];if(null==c)throw Error(`Row not found at y:${b}`);
+c=c.findIndex(({elem:k})=>g.$getNearestNodeFromDOMNode(k)===a);if(-1!==c)return{x:c,y:b}}throw Error("Cell not found in table.");}getCellFromCords(a,b,f){f||x(55);({cells:f}=f);b=f[b];if(null==b)return null;a=b[a];return null==a?null:a}getCellFromCordsOrThrow(a,b,f){a=this.getCellFromCords(a,b,f);if(!a)throw Error("Cell not found at cords.");return a}getCellNodeFromCords(a,b,f){a=this.getCellFromCords(a,b,f);if(null==a)return null;a=g.$getNearestNodeFromDOMNode(a.elem);return w(a)?a:null}getCellNodeFromCordsOrThrow(a,
+b,f){a=this.getCellNodeFromCords(a,b,f);if(!a)throw Error("Node at cords not TableCellNode.");return a}canSelectBefore(){return!0}}function N(){return{node:O()}}function O(){return new I}function C(a){return a instanceof I}
+class P extends g.GridRowNode{static getType(){return"tablerow"}static clone(a){return new P(a.__height,a.__key)}static convertDOM(){return{tr:()=>({conversion:Q,priority:0})}}constructor(a,b){super(b);this.__height=a}createDOM(a){const b=document.createElement("tr");this.__height&&(b.style.height=`${this.__height}px`);n.addClassNamesToElement(b,a.theme.tableRow);return b}setHeight(a){this.getWritable().__height=a;return this.__height}getHeight(){return this.getLatest().__height}updateDOM(a){return a.__height!==
+this.__height}canBeEmpty(){return!1}}function Q(){return{node:R()}}function R(a){return new P(a)}function S(a){return a instanceof P}function T(a){a=n.$findMatchingParent(a,b=>S(b));if(S(a))return a;throw Error("Expected table cell to be inside of table row.");}function U(a){a=n.$findMatchingParent(a,b=>C(b));if(C(a))return a;throw Error("Expected table cell to be inside of table.");}const V=g.createCommand();exports.$createTableCellNode=v;exports.$createTableNode=O;
+exports.$createTableNodeWithDimensions=function(a,b,f=!0){const h=O();for(let k=0;k<a;k++){const p=R();for(let d=0;d<b;d++){var c=q.NO_STATUS;f&&(0===k&&(c|=q.ROW),0===d&&(c|=q.COLUMN));c=v(c);const e=g.$createParagraphNode();e.append(g.$createTextNode());c.append(e);p.append(c)}h.append(p)}return h};exports.$createTableRowNode=R;
+exports.$deleteTableColumn=function(a,b){const f=a.getChildren();for(let c=0;c<f.length;c++){var h=f[c];if(S(h)){h=h.getChildren();if(b>=h.length||0>b)throw Error("Table column target index out of range");h[b].remove()}}return a};exports.$getElementGridForTableNode=function(a,b){a=a.getElementByKey(b.getKey());if(null==a)throw Error("Table Element Not Found");return B(a)};exports.$getTableCellNodeFromLexicalNode=function(a){a=n.$findMatchingParent(a,b=>w(b));return w(a)?a:null};
+exports.$getTableColumnIndexFromTableCellNode=function(a){return T(a).getChildren().findIndex(b=>b.is(a))};exports.$getTableNodeFromLexicalNodeOrThrow=U;exports.$getTableRowIndexFromTableCellNode=function(a){const b=T(a);return U(b).getChildren().findIndex(f=>f.is(b))};exports.$getTableRowNodeFromTableCellNodeOrThrow=T;
+exports.$insertTableColumn=function(a,b,f=!0,h){const c=a.getChildren();for(let d=0;d<c.length;d++){const e=c[d];if(S(e))for(let l=0;l<h;l++){var k=q.NO_STATUS;0===d&&(k|=q.ROW);k=v(k);k.append(g.$createParagraphNode());var p=e.getChildren();if(b>=p.length||0>b)throw Error("Table column target index out of range");p=p[b];f?p.insertAfter(k):p.insertBefore(k)}}return a};
+exports.$insertTableRow=function(a,b,f=!0,h,c){var k=a.getChildren();if(b>=k.length||0>b)throw Error("Table row target index out of range");b=k[b];if(S(b))for(k=0;k<h;k++){const e=b.getChildren(),l=e.length,m=R();for(let t=0;t<l;t++){var p=e[t];w(p)||x(73);var d=c;const A=U(p),{x:J,y:K}=A.getCordsFromCellNode(p,d);p={above:A.getCellNodeFromCords(J,K-1,d),below:A.getCellNodeFromCords(J,K+1,d),left:A.getCellNodeFromCords(J-1,K,d),right:A.getCellNodeFromCords(J+1,K,d)};const {above:L,below:M}=p;p=q.NO_STATUS;
+d=L&&L.getWidth()||M&&M.getWidth()||null;if(L&&L.hasHeaderState(q.COLUMN)||M&&M.hasHeaderState(q.COLUMN))p|=q.COLUMN;p=v(p,1,d);p.append(g.$createParagraphNode());m.append(p)}f?b.insertAfter(m):b.insertBefore(m)}else throw Error("Row before insertion index does not exist.");return a};exports.$isTableCellNode=w;exports.$isTableNode=C;exports.$isTableRowNode=S;
+exports.$removeTableRowAtIndex=function(a,b){const f=a.getChildren();if(b>=f.length||0>b)throw Error("Expected table cell to be inside of table row.");f[b].remove();return a};exports.INSERT_TABLE_COMMAND=V;exports.TableCellHeaderStates=q;exports.TableCellNode=r;exports.TableNode=I;exports.TableRowNode=P;exports.TableSelection=z;
+exports.applyTableHandlers=function(a,b,f){const h=f.getRootElement();if(null===h)throw Error("No root element.");const c=new z(f,a.getKey());b.__lexicalTableSelection=c;let k=!1;b.addEventListener("dblclick",d=>{const e=E(d.target);null!==e&&(d.preventDefault(),d.stopImmediatePropagation(),d.stopPropagation(),c.setAnchorCellForSelection(e),c.adjustFocusCellForSelection(e,!0),k=!1)});b.addEventListener("mousedown",d=>{setTimeout(()=>{if(0===d.button){var e=E(d.target);null!==e&&(k=!0,c.setAnchorCellForSelection(e),
+document.addEventListener("mouseup",()=>{k=!1},{capture:!0,once:!0}))}},0)});b.addEventListener("mousemove",d=>{if(k){const e=E(d.target);if(null!==e){const l=e.x,m=e.y;k&&(c.startX!==l||c.startY!==m||c.isHighlightingCells)&&(d.preventDefault(),k=!0,c.adjustFocusCellForSelection(e))}}});b.addEventListener("mouseup",()=>{k&&(k=!1)});b.addEventListener("mouseleave",()=>{});const p=d=>{0===d.button&&f.update(()=>{const e=g.$getSelection();if(g.$isGridSelection(e)&&e.gridKey===c.tableNodeKey&&h.contains(d.target))return c.clearHighlight()})};
+window.addEventListener("mousedown",p);c.listenersToRemove.add(()=>window.removeEventListener("mousedown",p));c.listenersToRemove.add(f.registerCommand(g.KEY_ARROW_DOWN_COMMAND,d=>{var e=g.$getSelection();if(g.$isRangeSelection(e)){if(e.isCollapsed()){var l=n.$findMatchingParent(e.anchor.getNode(),t=>w(t));if(!w(l))return!1;var m=a.getCordsFromCellNode(l,c.grid);e=n.$findMatchingParent(e.anchor.getNode(),t=>g.$isElementNode(t));if(null==e)throw Error("Expected BlockNode Parent");if((l=l.getLastChild())&&
+e.isParentOf(l)||e===l||d.shiftKey)return d.preventDefault(),d.stopImmediatePropagation(),d.stopPropagation(),d.shiftKey?(c.setAnchorCellForSelection(a.getCellFromCordsOrThrow(m.x,m.y,c.grid)),H(c,a,m.x,m.y,"down")):G(c,a,m.x,m.y,"down")}}else if(g.$isGridSelection(e)&&d.shiftKey){m=e.focus.getNode();if(!w(m))return!1;m=a.getCordsFromCellNode(m,c.grid);d.preventDefault();d.stopImmediatePropagation();d.stopPropagation();return H(c,a,m.x,m.y,"down")}return!1},4));c.listenersToRemove.add(f.registerCommand(g.KEY_ARROW_UP_COMMAND,
+d=>{var e=g.$getSelection();if(g.$isRangeSelection(e)){if(e.isCollapsed()){var l=n.$findMatchingParent(e.anchor.getNode(),t=>w(t));if(!w(l))return!1;var m=a.getCordsFromCellNode(l,c.grid);e=n.$findMatchingParent(e.anchor.getNode(),t=>g.$isElementNode(t));if(null==e)throw Error("Expected BlockNode Parent");if((l=l.getLastChild())&&e.isParentOf(l)||e===l||d.shiftKey)return d.preventDefault(),d.stopImmediatePropagation(),d.stopPropagation(),d.shiftKey?(c.setAnchorCellForSelection(a.getCellFromCordsOrThrow(m.x,
+m.y,c.grid)),H(c,a,m.x,m.y,"up")):G(c,a,m.x,m.y,"up")}}else if(g.$isGridSelection(e)&&d.shiftKey){m=e.focus.getNode();if(!w(m))return!1;m=a.getCordsFromCellNode(m,c.grid);d.preventDefault();d.stopImmediatePropagation();d.stopPropagation();return H(c,a,m.x,m.y,"up")}return!1},4));c.listenersToRemove.add(f.registerCommand(g.KEY_ARROW_LEFT_COMMAND,d=>{var e=g.$getSelection();if(g.$isRangeSelection(e)){if(e.isCollapsed()){var l=n.$findMatchingParent(e.anchor.getNode(),m=>w(m));if(!w(l))return!1;l=a.getCordsFromCellNode(l,
+c.grid);if(null==n.$findMatchingParent(e.anchor.getNode(),m=>g.$isElementNode(m)))throw Error("Expected BlockNode Parent");if(0===e.anchor.offset||d.shiftKey)return d.preventDefault(),d.stopImmediatePropagation(),d.stopPropagation(),d.shiftKey?(c.setAnchorCellForSelection(a.getCellFromCordsOrThrow(l.x,l.y,c.grid)),H(c,a,l.x,l.y,"backward")):G(c,a,l.x,l.y,"backward")}}else if(g.$isGridSelection(e)&&d.shiftKey){e=e.focus.getNode();if(!w(e))return!1;e=a.getCordsFromCellNode(e,c.grid);d.preventDefault();
+d.stopImmediatePropagation();d.stopPropagation();return H(c,a,e.x,e.y,"backward")}return!1},4));c.listenersToRemove.add(f.registerCommand(g.KEY_ARROW_RIGHT_COMMAND,d=>{var e=g.$getSelection();if(g.$isRangeSelection(e)){if(e.isCollapsed()){var l=n.$findMatchingParent(e.anchor.getNode(),m=>w(m));if(!w(l))return!1;l=a.getCordsFromCellNode(l,c.grid);if(null==n.$findMatchingParent(e.anchor.getNode(),m=>g.$isElementNode(m)))throw Error("Expected BlockNode Parent");if(e.anchor.offset===e.anchor.getNode().getTextContentSize()||
+d.shiftKey)return d.preventDefault(),d.stopImmediatePropagation(),d.stopPropagation(),d.shiftKey?(c.setAnchorCellForSelection(a.getCellFromCordsOrThrow(l.x,l.y,c.grid)),H(c,a,l.x,l.y,"forward")):G(c,a,l.x,l.y,"forward")}}else if(g.$isGridSelection(e)&&d.shiftKey){e=e.focus.getNode();if(!w(e))return!1;e=a.getCordsFromCellNode(e,c.grid);d.preventDefault();d.stopImmediatePropagation();d.stopPropagation();return H(c,a,e.x,e.y,"forward")}return!1},4));c.listenersToRemove.add(f.registerCommand(g.DELETE_CHARACTER_COMMAND,
+()=>{const d=g.$getSelection();if(g.$isGridSelection(d))return c.clearText(),!0;if(g.$isRangeSelection(d)){const e=n.$findMatchingParent(d.anchor.getNode(),l=>w(l));if(!w(e))return!1;if(d.isCollapsed()&&0===d.anchor.offset&&0===d.anchor.getNode().getPreviousSiblings().length)return!0}return!1},4));c.listenersToRemove.add(f.registerCommand(g.KEY_BACKSPACE_COMMAND,d=>{const e=g.$getSelection();if(g.$isGridSelection(e))return d.preventDefault(),d.stopPropagation(),c.clearText(),!0;g.$isRangeSelection(e)&&
+(d=n.$findMatchingParent(e.anchor.getNode(),l=>w(l)),w(d));return!1},4));c.listenersToRemove.add(f.registerCommand(g.FORMAT_TEXT_COMMAND,d=>{const e=g.$getSelection();if(g.$isGridSelection(e))return c.formatCells(d),!0;g.$isRangeSelection(e)&&(d=n.$findMatchingParent(e.anchor.getNode(),l=>w(l)),w(d));return!1},4));c.listenersToRemove.add(f.registerCommand(g.INSERT_TEXT_COMMAND,()=>{var d=g.$getSelection();g.$isGridSelection(d)?c.clearHighlight():g.$isRangeSelection(d)&&(d=n.$findMatchingParent(d.anchor.getNode(),
+e=>w(e)),w(d));return!1},4));c.listenersToRemove.add(f.registerCommand(g.KEY_TAB_COMMAND,d=>{var e=g.$getSelection();if(g.$isRangeSelection(e)){const l=n.$findMatchingParent(e.anchor.getNode(),m=>w(m));if(!w(l))return!1;if(e.isCollapsed())return e=a.getCordsFromCellNode(l,c.grid),d.preventDefault(),G(c,a,e.x,e.y,d.shiftKey?"backward":"forward"),!0}return!1},4));return c};exports.getCellFromTarget=E;exports.getTableSelectionFromTableElement=function(a){return a.__lexicalTableSelection};

package/package.json

@@ -1,9 +1,5 @@
 {
   "name": "@lexical/table",
-  "author": {
-    "name": "Dominic Gannaway",
-    "email": "dg@domgan.com"
-  },
   "description": "This package provides the Table feature for Lexical.",
   "keywords": [
     "lexical",
@@ -12,13 +8,13 @@
     "table"
   ],
   "license": "MIT",
-  "version": "0.1.16",
+  "version": "0.1.19",
   "main": "LexicalTable.js",
   "peerDependencies": {
-    "lexical": "0.1.16"
+    "lexical": "0.1.19"
   },
   "dependencies": {
-    "@lexical/utils": "0.1.16"
+    "@lexical/utils": "0.1.19"
   },
   "repository": {
     "type": "git",