@lexical/table 0.26.0 → 0.27.0

package/LexicalTable.dev.js

@@ -91,6 +91,7 @@ class TableCellNode extends lexical.ElementNode {
     this.__headerState = headerState;
     this.__width = width;
     this.__backgroundColor = null;
+    this.__verticalAlign = undefined;
   }
   createDOM(config) {
     const element = document.createElement(this.getTag());
@@ -306,6 +307,20 @@ function $isTableCellNode(node) {
 
 const INSERT_TABLE_COMMAND = lexical.createCommand('INSERT_TABLE_COMMAND');
 
+/**
+ * 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.
+ *
+ */
+
+// Do not require this module directly! Use normal `invariant` calls.
+
+function formatDevErrorMessage(message) {
+  throw new Error(message);
+}
+
 /**
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *
@@ -423,14 +438,6 @@ const documentMode = CAN_USE_DOM && 'documentMode' in document ? document.docume
 const IS_FIREFOX = CAN_USE_DOM && /^(?!.*Seamonkey)(?=.*Firefox).*/i.test(navigator.userAgent);
 CAN_USE_DOM && 'InputEvent' in window && !documentMode ? 'getTargetRanges' in new window.InputEvent('input') : false;
 
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
 function $createTableNodeWithDimensions(rowCount, columnCount, includeHeaders = true) {
   const tableNode = $createTableNode();
   for (let iRow = 0; iRow < rowCount; iRow++) {
@@ -528,7 +535,7 @@ function $insertTableRow(tableNode, targetIndex, shouldInsertAfter = true, rowCo
       for (let c = 0; c < tableColumnCount; c++) {
         const tableCellFromTargetRow = tableRowCells[c];
         if (!$isTableCellNode(tableCellFromTargetRow)) {
-          throw Error(`Expected table cell`);
+          formatDevErrorMessage(`Expected table cell`);
         }
         const {
           above,
@@ -569,7 +576,7 @@ const getHeaderState = (currentState, possibleState) => {
 function $insertTableRow__EXPERIMENTAL(insertAfter = true) {
   const selection = lexical.$getSelection();
   if (!(lexical.$isRangeSelection(selection) || $isTableSelection(selection))) {
-    throw Error(`Expected a RangeSelection or TableSelection`);
+    formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
   }
   const anchor = selection.anchor.getNode();
   const focus = selection.focus.getNode();
@@ -604,7 +611,7 @@ function $insertTableRow__EXPERIMENTAL(insertAfter = true) {
     }
     const insertAfterEndRowNode = grid.getChildAtIndex(insertAfterEndRow);
     if (!$isTableRowNode(insertAfterEndRowNode)) {
-      throw Error(`insertAfterEndRow is not a TableRowNode`);
+      formatDevErrorMessage(`insertAfterEndRow is not a TableRowNode`);
     }
     insertAfterEndRowNode.insertAfter(newRow);
     insertedRow = newRow;
@@ -628,7 +635,7 @@ function $insertTableRow__EXPERIMENTAL(insertAfter = true) {
     }
     const insertBeforeStartRowNode = grid.getChildAtIndex(insertBeforeStartRow);
     if (!$isTableRowNode(insertBeforeStartRowNode)) {
-      throw Error(`insertBeforeStartRow is not a TableRowNode`);
+      formatDevErrorMessage(`insertBeforeStartRow is not a TableRowNode`);
     }
     insertBeforeStartRowNode.insertBefore(newRow);
     insertedRow = newRow;
@@ -648,7 +655,7 @@ function $insertTableColumn(tableNode, targetIndex, shouldInsertAfter = true, co
         }
         const targetCell = tableRowChildren[targetIndex];
         if (!$isTableCellNode(targetCell)) {
-          throw Error(`Expected table cell`);
+          formatDevErrorMessage(`Expected table cell`);
         }
         const {
           left,
@@ -688,7 +695,7 @@ function $insertTableColumn(tableNode, targetIndex, shouldInsertAfter = true, co
 function $insertTableColumn__EXPERIMENTAL(insertAfter = true) {
   const selection = lexical.$getSelection();
   if (!(lexical.$isRangeSelection(selection) || $isTableSelection(selection))) {
-    throw Error(`Expected a RangeSelection or TableSelection`);
+    formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
   }
   const anchor = selection.anchor.getNode();
   const focus = selection.focus.getNode();
@@ -700,7 +707,7 @@ function $insertTableColumn__EXPERIMENTAL(insertAfter = true) {
   const insertAfterColumn = insertAfter ? startColumn + focusCell.__colSpan - 1 : startColumn - 1;
   const gridFirstChild = grid.getFirstChild();
   if (!$isTableRowNode(gridFirstChild)) {
-    throw Error(`Expected firstTable child to be a row`);
+    formatDevErrorMessage(`Expected firstTable child to be a row`);
   }
   let firstInsertedCell = null;
   function $createTableCellNodeForInsertTableColumn(headerState = TableCellHeaderStates.NO_STATUS) {
@@ -715,7 +722,7 @@ function $insertTableColumn__EXPERIMENTAL(insertAfter = true) {
     if (i !== 0) {
       const currentRow = loopRow.getNextSibling();
       if (!$isTableRowNode(currentRow)) {
-        throw Error(`Expected row nextSibling to be a row`);
+        formatDevErrorMessage(`Expected row nextSibling to be a row`);
       }
       loopRow = currentRow;
     }
@@ -784,7 +791,7 @@ function $deleteTableColumn(tableNode, targetIndex) {
 function $deleteTableRow__EXPERIMENTAL() {
   const selection = lexical.$getSelection();
   if (!(lexical.$isRangeSelection(selection) || $isTableSelection(selection))) {
-    throw Error(`Expected a RangeSelection or TableSelection`);
+    formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
   }
   const [anchor, focus] = selection.isBackward() ? [selection.focus.getNode(), selection.anchor.getNode()] : [selection.anchor.getNode(), selection.focus.getNode()];
   const [anchorCell,, grid] = $getNodeTriplet(anchor);
@@ -826,7 +833,7 @@ function $deleteTableRow__EXPERIMENTAL() {
       if (cellStartRow >= anchorStartRow && cellStartRow + cell.__rowSpan - 1 > focusEndRow) {
         cell.setRowSpan(cell.__rowSpan - (focusEndRow - cellStartRow + 1));
         if (!(nextRowNode !== null)) {
-          throw Error(`Expected nextRowNode not to be null`);
+          formatDevErrorMessage(`Expected nextRowNode not to be null`);
         }
         let insertAfterCell = null;
         for (let columnIndex = 0; columnIndex < column; columnIndex++) {
@@ -849,7 +856,7 @@ function $deleteTableRow__EXPERIMENTAL() {
     }
     const rowNode = grid.getChildAtIndex(row);
     if (!$isTableRowNode(rowNode)) {
-      throw Error(`Expected TableNode childAtIndex(${String(row)}) to be RowNode`);
+      formatDevErrorMessage(`Expected TableNode childAtIndex(${String(row)}) to be RowNode`);
     }
     rowNode.remove();
   }
@@ -869,7 +876,7 @@ function $deleteTableRow__EXPERIMENTAL() {
 function $deleteTableColumn__EXPERIMENTAL() {
   const selection = lexical.$getSelection();
   if (!(lexical.$isRangeSelection(selection) || $isTableSelection(selection))) {
-    throw Error(`Expected a RangeSelection or TableSelection`);
+    formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
   }
   const anchor = selection.anchor.getNode();
   const focus = selection.focus.getNode();
@@ -959,7 +966,7 @@ function $insertFirst(parent, node) {
 function $unmergeCell() {
   const selection = lexical.$getSelection();
   if (!(lexical.$isRangeSelection(selection) || $isTableSelection(selection))) {
-    throw Error(`Expected a RangeSelection or TableSelection`);
+    formatDevErrorMessage(`Expected a RangeSelection or TableSelection`);
   }
   const anchor = selection.anchor.getNode();
   const [cell, row, grid] = $getNodeTriplet(anchor);
@@ -1009,7 +1016,7 @@ function $unmergeCell() {
       const currentRowMap = map[currentRow];
       currentRowNode = (currentRowNode || row).getNextSibling();
       if (!$isTableRowNode(currentRowNode)) {
-        throw Error(`Expected row next sibling to be a row`);
+        formatDevErrorMessage(`Expected row next sibling to be a row`);
       }
       let insertAfterCell = null;
       for (let column = 0; column < startColumn; column++) {
@@ -1038,10 +1045,10 @@ function $unmergeCell() {
 function $computeTableMap(tableNode, cellA, cellB) {
   const [tableMap, cellAValue, cellBValue] = $computeTableMapSkipCellCheck(tableNode, cellA, cellB);
   if (!(cellAValue !== null)) {
-    throw Error(`Anchor not found in Table`);
+    formatDevErrorMessage(`Anchor not found in Table`);
   }
   if (!(cellBValue !== null)) {
-    throw Error(`Focus not found in Table`);
+    formatDevErrorMessage(`Focus not found in Table`);
   }
   return [tableMap, cellAValue, cellBValue];
 }
@@ -1060,12 +1067,12 @@ function $computeTableMapSkipCellCheck(tableNode, cellA, cellB) {
   for (let rowIdx = 0; rowIdx < gridChildren.length; rowIdx++) {
     const row = gridChildren[rowIdx];
     if (!$isTableRowNode(row)) {
-      throw Error(`Expected TableNode children to be TableRowNode`);
+      formatDevErrorMessage(`Expected TableNode children to be TableRowNode`);
     }
     const startMapRow = getMapRow(rowIdx);
     for (let cell = row.getFirstChild(), colIdx = 0; cell != null; cell = cell.getNextSibling()) {
       if (!$isTableCellNode(cell)) {
-        throw Error(`Expected TableRowNode children to be TableCellNode`);
+        formatDevErrorMessage(`Expected TableRowNode children to be TableCellNode`);
       } // Skip past any columns that were merged from a higher row
       while (startMapRow[colIdx] !== undefined) {
         colIdx++;
@@ -1112,23 +1119,23 @@ function $getNodeTriplet(source) {
   } else if ('__type' in source) {
     const cell_ = utils.$findMatchingParent(source, $isTableCellNode);
     if (!$isTableCellNode(cell_)) {
-      throw Error(`Expected to find a parent TableCellNode`);
+      formatDevErrorMessage(`Expected to find a parent TableCellNode`);
     }
     cell = cell_;
   } else {
     const cell_ = utils.$findMatchingParent(source.getNode(), $isTableCellNode);
     if (!$isTableCellNode(cell_)) {
-      throw Error(`Expected to find a parent TableCellNode`);
+      formatDevErrorMessage(`Expected to find a parent TableCellNode`);
     }
     cell = cell_;
   }
   const row = cell.getParent();
   if (!$isTableRowNode(row)) {
-    throw Error(`Expected TableCellNode to have a parent TableRowNode`);
+    formatDevErrorMessage(`Expected TableCellNode to have a parent TableRowNode`);
   }
   const grid = row.getParent();
   if (!$isTableNode(grid)) {
-    throw Error(`Expected TableRowNode to have a parent TableNode`);
+    formatDevErrorMessage(`Expected TableRowNode to have a parent TableNode`);
   }
   return [cell, row, grid];
 }
@@ -1259,34 +1266,26 @@ function $getTableCellNodeRect(tableCellNode) {
   return null;
 }
 
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
 function $getCellNodes(tableSelection) {
   const [[anchorNode, anchorCell, anchorRow, anchorTable], [focusNode, focusCell, focusRow, focusTable]] = ['anchor', 'focus'].map(k => {
     const node = tableSelection[k].getNode();
     const cellNode = utils.$findMatchingParent(node, $isTableCellNode);
     if (!$isTableCellNode(cellNode)) {
-      throw Error(`Expected TableSelection ${k} to be (or a child of) TableCellNode, got key ${node.getKey()} of type ${node.getType()}`);
+      formatDevErrorMessage(`Expected TableSelection ${k} to be (or a child of) TableCellNode, got key ${node.getKey()} of type ${node.getType()}`);
     }
     const rowNode = cellNode.getParent();
     if (!$isTableRowNode(rowNode)) {
-      throw Error(`Expected TableSelection ${k} cell parent to be a TableRowNode`);
+      formatDevErrorMessage(`Expected TableSelection ${k} cell parent to be a TableRowNode`);
     }
     const tableNode = rowNode.getParent();
     if (!$isTableNode(tableNode)) {
-      throw Error(`Expected TableSelection ${k} row parent to be a TableNode`);
+      formatDevErrorMessage(`Expected TableSelection ${k} row parent to be a TableNode`);
     }
     return [node, cellNode, rowNode, tableNode];
   });
   // TODO: nested tables may violate this
   if (!anchorTable.is(focusTable)) {
-    throw Error(`Expected TableSelection anchor and focus to be in the same table`);
+    formatDevErrorMessage(`Expected TableSelection anchor and focus to be in the same table`);
   }
   return {
     anchorCell,
@@ -1387,7 +1386,7 @@ class TableSelection {
   insertNodes(nodes) {
     const focusNode = this.focus.getNode();
     if (!lexical.$isElementNode(focusNode)) {
-      throw Error(`Expected TableSelection focus to be an ElementNode`);
+      formatDevErrorMessage(`Expected TableSelection focus to be an ElementNode`);
     }
     const selection = lexical.$normalizeSelection__EXPERIMENTAL(focusNode.select(0, focusNode.getChildrenSize()));
     selection.insertNodes(nodes);
@@ -1401,11 +1400,11 @@ class TableSelection {
     } = $getCellNodes(this);
     const anchorCellNodeRect = $getTableCellNodeRect(anchorCell);
     if (!(anchorCellNodeRect !== null)) {
-      throw Error(`getCellRect: expected to find AnchorNode`);
+      formatDevErrorMessage(`getCellRect: expected to find AnchorNode`);
     }
     const focusCellNodeRect = $getTableCellNodeRect(focusCell);
     if (!(focusCellNodeRect !== null)) {
-      throw Error(`getCellRect: expected to find focusCellNode`);
+      formatDevErrorMessage(`getCellRect: expected to find focusCellNode`);
     }
     const startX = Math.min(anchorCellNodeRect.columnIndex, focusCellNodeRect.columnIndex);
     const stopX = Math.max(anchorCellNodeRect.columnIndex + anchorCellNodeRect.colSpan - 1, focusCellNodeRect.columnIndex + focusCellNodeRect.colSpan - 1);
@@ -1437,14 +1436,14 @@ class TableSelection {
         // focus is on higher Grid level than anchor
         const gridParent = tableNode.getParent();
         if (!(gridParent != null)) {
-          throw Error(`Expected gridParent to have a parent`);
+          formatDevErrorMessage(`Expected gridParent to have a parent`);
         }
         this.set(this.tableKey, gridParent.getKey(), focusCell.getKey());
       } else {
         // anchor is on higher Grid level than focus
         const focusCellParent = focusCellGrid.getParent();
         if (!(focusCellParent != null)) {
-          throw Error(`Expected focusCellParent to have a parent`);
+          formatDevErrorMessage(`Expected focusCellParent to have a parent`);
         }
         this.set(this.tableKey, focusCell.getKey(), focusCellParent.getKey());
       }
@@ -1474,7 +1473,7 @@ class TableSelection {
         } = map[i][j];
         const currentRow = cell.getParent();
         if (!$isTableRowNode(currentRow)) {
-          throw Error(`Expected TableCellNode parent to be a TableRowNode`);
+          formatDevErrorMessage(`Expected TableCellNode parent to be a TableRowNode`);
         }
         if (currentRow !== lastRow) {
           nodeMap.set(currentRow.getKey(), currentRow);
@@ -1524,13 +1523,13 @@ function $createTableSelectionFrom(tableNode, anchorCell, focusCell) {
   const focusCellKey = focusCell.getKey();
   {
     if (!tableNode.isAttached()) {
-      throw Error(`$createTableSelectionFrom: tableNode ${tableNodeKey} is not attached`);
+      formatDevErrorMessage(`$createTableSelectionFrom: tableNode ${tableNodeKey} is not attached`);
     }
     if (!tableNode.is($findTableNode(anchorCell))) {
-      throw Error(`$createTableSelectionFrom: anchorCell ${anchorCellKey} is not in table ${tableNodeKey}`);
+      formatDevErrorMessage(`$createTableSelectionFrom: anchorCell ${anchorCellKey} is not in table ${tableNodeKey}`);
     }
     if (!tableNode.is($findTableNode(focusCell))) {
-      throw Error(`$createTableSelectionFrom: focusCell ${focusCellKey} is not in table ${tableNodeKey}`);
+      formatDevErrorMessage(`$createTableSelectionFrom: focusCell ${focusCellKey} is not in table ${tableNodeKey}`);
     } // TODO: Check for rectangular grid
   }
   const prevSelection = lexical.$getSelection();
@@ -1556,22 +1555,14 @@ function $visitRecursively(node, $visit) {
   }
 }
 
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
 function $getTableAndElementByKey(tableNodeKey, editor = lexical.$getEditor()) {
   const tableNode = lexical.$getNodeByKey(tableNodeKey);
   if (!$isTableNode(tableNode)) {
-    throw Error(`TableObserver: Expected tableNodeKey ${tableNodeKey} to be a TableNode`);
+    formatDevErrorMessage(`TableObserver: Expected tableNodeKey ${tableNodeKey} to be a TableNode`);
   }
   const tableElement = getTableElement(tableNode, editor.getElementByKey(tableNodeKey));
   if (!(tableElement !== null)) {
-    throw Error(`TableObserver: Expected to find TableElement in DOM for key ${tableNodeKey}`);
+    formatDevErrorMessage(`TableObserver: Expected to find TableElement in DOM for key ${tableNodeKey}`);
   }
   return {
     tableElement,
@@ -1703,7 +1694,7 @@ class TableObserver {
   $updateTableTableSelection(selection) {
     if (selection !== null) {
       if (!(selection.tableKey === this.tableNodeKey)) {
-        throw Error(`TableObserver.$updateTableTableSelection: selection.tableKey !== this.tableNodeKey ('${selection.tableKey}' !== '${this.tableNodeKey}')`);
+        formatDevErrorMessage(`TableObserver.$updateTableTableSelection: selection.tableKey !== this.tableNodeKey ('${selection.tableKey}' !== '${this.tableNodeKey}')`);
       }
       const editor = this.editor;
       this.tableSelection = selection;
@@ -1810,7 +1801,7 @@ class TableObserver {
   $getAnchorTableCellOrThrow() {
     const anchorTableCell = this.$getAnchorTableCell();
     if (!(anchorTableCell !== null)) {
-      throw Error(`TableObserver anchorTableCell is null`);
+      formatDevErrorMessage(`TableObserver anchorTableCell is null`);
     }
     return anchorTableCell;
   }
@@ -1820,7 +1811,7 @@ class TableObserver {
   $getFocusTableCellOrThrow() {
     const focusTableCell = this.$getFocusTableCell();
     if (!(focusTableCell !== null)) {
-      throw Error(`TableObserver focusTableCell is null`);
+      formatDevErrorMessage(`TableObserver focusTableCell is null`);
     }
     return focusTableCell;
   }
@@ -1842,14 +1833,14 @@ class TableObserver {
   $formatCells(type) {
     const selection = lexical.$getSelection();
     if (!$isTableSelection(selection)) {
-      throw Error(`Expected Table selection`);
+      formatDevErrorMessage(`Expected Table selection`);
     }
     const formatSelection = lexical.$createRangeSelection();
     const anchor = formatSelection.anchor;
     const focus = formatSelection.focus;
     const cellNodes = selection.getNodes().filter($isTableCellNode);
     if (!(cellNodes.length > 0)) {
-      throw Error(`No table cells present`);
+      formatDevErrorMessage(`No table cells present`);
     }
     const paragraph = cellNodes[0].getFirstChild();
     const alignFormatWith = lexical.$isParagraphNode(paragraph) ? paragraph.getFormatFlags(type, null) : null;
@@ -1871,7 +1862,7 @@ class TableObserver {
     }
     const selection = lexical.$getSelection();
     if (!$isTableSelection(selection)) {
-      throw Error(`Expected TableSelection`);
+      formatDevErrorMessage(`Expected TableSelection`);
     }
     const selectedNodes = selection.getNodes().filter($isTableCellNode);
     if (selectedNodes.length === this.table.columns * this.table.rows) {
@@ -1904,14 +1895,6 @@ class TableObserver {
   }
 }
 
-/**
- * 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 LEXICAL_ELEMENT_KEY = '__lexicalTableSelection';
 const isMouseDownOnEvent = event => {
   return (event.buttons & 1) === 1;
@@ -1922,7 +1905,7 @@ function getTableElement(tableNode, dom) {
   }
   const element = dom.nodeName === 'TABLE' ? dom : tableNode.getDOMSlot(dom).element;
   if (!(element.nodeName === 'TABLE')) {
-    throw Error(`getTableElement: Expecting table in as DOM node for TableNode, not ${dom.nodeName}`);
+    formatDevErrorMessage(`getTableElement: Expecting table in as DOM node for TableNode, not ${dom.nodeName}`);
   }
   return element;
 }
@@ -1946,7 +1929,7 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler) {
   const rootElement = editor.getRootElement();
   const editorWindow = getEditorWindow(editor);
   if (!(rootElement !== null && editorWindow !== null)) {
-    throw Error(`applyTableHandlers: editor has no root element set`);
+    formatDevErrorMessage(`applyTableHandlers: editor has no root element set`);
   }
   const tableObserver = new TableObserver(editor, tableNode.getKey());
   const tableElement = getTableElement(tableNode, element);
@@ -2478,7 +2461,7 @@ function detatchTableObserverFromTableElement(tableElement, tableObserver) {
 }
 function attachTableObserverToTableElement(tableElement, tableObserver) {
   if (!(getTableObserverFromTableElement(tableElement) === null)) {
-    throw Error(`tableElement already has an attached TableObserver`);
+    formatDevErrorMessage(`tableElement already has an attached TableObserver`);
   }
   tableElement[LEXICAL_ELEMENT_KEY] = tableObserver;
 }
@@ -2627,7 +2610,7 @@ function $selectAdjacentCell(tableCellNode, direction) {
   }
   const parentRow = utils.$findMatchingParent(tableCellNode, $isTableRowNode);
   if (!(parentRow !== null)) {
-    throw Error(`selectAdjacentCell: Cell not in table row`);
+    formatDevErrorMessage(`selectAdjacentCell: Cell not in table row`);
   }
   for (let nextRow = parentRow[siblingMethod](); $isTableRowNode(nextRow); nextRow = nextRow[siblingMethod]()) {
     const child = nextRow[childMethod]();
@@ -2637,7 +2620,7 @@ function $selectAdjacentCell(tableCellNode, direction) {
   }
   const parentTable = utils.$findMatchingParent(parentRow, $isTableNode);
   if (!(parentTable !== null)) {
-    throw Error(`selectAdjacentCell: Row not in table`);
+    formatDevErrorMessage(`selectAdjacentCell: Row not in table`);
   }
   return direction === 'next' ? parentTable.selectNext() : parentTable.selectPrevious();
 }
@@ -2698,7 +2681,7 @@ function getCorner(rect, cellValue) {
 function getCornerOrThrow(rect, cellValue) {
   const corner = getCorner(rect, cellValue);
   if (!(corner !== null)) {
-    throw Error(`getCornerOrThrow: cell ${cellValue.cell.getKey()} is not at a corner of rect`);
+    formatDevErrorMessage(`getCornerOrThrow: cell ${cellValue.cell.getKey()} is not at a corner of rect`);
   }
   return corner;
 }
@@ -2709,12 +2692,12 @@ function cellAtCornerOrThrow(tableMap, rect, [colName, rowName]) {
   const rowNum = rect[rowName];
   const rowMap = tableMap[rowNum];
   if (!(rowMap !== undefined)) {
-    throw Error(`cellAtCornerOrThrow: ${rowName} = ${String(rowNum)} missing in tableMap`);
+    formatDevErrorMessage(`cellAtCornerOrThrow: ${rowName} = ${String(rowNum)} missing in tableMap`);
   }
   const colNum = rect[colName];
   const cell = rowMap[colNum];
   if (!(cell !== undefined)) {
-    throw Error(`cellAtCornerOrThrow: ${colName} = ${String(colNum)} missing in tableMap`);
+    formatDevErrorMessage(`cellAtCornerOrThrow: ${colName} = ${String(colNum)} missing in tableMap`);
   }
   return cell;
 }
@@ -2777,6 +2760,9 @@ function $adjustFocusInDirection(tableObserver, tableMap, anchorCellValue, focus
 }
 function $isSelectionInTable(selection, tableNode) {
   if (lexical.$isRangeSelection(selection) || $isTableSelection(selection)) {
+    // TODO this should probably return false if there's an unrelated
+    //      shadow root between the node and the table (e.g. another table,
+    //      collapsible, etc.)
     const isAnchorInside = tableNode.isParentOf(selection.anchor.getNode());
     const isFocusInside = tableNode.isParentOf(selection.focus.getNode());
     return isAnchorInside && isFocusInside;
@@ -2806,7 +2792,7 @@ function $addHighlightToDOM(editor, cell) {
   const editorThemeClasses = editor._config.theme;
   const node = lexical.$getNearestNodeFromDOMNode(element);
   if (!$isTableCellNode(node)) {
-    throw Error(`Expected to find LexicalNode from Table Cell DOMNode`);
+    formatDevErrorMessage(`Expected to find LexicalNode from Table Cell DOMNode`);
   }
   utils.addClassNamesToElement(element, editorThemeClasses.tableCellSelected);
 }
@@ -2814,7 +2800,7 @@ function $removeHighlightFromDOM(editor, cell) {
   const element = cell.elem;
   const node = lexical.$getNearestNodeFromDOMNode(element);
   if (!$isTableCellNode(node)) {
-    throw Error(`Expected to find LexicalNode from Table Cell DOMNode`);
+    formatDevErrorMessage(`Expected to find LexicalNode from Table Cell DOMNode`);
   }
   const editorThemeClasses = editor._config.theme;
   utils.removeClassNamesFromElement(element, editorThemeClasses.tableCellSelected);
@@ -2840,6 +2826,85 @@ function $getBlockParentIfFirstNode(node) {
   }
   return null;
 }
+function $handleHorizontalArrowKeyRangeSelection(editor, event, selection, alter, isBackward, tableNode, tableObserver) {
+  const initialFocus = lexical.$caretFromPoint(selection.focus, isBackward ? 'previous' : 'next');
+  if (lexical.$isExtendableTextPointCaret(initialFocus)) {
+    return false;
+  }
+  let lastCaret = initialFocus;
+  // TableCellNode is the only shadow root we are interested in piercing so
+  // we find the last internal caret and then check its parent
+  for (const nextCaret of lexical.$extendCaretToRange(initialFocus).iterNodeCarets('shadowRoot')) {
+    if (!(lexical.$isSiblingCaret(nextCaret) && lexical.$isElementNode(nextCaret.origin))) {
+      return false;
+    }
+    lastCaret = nextCaret;
+  }
+  const lastCaretParent = lastCaret.getParentAtCaret();
+  if (!$isTableCellNode(lastCaretParent)) {
+    return false;
+  }
+  const anchorCell = lastCaretParent;
+  const focusCaret = $findNextTableCell(lexical.$getSiblingCaret(anchorCell, lastCaret.direction));
+  const anchorCellTable = utils.$findMatchingParent(anchorCell, $isTableNode);
+  if (!(anchorCellTable && anchorCellTable.is(tableNode))) {
+    return false;
+  }
+  const anchorCellDOM = editor.getElementByKey(anchorCell.getKey());
+  const anchorDOMCell = getDOMCellFromTarget(anchorCellDOM);
+  if (!anchorCellDOM || !anchorDOMCell) {
+    return false;
+  }
+  const anchorCellTableElement = $getElementForTableNode(editor, anchorCellTable);
+  tableObserver.table = anchorCellTableElement;
+  if (!focusCaret) {
+    if (alter === 'extend') {
+      // extend the selection from a range inside the cell to a table selection of the cell
+      tableObserver.$setAnchorCellForSelection(anchorDOMCell);
+      tableObserver.$setFocusCellForSelection(anchorDOMCell, true);
+    } else {
+      // exit the table
+      const outerFocusCaret = $getTableExitCaret(lexical.$getSiblingCaret(anchorCellTable, initialFocus.direction));
+      lexical.$setPointFromCaret(selection.anchor, outerFocusCaret);
+      lexical.$setPointFromCaret(selection.focus, outerFocusCaret);
+    }
+  } else if (alter === 'extend') {
+    const focusDOMCell = getDOMCellFromTarget(editor.getElementByKey(focusCaret.origin.getKey()));
+    if (!focusDOMCell) {
+      return false;
+    }
+    tableObserver.$setAnchorCellForSelection(anchorDOMCell);
+    tableObserver.$setFocusCellForSelection(focusDOMCell, true);
+  } else {
+    // alter === 'move'
+    const innerFocusCaret = lexical.$normalizeCaret(focusCaret);
+    lexical.$setPointFromCaret(selection.anchor, innerFocusCaret);
+    lexical.$setPointFromCaret(selection.focus, innerFocusCaret);
+  }
+  stopEvent(event);
+  return true;
+}
+function $getTableExitCaret(initialCaret) {
+  const adjacent = lexical.$getAdjacentChildCaret(initialCaret);
+  return lexical.$isChildCaret(adjacent) ? lexical.$normalizeCaret(adjacent) : initialCaret;
+}
+function $findNextTableCell(initialCaret) {
+  for (const nextCaret of lexical.$extendCaretToRange(initialCaret).iterNodeCarets('root')) {
+    const {
+      origin
+    } = nextCaret;
+    if ($isTableCellNode(origin)) {
+      // not sure why ts isn't narrowing here (even if the guard is on nextCaret.origin)
+      // but returning a new caret is fine
+      if (lexical.$isChildCaret(nextCaret)) {
+        return lexical.$getChildCaret(origin, initialCaret.direction);
+      }
+    } else if (!$isTableRowNode(origin)) {
+      break;
+    }
+  }
+  return null;
+}
 function $handleArrowKey(editor, event, direction, tableNode, tableObserver) {
   if ((direction === 'up' || direction === 'down') && isTypeaheadMenuInView(editor)) {
     return false;
@@ -2957,77 +3022,67 @@ function $handleArrowKey(editor, event, direction, tableNode, tableObserver) {
     }
     return false;
   }
-  if (lexical.$isRangeSelection(selection) && selection.isCollapsed()) {
-    const {
-      anchor,
-      focus
-    } = selection;
-    const anchorCellNode = utils.$findMatchingParent(anchor.getNode(), $isTableCellNode);
-    const focusCellNode = utils.$findMatchingParent(focus.getNode(), $isTableCellNode);
-    if (!$isTableCellNode(anchorCellNode) || !anchorCellNode.is(focusCellNode)) {
-      return false;
-    }
-    const anchorCellTable = $findTableNode(anchorCellNode);
-    if (anchorCellTable !== tableNode && anchorCellTable != null) {
-      const anchorCellTableElement = getTableElement(anchorCellTable, editor.getElementByKey(anchorCellTable.getKey()));
-      if (anchorCellTableElement != null) {
-        tableObserver.table = getTable(anchorCellTable, anchorCellTableElement);
-        return $handleArrowKey(editor, event, direction, anchorCellTable, tableObserver);
-      }
-    }
+  if (lexical.$isRangeSelection(selection)) {
     if (direction === 'backward' || direction === 'forward') {
-      const anchorType = anchor.type;
-      const anchorOffset = anchor.offset;
-      const anchorNode = anchor.getNode();
-      if (!anchorNode) {
+      const alter = event.shiftKey ? 'extend' : 'move';
+      return $handleHorizontalArrowKeyRangeSelection(editor, event, selection, alter, direction === 'backward', tableNode, tableObserver);
+    }
+    if (selection.isCollapsed()) {
+      const {
+        anchor,
+        focus
+      } = selection;
+      const anchorCellNode = utils.$findMatchingParent(anchor.getNode(), $isTableCellNode);
+      const focusCellNode = utils.$findMatchingParent(focus.getNode(), $isTableCellNode);
+      if (!$isTableCellNode(anchorCellNode) || !anchorCellNode.is(focusCellNode)) {
         return false;
       }
-      const selectedNodes = selection.getNodes();
-      if (selectedNodes.length === 1 && lexical.$isDecoratorNode(selectedNodes[0])) {
+      const anchorCellTable = $findTableNode(anchorCellNode);
+      if (anchorCellTable !== tableNode && anchorCellTable != null) {
+        const anchorCellTableElement = getTableElement(anchorCellTable, editor.getElementByKey(anchorCellTable.getKey()));
+        if (anchorCellTableElement != null) {
+          tableObserver.table = getTable(anchorCellTable, anchorCellTableElement);
+          return $handleArrowKey(editor, event, direction, anchorCellTable, tableObserver);
+        }
+      }
+      const anchorCellDom = editor.getElementByKey(anchorCellNode.__key);
+      const anchorDOM = editor.getElementByKey(anchor.key);
+      if (anchorDOM == null || anchorCellDom == null) {
         return false;
       }
-      if (isExitingTableAnchor(anchorType, anchorOffset, anchorNode, direction)) {
-        return $handleTableExit(event, anchorNode, anchorCellNode, tableNode, direction);
+      let edgeSelectionRect;
+      if (anchor.type === 'element') {
+        edgeSelectionRect = anchorDOM.getBoundingClientRect();
+      } else {
+        const domSelection = lexical.getDOMSelection(getEditorWindow(editor));
+        if (domSelection === null || domSelection.rangeCount === 0) {
+          return false;
+        }
+        const range = domSelection.getRangeAt(0);
+        edgeSelectionRect = range.getBoundingClientRect();
       }
-      return false;
-    }
-    const anchorCellDom = editor.getElementByKey(anchorCellNode.__key);
-    const anchorDOM = editor.getElementByKey(anchor.key);
-    if (anchorDOM == null || anchorCellDom == null) {
-      return false;
-    }
-    let edgeSelectionRect;
-    if (anchor.type === 'element') {
-      edgeSelectionRect = anchorDOM.getBoundingClientRect();
-    } else {
-      const domSelection = lexical.getDOMSelection(getEditorWindow(editor));
-      if (domSelection === null || domSelection.rangeCount === 0) {
+      const edgeChild = direction === 'up' ? anchorCellNode.getFirstChild() : anchorCellNode.getLastChild();
+      if (edgeChild == null) {
         return false;
       }
-      const range = domSelection.getRangeAt(0);
-      edgeSelectionRect = range.getBoundingClientRect();
-    }
-    const edgeChild = direction === 'up' ? anchorCellNode.getFirstChild() : anchorCellNode.getLastChild();
-    if (edgeChild == null) {
-      return false;
-    }
-    const edgeChildDOM = editor.getElementByKey(edgeChild.__key);
-    if (edgeChildDOM == null) {
-      return false;
-    }
-    const edgeRect = edgeChildDOM.getBoundingClientRect();
-    const isExiting = direction === 'up' ? edgeRect.top > edgeSelectionRect.top - edgeSelectionRect.height : edgeSelectionRect.bottom + edgeSelectionRect.height > edgeRect.bottom;
-    if (isExiting) {
-      stopEvent(event);
-      const cords = tableNode.getCordsFromCellNode(anchorCellNode, tableObserver.table);
-      if (event.shiftKey) {
-        const cell = tableNode.getDOMCellFromCordsOrThrow(cords.x, cords.y, tableObserver.table);
-        tableObserver.$setAnchorCellForSelection(cell);
-        tableObserver.$setFocusCellForSelection(cell, true);
-      } else {
-        return selectTableNodeInDirection(tableObserver, tableNode, cords.x, cords.y, direction);
+      const edgeChildDOM = editor.getElementByKey(edgeChild.__key);
+      if (edgeChildDOM == null) {
+        return false;
+      }
+      const edgeRect = edgeChildDOM.getBoundingClientRect();
+      const isExiting = direction === 'up' ? edgeRect.top > edgeSelectionRect.top - edgeSelectionRect.height : edgeSelectionRect.bottom + edgeSelectionRect.height > edgeRect.bottom;
+      if (isExiting) {
+        stopEvent(event);
+        const cords = tableNode.getCordsFromCellNode(anchorCellNode, tableObserver.table);
+        if (event.shiftKey) {
+          const cell = tableNode.getDOMCellFromCordsOrThrow(cords.x, cords.y, tableObserver.table);
+          tableObserver.$setAnchorCellForSelection(cell);
+          tableObserver.$setFocusCellForSelection(cell, true);
+        } else {
+          return selectTableNodeInDirection(tableObserver, tableNode, cords.x, cords.y, direction);
+        }
+        return true;
       }
-      return true;
     }
   } else if ($isTableSelection(selection)) {
     const {
@@ -3038,7 +3093,7 @@ function $handleArrowKey(editor, event, direction, tableNode, tableObserver) {
     const focusCellNode = utils.$findMatchingParent(focus.getNode(), $isTableCellNode);
     const [tableNodeFromSelection] = selection.getNodes();
     if (!$isTableNode(tableNodeFromSelection)) {
-      throw Error(`$handleArrowKey: TableSelection.getNodes()[0] expected to be TableNode`);
+      formatDevErrorMessage(`$handleArrowKey: TableSelection.getNodes()[0] expected to be TableNode`);
     }
     const tableElement = getTableElement(tableNodeFromSelection, editor.getElementByKey(tableNodeFromSelection.getKey()));
     if (!$isTableCellNode(anchorCellNode) || !$isTableCellNode(focusCellNode) || !$isTableNode(tableNodeFromSelection) || tableElement == null) {
@@ -3074,54 +3129,6 @@ function isTypeaheadMenuInView(editor) {
   }
   return root.hasAttribute('aria-controls') && root.getAttribute('aria-controls') === 'typeahead-menu';
 }
-function isExitingTableAnchor(type, offset, anchorNode, direction) {
-  return isExitingTableElementAnchor(type, anchorNode, direction) || $isExitingTableTextAnchor(type, offset, anchorNode, direction);
-}
-function isExitingTableElementAnchor(type, anchorNode, direction) {
-  return type === 'element' && (direction === 'backward' ? anchorNode.getPreviousSibling() === null : anchorNode.getNextSibling() === null);
-}
-function $isExitingTableTextAnchor(type, offset, anchorNode, direction) {
-  const parentNode = utils.$findMatchingParent(anchorNode, n => lexical.$isElementNode(n) && !n.isInline());
-  if (!parentNode) {
-    return false;
-  }
-  const hasValidOffset = direction === 'backward' ? offset === 0 : offset === anchorNode.getTextContentSize();
-  return type === 'text' && hasValidOffset && (direction === 'backward' ? parentNode.getPreviousSibling() === null : parentNode.getNextSibling() === null);
-}
-function $handleTableExit(event, anchorNode, anchorCellNode, tableNode, direction) {
-  const [tableMap, cellValue] = $computeTableMap(tableNode, anchorCellNode, anchorCellNode);
-  if (!isExitingCell(tableMap, cellValue, direction)) {
-    return false;
-  }
-  const toNode = $getExitingToNode(anchorNode, direction, tableNode);
-  if (!toNode || $isTableNode(toNode)) {
-    return false;
-  }
-  stopEvent(event);
-  if (direction === 'backward') {
-    toNode.selectEnd();
-  } else {
-    toNode.selectStart();
-  }
-  return true;
-}
-function isExitingCell(tableMap, cellValue, direction) {
-  const firstCell = tableMap[0][0];
-  const lastCell = tableMap[tableMap.length - 1][tableMap[0].length - 1];
-  const {
-    startColumn,
-    startRow
-  } = cellValue;
-  return direction === 'backward' ? startColumn === firstCell.startColumn && startRow === firstCell.startRow : startColumn === lastCell.startColumn && startRow === lastCell.startRow;
-}
-function $getExitingToNode(anchorNode, direction, tableNode) {
-  const parentNode = utils.$findMatchingParent(anchorNode, n => lexical.$isElementNode(n) && !n.isInline());
-  if (!parentNode) {
-    return undefined;
-  }
-  const anchorSibling = direction === 'backward' ? parentNode.getPreviousSibling() : parentNode.getNextSibling();
-  return anchorSibling && $isTableNode(anchorSibling) ? anchorSibling : direction === 'backward' ? tableNode.getPreviousSibling() : tableNode.getNextSibling();
-}
 function $insertParagraphAtTableEdge(edgePosition, tableNode, children) {
   const paragraphNode = lexical.$createParagraphNode();
   if (edgePosition === 'first') {
@@ -3190,14 +3197,6 @@ function $getNearestTableCellInTableFromDOMNode(tableNode, startingDOM, editorSt
   return $findParentTableCellNodeInTable(tableNode, lexical.$getNearestNodeFromDOMNode(startingDOM, editorState));
 }
 
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
 function updateColgroup(dom, config, colCount, colWidths) {
   const colGroup = dom.querySelector('colgroup');
   if (!colGroup) {
@@ -3334,7 +3333,7 @@ class TableNode extends lexical.ElementNode {
   getDOMSlot(element) {
     const tableElement = element.nodeName !== 'TABLE' && element.querySelector('table') || element;
     if (!(tableElement.nodeName === 'TABLE')) {
-      throw Error(`TableNode.getDOMSlot: createDOM() did not return a table`);
+      formatDevErrorMessage(`TableNode.getDOMSlot: createDOM() did not return a table`);
     }
     return super.getDOMSlot(tableElement).withAfter(tableElement.querySelector('colgroup'));
   }
@@ -3584,7 +3583,7 @@ class TableNode extends lexical.ElementNode {
 function $getElementForTableNode(editor, tableNode) {
   const tableElement = editor.getElementByKey(tableNode.getKey());
   if (!(tableElement !== null)) {
-    throw Error(`$getElementForTableNode: Table Element Not Found`);
+    formatDevErrorMessage(`$getElementForTableNode: Table Element Not Found`);
   }
   return getTable(tableNode, tableElement);
 }
@@ -3624,14 +3623,6 @@ function $isTableNode(node) {
   return node instanceof 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.
- *
- */
-
 function $insertTableCommandListener({
   rows,
   columns,
@@ -3687,7 +3678,7 @@ function $tableTransform(node) {
       continue;
     }
     if (!$isTableRowNode(rowNode)) {
-      throw Error(`TablePlugin: Expecting all children of TableNode to be TableRowNode, found ${rowNode.constructor.name} (type ${rowNode.getType()})`);
+      formatDevErrorMessage(`TablePlugin: Expecting all children of TableNode to be TableRowNode, found ${rowNode.constructor.name} (type ${rowNode.getType()})`);
     }
     const rowLength = gridMap[i].reduce((acc, cell) => cell ? 1 + acc : acc, 0);
     if (rowLength === maxRowLength) {
@@ -3740,14 +3731,14 @@ function registerTableCellUnmergeTransform(editor) {
       const columnsCount = gridMap[0].length;
       let row = gridNode.getFirstChild();
       if (!$isTableRowNode(row)) {
-        throw Error(`Expected TableNode first child to be a RowNode`);
+        formatDevErrorMessage(`Expected TableNode first child to be a RowNode`);
       }
       const unmerged = [];
       for (let i = 0; i < rowsCount; i++) {
         if (i !== 0) {
           row = row.getNextSibling();
           if (!$isTableRowNode(row)) {
-            throw Error(`Expected TableNode first child to be a RowNode`);
+            formatDevErrorMessage(`Expected TableNode first child to be a RowNode`);
           }
         }
         let lastRowCell = null;
@@ -3759,7 +3750,7 @@ function registerTableCellUnmergeTransform(editor) {
             unmerged.push(cell);
           } else if (cell.getColSpan() > 1 || cell.getRowSpan() > 1) {
             if (!$isTableCellNode(cell)) {
-              throw Error(`Expected TableNode cell to be a TableCellNode`);
+              formatDevErrorMessage(`Expected TableNode cell to be a TableCellNode`);
             }
             const newCell = $createTableCellNode(cell.__headerState);
             if (lastRowCell !== null) {
@@ -3835,7 +3826,7 @@ function registerTableSelectionObserver(editor, hasTabHandler = true) {
 function registerTablePlugin(editor) {
   if (!editor.hasNodes([TableNode])) {
     {
-      throw Error(`TablePlugin: TableNode is not registered on editor`);
+      formatDevErrorMessage(`TablePlugin: TableNode is not registered on editor`);
     }
   }
   return utils.mergeRegister(editor.registerCommand(INSERT_TABLE_COMMAND, $insertTableCommandListener, lexical.COMMAND_PRIORITY_EDITOR), editor.registerCommand(lexical.SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, ({