@lexical/table 0.48.0 → 0.48.1-nightly.20260720.0

package/dist/LexicalTable.dev.js

@@ -56,11 +56,20 @@ class TableCellNode extends lexical.ElementNode {
   __backgroundColor;
   /** @internal */
   __verticalAlign;
-  static getType() {
-    return 'tablecell';
-  }
-  static clone(node) {
-    return new TableCellNode(node.__headerState, node.__colSpan, node.__width, node.__key);
+  $config() {
+    return this.config('tablecell', {
+      extends: lexical.ElementNode,
+      importDOM: {
+        td: () => ({
+          conversion: $convertTableCellNodeElement,
+          priority: 0
+        }),
+        th: () => ({
+          conversion: $convertTableCellNodeElement,
+          priority: 0
+        })
+      }
+    });
   }
   afterCloneFrom(node) {
     super.afterCloneFrom(node);
@@ -71,21 +80,6 @@ class TableCellNode extends lexical.ElementNode {
     this.__headerState = node.__headerState;
     this.__width = node.__width;
   }
-  static importDOM() {
-    return {
-      td: node => ({
-        conversion: $convertTableCellNodeElement,
-        priority: 0
-      }),
-      th: node => ({
-        conversion: $convertTableCellNodeElement,
-        priority: 0
-      })
-    };
-  }
-  static importJSON(serializedNode) {
-    return $createTableCellNode().updateFromJSON(serializedNode);
-  }
   updateFromJSON(serializedNode) {
     return super.updateFromJSON(serializedNode).setHeaderStyles(serializedNode.headerState).setColSpan(serializedNode.colSpan || 1).setRowSpan(serializedNode.rowSpan || 1).setWidth(serializedNode.width || undefined).setBackgroundColor(serializedNode.backgroundColor || null).setVerticalAlign(serializedNode.verticalAlign || undefined);
   }
@@ -383,31 +377,28 @@ function formatDevErrorMessage(message) {
 class TableRowNode extends lexical.ElementNode {
   /** @internal */
   __height;
-  static getType() {
-    return 'tablerow';
-  }
-  static clone(node) {
-    return new TableRowNode(node.__height, node.__key);
+  $config() {
+    return this.config('tablerow', {
+      extends: lexical.ElementNode,
+      importDOM: {
+        tr: () => ({
+          conversion: $convertTableRowElement,
+          priority: 0
+        })
+      }
+    });
   }
   afterCloneFrom(prevNode) {
     super.afterCloneFrom(prevNode);
     this.__height = prevNode.__height;
   }
-  static importDOM() {
-    return {
-      tr: node => ({
-        conversion: $convertTableRowElement,
-        priority: 0
-      })
-    };
-  }
-  static importJSON(serializedNode) {
-    return $createTableRowNode().updateFromJSON(serializedNode);
-  }
   updateFromJSON(serializedNode) {
     return super.updateFromJSON(serializedNode).setHeight(serializedNode.height);
   }
-  constructor(height, key) {
+
+  // `height` carries an explicit `undefined` default so the constructor reports
+  // zero required arguments and `$config` can synthesize the static `clone`.
+  constructor(height = undefined, key) {
     super(key);
     this.__height = height;
   }
@@ -1391,6 +1382,11 @@ function $computeTableCellRectSpans(map, boundary) {
     topSpan
   };
 }
+
+/**
+ * Compute the bounding rectangle of two table cells in a table map,
+ * expanding iteratively to include any merged cells that overlap the boundary.
+ */
 function $computeTableCellRectBoundary(map, cellAMap, cellBMap) {
   // Initial boundaries based on the anchor and focus cells
   let minColumn = Math.min(cellAMap.startColumn, cellBMap.startColumn);
@@ -1899,7 +1895,7 @@ class TableSelection {
     selection.insertNodes(nodes);
   }
 
-  // TODO Deprecate this method. It's confusing when used with colspan|rowspan
+  /** @deprecated Use {@link $computeTableMap} and {@link $computeTableCellRectBoundary} directly. */
   getShape() {
     const {
       anchorCell,
@@ -2011,19 +2007,28 @@ class TableSelection {
     return textContent;
   }
 }
+
+/** Type guard for {@link TableSelection}. */
 function $isTableSelection(x) {
   return x instanceof TableSelection;
 }
+
+/** @deprecated Use {@link $createTableSelectionFrom} instead. */
 function $createTableSelection() {
-  // TODO this is a suboptimal design, it doesn't make sense to have
-  // a table selection that isn't associated with a table. This
-  // constructor should have required arguments and in __DEV__ we
-  // should check that they point to a table and are element points to
-  // cell nodes of that table.
   const anchor = lexical.$createPoint('root', 0, 'element');
   const focus = lexical.$createPoint('root', 0, 'element');
   return new TableSelection('root', anchor, focus);
 }
+
+/**
+ * Creates a {@link TableSelection} spanning from `anchorCell` to `focusCell`
+ * within `tableNode`. In `__DEV__` mode, validates that both cells belong to
+ * the given table and that the table is attached to the editor state.
+ *
+ * If the current selection is already a TableSelection, it clones and
+ * re-targets it (preserving identity for dirty-checking); otherwise it
+ * constructs a fresh one.
+ */
 function $createTableSelectionFrom(tableNode, anchorCell, focusCell) {
   const tableNodeKey = tableNode.getKey();
   const anchorCellKey = anchorCell.getKey();
@@ -2040,7 +2045,7 @@ function $createTableSelectionFrom(tableNode, anchorCell, focusCell) {
     } // TODO: Check for rectangular grid
   }
   const prevSelection = lexical.$getSelection();
-  const nextSelection = $isTableSelection(prevSelection) ? prevSelection.clone() : $createTableSelection();
+  const nextSelection = $isTableSelection(prevSelection) ? prevSelection.clone() : new TableSelection('root', lexical.$createPoint('root', 0, 'element'), lexical.$createPoint('root', 0, 'element'));
   nextSelection.set(tableNode.getKey(), anchorCell.getKey(), focusCell.getKey());
   return nextSelection;
 }
@@ -2899,7 +2904,7 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler, tableObse
     }
     return false;
   }, lexical.COMMAND_PRIORITY_HIGH));
-  const deleteTextHandler = command => () => {
+  const $deleteTextHandler = () => {
     const selection = lexical.$getSelection();
     if (!$isSelectionInTable(selection, tableNode)) {
       return false;
@@ -2907,34 +2912,11 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler, tableObse
     if ($isTableSelection(selection)) {
       tableObserver.$clearText();
       return true;
-    } else if (lexical.$isRangeSelection(selection)) {
-      const tableCellNode = $findParentTableCellNodeInTable(tableNode, selection.anchor.getNode());
-      if (!$isTableCellNode(tableCellNode)) {
-        return false;
-      }
-      const anchorNode = selection.anchor.getNode();
-      const focusNode = selection.focus.getNode();
-      const isAnchorInside = tableNode.isParentOf(anchorNode);
-      const isFocusInside = tableNode.isParentOf(focusNode);
-      const selectionContainsPartialTable = isAnchorInside && !isFocusInside || isFocusInside && !isAnchorInside;
-      if (selectionContainsPartialTable) {
-        tableObserver.$clearText();
-        return true;
-      }
-      const nearestElementNode = lexical.$findMatchingParent(selection.anchor.getNode(), n => lexical.$isElementNode(n));
-      const topLevelCellElementNode = nearestElementNode && lexical.$findMatchingParent(nearestElementNode, n => lexical.$isElementNode(n) && $isTableCellNode(n.getParent()));
-      if (!lexical.$isElementNode(topLevelCellElementNode) || !lexical.$isElementNode(nearestElementNode)) {
-        return false;
-      }
-      if (command === lexical.DELETE_LINE_COMMAND && topLevelCellElementNode.getPreviousSibling() === null) {
-        // TODO: Fix Delete Line in Table Cells.
-        return true;
-      }
     }
     return false;
   };
   for (const command of DELETE_TEXT_COMMANDS) {
-    tableObserver.listenersToRemove.add(editor.registerCommand(command, deleteTextHandler(command), lexical.COMMAND_PRIORITY_HIGH));
+    tableObserver.listenersToRemove.add(editor.registerCommand(command, $deleteTextHandler, lexical.COMMAND_PRIORITY_HIGH));
   }
   const $deleteCellHandler = event => {
     const selection = lexical.$getSelection();
@@ -3047,11 +3029,6 @@ function applyTableHandlers(tableNode, element, editor, hasTabHandler, tableObse
     if ($isTableSelection(selection)) {
       tableObserver.$formatCells(payload);
       return true;
-    } else if (lexical.$isRangeSelection(selection)) {
-      const tableCellNode = lexical.$findMatchingParent(selection.anchor.getNode(), n => $isTableCellNode(n));
-      if (!$isTableCellNode(tableCellNode)) {
-        return false;
-      }
     }
     return false;
   }, lexical.COMMAND_PRIORITY_HIGH));
@@ -4197,10 +4174,167 @@ function alignTableElement(dom, config, formatType) {
   lexical.removeClassNamesFromElement(dom, ...removeClasses);
   lexical.addClassNamesToElement(dom, ...addClasses);
 }
+function $createScrollableWrapper(tableElement, config, hideNativeScrollbar) {
+  const wrapper = lexical.$getDocument().createElement('div');
+  const classes = config.theme.tableScrollableWrapper;
+  if (classes) {
+    lexical.addClassNamesToElement(wrapper, classes);
+  } else {
+    wrapper.style.overflowX = 'auto';
+  }
+  if (hideNativeScrollbar) {
+    wrapper.style.scrollbarWidth = 'none';
+  }
+  wrapper.appendChild(tableElement);
+  return wrapper;
+}
+function $createStickyScrollbar(config) {
+  const doc = lexical.$getDocument();
+  const scrollbar = doc.createElement('div');
+  const classes = config.theme.tableStickyScrollbar;
+  if (classes) {
+    lexical.addClassNamesToElement(scrollbar, classes);
+  } else {
+    scrollbar.style.position = 'sticky';
+    scrollbar.style.bottom = '0';
+    scrollbar.style.overflowX = 'scroll';
+    scrollbar.style.overflowY = 'hidden';
+  }
+  scrollbar.style.display = 'none';
+  scrollbar.setAttribute('aria-hidden', 'true');
+  scrollbar.tabIndex = -1;
+  const spacer = doc.createElement('div');
+  spacer.style.height = '1px';
+  spacer.style.width = '0px';
+  scrollbar.appendChild(spacer);
+  return scrollbar;
+}
+// Unthemed sticky scrollbars whose environment cannot render a persistent
+// proxy scrollbar (overlay scrollbars reserve no height and show no idle
+// thumb), permanently hidden in favor of the wrapper's native scrollbar.
+const overlayStickyScrollbars = new WeakSet();
+function measureScrollbarThickness(scrollbar) {
+  const prevDisplay = scrollbar.style.display;
+  scrollbar.style.display = '';
+  const thickness = scrollbar.offsetHeight - scrollbar.clientHeight;
+  scrollbar.style.display = prevDisplay;
+  return thickness;
+}
+function attachStickyScrollbarListeners(elements) {
+  const {
+    scrollable,
+    scrollbar,
+    tableElement
+  } = elements;
+  // A themed scrollbar (theme.tableStickyScrollbar, detectable by its
+  // classes) is the integrator's responsibility to keep visible (e.g. via
+  // ::-webkit-scrollbar height or scrollbar-width). The unthemed fallback
+  // relies on classic native scrollbars for its height, so where the
+  // environment renders overlay scrollbars (no reserved thickness — e.g.
+  // macOS "show scrollbars when scrolling", or non-layout environments like
+  // jsdom) the proxy would be an invisible strip: keep it hidden and
+  // restore the wrapper's native scrollbar instead of presenting no scroll
+  // affordance at all.
+  if (scrollbar.classList.length === 0 && measureScrollbarThickness(scrollbar) === 0) {
+    overlayStickyScrollbars.add(scrollbar);
+    scrollbar.style.display = 'none';
+    scrollable.style.scrollbarWidth = 'auto';
+    return () => {};
+  }
+  const onWrapperScroll = () => {
+    if (scrollbar.scrollLeft !== scrollable.scrollLeft) {
+      scrollbar.scrollLeft = scrollable.scrollLeft;
+    }
+  };
+  const onScrollbarScroll = () => {
+    if (scrollable.scrollLeft !== scrollbar.scrollLeft) {
+      scrollable.scrollLeft = scrollbar.scrollLeft;
+    }
+  };
+  scrollable.addEventListener('scroll', onWrapperScroll, {
+    passive: true
+  });
+  scrollbar.addEventListener('scroll', onScrollbarScroll, {
+    passive: true
+  });
+  let resizeObserver = null;
+  if (typeof ResizeObserver !== 'undefined') {
+    resizeObserver = new ResizeObserver(() => {
+      syncStickyScrollbar(scrollable, scrollbar);
+    });
+    resizeObserver.observe(scrollable);
+    resizeObserver.observe(tableElement);
+  }
+  const cleanup = () => {
+    scrollable.removeEventListener('scroll', onWrapperScroll);
+    scrollbar.removeEventListener('scroll', onScrollbarScroll);
+    if (resizeObserver) {
+      resizeObserver.disconnect();
+    }
+  };
+  syncStickyScrollbar(scrollable, scrollbar);
+  return cleanup;
+}
+function syncStickyScrollbar(scrollable, scrollbar) {
+  if (overlayStickyScrollbars.has(scrollbar)) {
+    return;
+  }
+  const spacer = scrollbar.firstElementChild;
+  if (!spacer || !lexical.isHTMLElement(spacer) || !scrollable.isConnected) {
+    return;
+  }
+  const view = scrollable.ownerDocument.defaultView;
+  if (!view) {
+    scrollbar.style.display = 'none';
+    return;
+  }
+  // All layout reads happen before any write so a sync forces at most one
+  // reflow, and both metrics come from the same element so their rounding
+  // can't disagree at fractional zoom levels.
+  const overflowX = view.getComputedStyle(scrollable).overflowX;
+  const isScrollable = overflowX === 'auto' || overflowX === 'scroll';
+  const scrollWidth = scrollable.scrollWidth;
+  const clientWidth = scrollable.clientWidth;
+  const spacerWidth = scrollWidth + 'px';
+  if (spacer.style.width !== spacerWidth) {
+    spacer.style.width = spacerWidth;
+  }
+  const hasOverflow = isScrollable && scrollWidth > clientWidth;
+  scrollbar.style.display = hasOverflow ? '' : 'none';
+}
+function findStickyScrollbarElements(dom) {
+  if (!dom.hasAttribute('data-lexical-sticky-scrollbar')) {
+    return null;
+  }
+  const firstChild = dom.firstElementChild;
+  if (!isHTMLDivElement(firstChild)) {
+    return null;
+  }
+  const tableElement = firstChild.querySelector(':scope > table');
+  if (!isHTMLTableElement(tableElement)) {
+    return null;
+  }
+  const scrollbar = firstChild.nextElementSibling;
+  if (!isHTMLDivElement(scrollbar)) {
+    return null;
+  }
+  return {
+    scrollable: firstChild,
+    scrollbar,
+    tableElement
+  };
+}
 const scrollableEditors = new WeakSet();
 function $isScrollableTablesActive(editor = lexical.$getEditor()) {
   return scrollableEditors.has(editor);
 }
+function $isStickyScrollbarActive(editor = lexical.$getEditor()) {
+  const dep = extension.getPeerDependencyFromEditor(editor, '@lexical/table/Table');
+  // peek() so a reconcile that runs inside a signals effect (e.g. via a
+  // discrete update or force-commit read) does not subscribe that effect to
+  // the table config; re-rendering on change is the TableExtension's job.
+  return dep ? dep.output.hasStickyScrollbar.peek() && dep.output.hasHorizontalScroll.peek() : false;
+}
 function setScrollableTablesActive(editor, active) {
   if (active) {
     if (!editor._config.theme.tableScrollableWrapper) {
@@ -4215,12 +4349,24 @@ function setScrollableTablesActive(editor, active) {
 /** @noInheritDoc */
 class TableNode extends lexical.ElementNode {
   /** @internal */
-  __rowStriping;
-  __frozenColumnCount;
-  __frozenRowCount;
-  __colWidths;
-  static getType() {
-    return 'table';
+  __rowStriping = false;
+  __frozenColumnCount = 0;
+  __frozenRowCount = 0;
+  // Initialized unconditionally (not `__colWidths?: ...`) so a freshly
+  // constructed instance always has the own property — `@lexical/yjs` derives a
+  // node's syncable properties from `Object.keys(new Klass())`, so an
+  // uninitialized optional field would silently drop out of collab sync.
+  __colWidths = undefined;
+  $config() {
+    return this.config('table', {
+      extends: lexical.ElementNode,
+      importDOM: {
+        table: () => ({
+          conversion: $convertTableElement,
+          priority: 1
+        })
+      }
+    });
   }
   getColWidths() {
     const self = this.getLatest();
@@ -4232,9 +4378,6 @@ class TableNode extends lexical.ElementNode {
     self.__colWidths = colWidths !== undefined && __DEV__ ? Object.freeze(colWidths) : colWidths;
     return self;
   }
-  static clone(node) {
-    return new TableNode(node.__key);
-  }
   afterCloneFrom(prevNode) {
     super.afterCloneFrom(prevNode);
     this.__colWidths = prevNode.__colWidths;
@@ -4242,27 +4385,9 @@ class TableNode extends lexical.ElementNode {
     this.__frozenColumnCount = prevNode.__frozenColumnCount;
     this.__frozenRowCount = prevNode.__frozenRowCount;
   }
-  static importDOM() {
-    return {
-      table: _node => ({
-        conversion: $convertTableElement,
-        priority: 1
-      })
-    };
-  }
-  static importJSON(serializedNode) {
-    return $createTableNode().updateFromJSON(serializedNode);
-  }
   updateFromJSON(serializedNode) {
     return super.updateFromJSON(serializedNode).setRowStriping(serializedNode.rowStriping || false).setFrozenColumns(serializedNode.frozenColumnCount || 0).setFrozenRows(serializedNode.frozenRowCount || 0).setColWidths(serializedNode.colWidths);
   }
-  constructor(key) {
-    super(key);
-    this.__rowStriping = false;
-    this.__frozenColumnCount = 0;
-    this.__frozenRowCount = 0;
-    this.__colWidths = undefined;
-  }
   exportJSON() {
     return {
       ...super.exportJSON(),
@@ -4293,16 +4418,19 @@ class TableNode extends lexical.ElementNode {
     lexical.addClassNamesToElement(tableElement, config.theme.table);
     this.updateTableElement(null, tableElement, config);
     if ($isScrollableTablesActive(editor)) {
-      const wrapperElement = lexical.$getDocument().createElement('div');
-      const classes = config.theme.tableScrollableWrapper;
-      if (classes) {
-        lexical.addClassNamesToElement(wrapperElement, classes);
-      } else {
-        wrapperElement.style.overflowX = 'auto';
-      }
-      wrapperElement.appendChild(tableElement);
-      this.updateTableWrapper(null, wrapperElement, tableElement, config);
-      return wrapperElement;
+      const hasStickyScrollbar = $isStickyScrollbarActive(editor);
+      const scrollableWrapper = $createScrollableWrapper(tableElement, config, hasStickyScrollbar);
+      this.updateTableWrapper(null, scrollableWrapper, tableElement, config);
+      if (hasStickyScrollbar) {
+        const stickyScrollbar = $createStickyScrollbar(config);
+        const outerWrapper = lexical.$getDocument().createElement('div');
+        outerWrapper.setAttribute('data-lexical-sticky-scrollbar', 'true');
+        outerWrapper.appendChild(scrollableWrapper);
+        outerWrapper.appendChild(stickyScrollbar);
+        lexical.setDOMUnmanaged(stickyScrollbar);
+        return outerWrapper;
+      }
+      return scrollableWrapper;
     }
     return tableElement;
   }
@@ -4334,7 +4462,16 @@ class TableNode extends lexical.ElementNode {
       return true;
     }
     if (isHTMLDivElement(dom)) {
-      this.updateTableWrapper(prevNode, dom, tableElement, config);
+      const hasStickyDom = dom.hasAttribute('data-lexical-sticky-scrollbar');
+      if (hasStickyDom !== $isStickyScrollbarActive()) {
+        return true;
+      }
+      // The scrollable wrapper is the table's immediate parent in both
+      // layouts (the inner div in sticky mode, dom itself otherwise).
+      const scrollable = tableElement.parentElement;
+      if (isHTMLDivElement(scrollable)) {
+        this.updateTableWrapper(prevNode, scrollable, tableElement, config);
+      }
     }
     this.updateTableElement(prevNode, tableElement, config);
     return false;
@@ -5157,6 +5294,51 @@ const TableImportRules = [TableRule, TableRowRule, TableCellRule];
  *
  */
 
+function registerStickyScrollbar(editor) {
+  const attached = new Map();
+  const detachAll = () => {
+    for (const {
+      cleanup
+    } of attached.values()) {
+      cleanup();
+    }
+    attached.clear();
+  };
+  return lexical.mergeRegister(detachAll, editor.registerMutationListener(TableNode, nodeMutations => {
+    for (const [nodeKey, mutation] of nodeMutations) {
+      const prev = attached.get(nodeKey);
+      if (mutation === 'destroyed') {
+        if (prev) {
+          prev.cleanup();
+          attached.delete(nodeKey);
+        }
+        continue;
+      }
+      const dom = editor.getElementByKey(nodeKey);
+      const parts = dom && lexical.isHTMLElement(dom) ? findStickyScrollbarElements(dom) : null;
+      if (prev && parts && prev.parts.scrollable === parts.scrollable && prev.parts.scrollbar === parts.scrollbar && prev.parts.tableElement === parts.tableElement) {
+        // Same DOM: keep the listeners, but resync since the
+        // update may still change scrollability (e.g. a frozen
+        // rows toggle switches the wrapper to overflow-x: clip).
+        syncStickyScrollbar(parts.scrollable, parts.scrollbar);
+        continue;
+      }
+      if (prev) {
+        prev.cleanup();
+        attached.delete(nodeKey);
+      }
+      if (parts) {
+        attached.set(nodeKey, {
+          cleanup: attachStickyScrollbarListeners(parts),
+          parts
+        });
+      }
+    }
+  }, {
+    skipInitialization: false
+  }));
+}
+
 /**
  * Configures {@link TableNode}, {@link TableRowNode}, {@link TableCellNode} and
  * registers table behaviors (see {@link TableConfig})
@@ -5170,6 +5352,7 @@ const TableExtension = /* @__PURE__ */lexical.defineExtension({
     hasCellMerge: true,
     hasHorizontalScroll: true,
     hasNestedTables: false,
+    hasStickyScrollbar: false,
     hasTabHandler: true
   }),
   dependencies: [
@@ -5183,18 +5366,31 @@ const TableExtension = /* @__PURE__ */lexical.defineExtension({
   nodes: () => [TableNode, TableRowNode, TableCellNode],
   register(editor, config, state) {
     const stores = state.getOutput();
+    let prevStickyScrollbar = false;
     return lexical.mergeRegister(extension.effect(() => {
       const hasHorizontalScroll = stores.hasHorizontalScroll.value;
+      const hasStickyScrollbar = stores.hasStickyScrollbar.value && hasHorizontalScroll;
       const hadHorizontalScroll = $isScrollableTablesActive(editor);
       if (hadHorizontalScroll !== hasHorizontalScroll) {
         setScrollableTablesActive(editor, hasHorizontalScroll);
+      }
+      if (hadHorizontalScroll !== hasHorizontalScroll || prevStickyScrollbar !== hasStickyScrollbar) {
         // Re-render existing tables through the new scroll-wrapper config
         // without cloning every TableNode the way marking them dirty would. A
         // full reconcile marks no nodes dirty, so it's deferred (no
         // synchronous render from this effect) and produces no history entry.
         editor.update(lexical.$fullReconcile);
       }
-    }), registerTablePlugin(editor, stores), extension.effect(() => registerTableSelectionObserver(editor, stores.hasTabHandler.value)), extension.effect(() => stores.hasCellMerge.value ? undefined : registerTableCellUnmergeTransform(editor)), extension.effect(() => stores.hasCellBackgroundColor.value ? undefined : editor.registerNodeTransform(TableCellNode, node => {
+      prevStickyScrollbar = hasStickyScrollbar;
+    }), registerTablePlugin(editor, stores), extension.effect(() => registerTableSelectionObserver(editor, stores.hasTabHandler.value)), extension.effect(() => {
+      if (stores.hasStickyScrollbar.value && stores.hasHorizontalScroll.value) {
+        return editor.registerRootListener(rootElement => {
+          if (rootElement) {
+            return registerStickyScrollbar(editor);
+          }
+        });
+      }
+    }), extension.effect(() => stores.hasCellMerge.value ? undefined : registerTableCellUnmergeTransform(editor)), extension.effect(() => stores.hasCellBackgroundColor.value ? undefined : editor.registerNodeTransform(TableCellNode, node => {
       if (node.getBackgroundColor() !== null) {
         node.setBackgroundColor(null);
       }
@@ -5216,6 +5412,7 @@ const TableImportExtension = /* @__PURE__ */lexical.defineExtension({
   name: '@lexical/table/Import'
 });
 
+exports.$computeTableCellRectBoundary = $computeTableCellRectBoundary;
 exports.$computeTableMap = $computeTableMap;
 exports.$computeTableMapSkipCellCheck = $computeTableMapSkipCellCheck;
 exports.$createTableCellNode = $createTableCellNode;
@@ -5250,6 +5447,7 @@ exports.$insertTableRowAtSelection = $insertTableRowAtSelection;
 exports.$insertTableRow__EXPERIMENTAL = $insertTableRow__EXPERIMENTAL;
 exports.$isScrollableTablesActive = $isScrollableTablesActive;
 exports.$isSimpleTable = $isSimpleTable;
+exports.$isStickyScrollbarActive = $isStickyScrollbarActive;
 exports.$isTableCellNode = $isTableCellNode;
 exports.$isTableNode = $isTableNode;
 exports.$isTableRowNode = $isTableRowNode;