@kopexa/extension-table 17.0.46 → 17.1.0

package/dist/index.mjs

@@ -1,34 +1,56 @@
 "use client";
 import {
-  TableKit
-} from "./chunk-2L3HZWWG.mjs";
+  TableHandle
+} from "./chunk-TEGO6KUS.mjs";
+import "./chunk-62B2LU2Q.mjs";
 import {
-  TableCell
-} from "./chunk-DR2GZJH6.mjs";
+  TableSelectionOverlay
+} from "./chunk-2NBDRVYL.mjs";
+import "./chunk-G6GHC2WO.mjs";
+import "./chunk-6FHFDGJO.mjs";
+import {
+  TableCellHandleMenu
+} from "./chunk-XRNQXADK.mjs";
+import "./chunk-KIYFW7MP.mjs";
+import {
+  TableAlignMenuItems,
+  TableAlignSubMenu
+} from "./chunk-VQV757EG.mjs";
+import "./chunk-VIBVRWS4.mjs";
+import "./chunk-KTRZVXJC.mjs";
+import "./chunk-4QSZXHZO.mjs";
+import "./chunk-ZVPJDJBO.mjs";
+import "./chunk-CPDSPBS6.mjs";
+import "./chunk-GBTQVIN5.mjs";
+import "./chunk-GDEXPEW5.mjs";
+import "./chunk-CD62W5C3.mjs";
 import {
-  TableHeader
-} from "./chunk-POJFNXG7.mjs";
+  messages
+} from "./chunk-CN73TYHV.mjs";
 import {
-  TableRow
-} from "./chunk-HWVA6DOK.mjs";
-import "./chunk-RPPUD4R5.mjs";
+  TableKit
+} from "./chunk-MB52MZQ4.mjs";
+import {
+  TableCell
+} from "./chunk-E7W2KRZG.mjs";
+import "./chunk-LUA32VH4.mjs";
+import "./chunk-3SWV7BGP.mjs";
+import "./chunk-GQLZBIWF.mjs";
+import "./chunk-5B5XIL2G.mjs";
 import {
   Table
-} from "./chunk-LPHCE6EI.mjs";
-import {
-  TableNodeView
-} from "./chunk-GHOJLOCF.mjs";
-import "./chunk-KNOMCS6F.mjs";
-import "./chunk-3XEOCAHB.mjs";
-import "./chunk-KLUH6EZS.mjs";
-import "./chunk-BTJ3DCGC.mjs";
-import "./chunk-QHD3QTD2.mjs";
+} from "./chunk-IRJ6RAVQ.mjs";
+import "./chunk-PTX5UYV6.mjs";
+import "./chunk-J4VOSZCZ.mjs";
 import "./chunk-WKV76XOR.mjs";
 export {
   Table,
+  TableAlignMenuItems,
+  TableAlignSubMenu,
   TableCell,
-  TableHeader,
+  TableCellHandleMenu,
+  TableHandle,
   TableKit,
-  TableNodeView,
-  TableRow
+  TableSelectionOverlay,
+  messages as tableMessages
 };

package/dist/lib/constants.d.mts

@@ -0,0 +1,4 @@
+declare const EMPTY_CELL_WIDTH = 120;
+declare const RESIZE_MIN_WIDTH = 35;
+
+export { EMPTY_CELL_WIDTH, RESIZE_MIN_WIDTH };

package/dist/lib/constants.d.ts

@@ -0,0 +1,4 @@
+declare const EMPTY_CELL_WIDTH = 120;
+declare const RESIZE_MIN_WIDTH = 35;
+
+export { EMPTY_CELL_WIDTH, RESIZE_MIN_WIDTH };

package/dist/{table/lib/is-cell-selection.js → lib/constants.js}

@@ -18,17 +18,17 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/table/lib/is-cell-selection.ts
-var is_cell_selection_exports = {};
-__export(is_cell_selection_exports, {
-  isCellSelection: () => isCellSelection
+// src/lib/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  EMPTY_CELL_WIDTH: () => EMPTY_CELL_WIDTH,
+  RESIZE_MIN_WIDTH: () => RESIZE_MIN_WIDTH
 });
-module.exports = __toCommonJS(is_cell_selection_exports);
-var import_tables = require("@tiptap/pm/tables");
-function isCellSelection(value) {
-  return value instanceof import_tables.CellSelection;
-}
+module.exports = __toCommonJS(constants_exports);
+var EMPTY_CELL_WIDTH = 120;
+var RESIZE_MIN_WIDTH = 35;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  isCellSelection
+  EMPTY_CELL_WIDTH,
+  RESIZE_MIN_WIDTH
 });

package/dist/lib/constants.mjs

@@ -0,0 +1,10 @@
+"use client";
+import {
+  EMPTY_CELL_WIDTH,
+  RESIZE_MIN_WIDTH
+} from "../chunk-PTX5UYV6.mjs";
+import "../chunk-WKV76XOR.mjs";
+export {
+  EMPTY_CELL_WIDTH,
+  RESIZE_MIN_WIDTH
+};

package/dist/lib/create-image.d.mts

@@ -0,0 +1,12 @@
+import { Editor } from '@tiptap/core';
+
+/**
+ * Public API
+ * Creates a polished drag image for a row/column from a TipTap/ProseMirror table.
+ * - Subtle rounded corners & shadow
+ * - Scales down if it exceeds editor width
+ * - Preserves computed styles to look 1:1 with the table
+ */
+declare function createTableDragImage(editor: Editor, orientation: "row" | "col", index: number, tablePos: number): HTMLElement;
+
+export { createTableDragImage };

package/dist/lib/create-image.d.ts

@@ -0,0 +1,12 @@
+import { Editor } from '@tiptap/core';
+
+/**
+ * Public API
+ * Creates a polished drag image for a row/column from a TipTap/ProseMirror table.
+ * - Subtle rounded corners & shadow
+ * - Scales down if it exceeds editor width
+ * - Preserves computed styles to look 1:1 with the table
+ */
+declare function createTableDragImage(editor: Editor, orientation: "row" | "col", index: number, tablePos: number): HTMLElement;
+
+export { createTableDragImage };

package/dist/lib/create-image.js

@@ -0,0 +1,221 @@
+"use client";
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lib/create-image.ts
+var create_image_exports = {};
+__export(create_image_exports, {
+  createTableDragImage: () => createTableDragImage
+});
+module.exports = __toCommonJS(create_image_exports);
+var STYLE_PROPS = [
+  // Box & border
+  "boxSizing",
+  "backgroundColor",
+  "borderTopColor",
+  "borderRightColor",
+  "borderBottomColor",
+  "borderLeftColor",
+  "borderTopStyle",
+  "borderRightStyle",
+  "borderBottomStyle",
+  "borderLeftStyle",
+  "borderTopWidth",
+  "borderRightWidth",
+  "borderBottomWidth",
+  "borderLeftWidth",
+  "borderRadius",
+  // Spacing
+  "paddingTop",
+  "paddingRight",
+  "paddingBottom",
+  "paddingLeft",
+  // Typography
+  "color",
+  "font",
+  "fontFamily",
+  "fontSize",
+  "fontWeight",
+  "fontStyle",
+  "lineHeight",
+  "letterSpacing",
+  "textTransform",
+  "textDecoration",
+  "textAlign",
+  "verticalAlign",
+  "whiteSpace",
+  // Sizing
+  "width",
+  "minWidth",
+  "maxWidth",
+  "height",
+  "minHeight",
+  "maxHeight",
+  // Table specifics
+  "backgroundClip"
+];
+var toDash = (p) => p.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+function copyComputedStyles(source, target) {
+  const cs = getComputedStyle(source);
+  for (const p of STYLE_PROPS) {
+    const prop = String(p);
+    const val = cs.getPropertyValue(toDash(prop));
+    if (val) target.style[prop] = val;
+  }
+  target.style.overflow = "hidden";
+  target.style.textOverflow = "ellipsis";
+  if (cs.whiteSpace === "" || cs.whiteSpace === "normal") {
+    target.style.whiteSpace = "nowrap";
+  }
+}
+function cloneWithStyles(root) {
+  const clone = root.cloneNode(true);
+  const q = [{ src: root, dst: clone }];
+  while (q.length) {
+    const { src, dst } = q.shift();
+    if (src instanceof HTMLElement && dst instanceof HTMLElement) {
+      copyComputedStyles(src, dst);
+    }
+    const srcChildren = Array.from(src.children);
+    const dstChildren = Array.from(dst.children);
+    const len = Math.min(srcChildren.length, dstChildren.length);
+    for (let i = 0; i < len; i++) {
+      const srcChild = srcChildren[i];
+      const dstChild = dstChildren[i];
+      if (srcChild && dstChild) {
+        q.push({ src: srcChild, dst: dstChild });
+      }
+    }
+  }
+  return clone;
+}
+function styleDragWrapper(el, maxWidth) {
+  Object.assign(el.style, {
+    position: "fixed",
+    top: "-10000px",
+    left: "-10000px",
+    pointerEvents: "none",
+    zIndex: "2147483647",
+    maxWidth: `${maxWidth}px`,
+    borderRadius: "12px",
+    background: "transparent",
+    filter: "drop-shadow(0 8px 24px rgba(0,0,0,0.18)) drop-shadow(0 2px 8px rgba(0,0,0,0.10))",
+    overflow: "hidden"
+  });
+}
+function scaleToFit(el, maxWidth) {
+  if (!el.isConnected) document.body.appendChild(el);
+  const rect = el.getBoundingClientRect();
+  if (rect.width > maxWidth && rect.width > 0) {
+    const scale = maxWidth / rect.width;
+    el.style.transformOrigin = "top left";
+    el.style.transform = `scale(${scale})`;
+  }
+}
+function applyTableBoxStyles(srcTable, dstTable) {
+  const tcs = getComputedStyle(srcTable);
+  dstTable.style.borderCollapse = tcs.borderCollapse;
+  dstTable.style.borderSpacing = tcs.borderSpacing;
+  dstTable.style.tableLayout = "fixed";
+  dstTable.className = srcTable.className;
+}
+function lockCellWidth(fromCell, toCell) {
+  const rect = fromCell.getBoundingClientRect();
+  if (rect.width > 0) {
+    toCell.style.width = `${rect.width}px`;
+    toCell.style.maxWidth = `${rect.width}px`;
+  }
+}
+function buildRowPreview(tableEl, rowIndex) {
+  var _a, _b, _c;
+  const body = (_b = (_a = tableEl.tBodies) == null ? void 0 : _a[0]) != null ? _b : tableEl.querySelector("tbody");
+  if (!body) return null;
+  const row = (_c = body.rows) == null ? void 0 : _c[rowIndex];
+  if (!row) return null;
+  const tableClone = document.createElement("table");
+  const tbodyClone = document.createElement("tbody");
+  const rowClone = cloneWithStyles(row);
+  applyTableBoxStyles(tableEl, tableClone);
+  for (let i = 0; i < row.cells.length; i++) {
+    const src = row.cells[i];
+    const dst = rowClone.cells[i];
+    if (dst) lockCellWidth(src, dst);
+  }
+  tbodyClone.appendChild(rowClone);
+  tableClone.appendChild(tbodyClone);
+  return tableClone;
+}
+function buildColumnPreview(tableEl, colIndex) {
+  var _a, _b, _c;
+  const body = (_b = (_a = tableEl.tBodies) == null ? void 0 : _a[0]) != null ? _b : tableEl.querySelector("tbody");
+  if (!body) return null;
+  const tableClone = document.createElement("table");
+  const tbodyClone = document.createElement("tbody");
+  applyTableBoxStyles(tableEl, tableClone);
+  let firstCellWidth = 0;
+  for (let r = 0; r < body.rows.length; r++) {
+    const srcRow = body.rows[r];
+    if (!srcRow) continue;
+    const srcCell = (_c = srcRow.cells) == null ? void 0 : _c[colIndex];
+    if (!srcCell) continue;
+    const tr = document.createElement("tr");
+    const cellClone = cloneWithStyles(srcCell);
+    const rect = srcCell.getBoundingClientRect();
+    if (!firstCellWidth && rect.width > 0) firstCellWidth = rect.width;
+    lockCellWidth(srcCell, cellClone);
+    tr.appendChild(cellClone);
+    tbodyClone.appendChild(tr);
+  }
+  if (firstCellWidth > 0) {
+    tableClone.style.width = `${firstCellWidth}px`;
+    tableClone.style.maxWidth = `${firstCellWidth}px`;
+  }
+  tableClone.appendChild(tbodyClone);
+  return tableClone;
+}
+function createTableDragImage(editor, orientation, index, tablePos) {
+  const editorRect = editor.view.dom.getBoundingClientRect();
+  const maxWidth = Math.max(0, editorRect.width);
+  const wrapper = document.createElement("div");
+  styleDragWrapper(wrapper, maxWidth);
+  const tableEl = editor.view.nodeDOM(tablePos);
+  if (!tableEl) {
+    document.body.appendChild(wrapper);
+    return wrapper;
+  }
+  const tableRect = tableEl.getBoundingClientRect();
+  const dragWidth = Math.min(tableRect.width, editorRect.width);
+  wrapper.style.width = `${dragWidth}px`;
+  const preview = orientation === "row" ? buildRowPreview(tableEl, index) : buildColumnPreview(tableEl, index);
+  if (preview) {
+    const card = document.createElement("div");
+    Object.assign(card.style, {
+      background: "var(--drag-image-bg, transparent)",
+      overflow: "hidden"
+    });
+    card.appendChild(preview);
+    wrapper.appendChild(card);
+  }
+  scaleToFit(wrapper, maxWidth);
+  return wrapper;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createTableDragImage
+});

package/dist/lib/create-image.mjs

@@ -0,0 +1,8 @@
+"use client";
+import {
+  createTableDragImage
+} from "../chunk-GQLZBIWF.mjs";
+import "../chunk-WKV76XOR.mjs";
+export {
+  createTableDragImage
+};

package/dist/lib/table-utils.d.mts

@@ -0,0 +1,263 @@
+import { Node } from '@tiptap/pm/model';
+import { Transaction, EditorState, Command } from '@tiptap/pm/state';
+import { TableMap, FindNodeResult, Rect } from '@tiptap/pm/tables';
+import { Editor } from '@tiptap/react';
+
+type Orientation = "row" | "column";
+type TableInfo = {
+    map: TableMap;
+} & FindNodeResult;
+interface CellInfo extends FindNodeResult {
+    row: number;
+    column: number;
+}
+type DomCellAroundResult = {
+    type: "cell";
+    domNode: HTMLElement;
+    tbodyNode: HTMLTableSectionElement | null;
+} | {
+    type: "wrapper";
+    domNode: HTMLElement;
+    tbodyNode: HTMLTableSectionElement | null;
+};
+/**
+ * Walk up from an element until we find a TD/TH or the table wrapper.
+ * Returns the found element plus its tbody (if present).
+ */
+declare function domCellAround(target: Element): DomCellAroundResult | undefined;
+/**
+ * Given a DOM cell element, find its (row, col) indices within the table.
+ *
+ * This function:
+ * - Locates the nearest ancestor table element
+ * - Uses the editor's document model to resolve the cell's position
+ * - Traverses up the node hierarchy to find the corresponding table cell node
+ * - Uses `TableMap` to translate the cell's position into (row, col) indices
+ *
+ * Returns null if:
+ * - the table or cell cannot be found in the editor's document
+ * - any error occurs during position resolution
+ *
+ * @param cell      The HTMLTableCellElement (td or th)
+ * @param tableNode The table node in the ProseMirror document
+ * @param editor    The Tiptap editor instance
+ * @returns An object with { rowIndex, colIndex } or null if not found
+ */
+declare function getCellIndicesFromDOM(cell: HTMLTableCellElement, tableNode: Node | null, editor: Editor): {
+    rowIndex: number;
+    colIndex: number;
+} | null;
+/**
+ * Checks if a cell is merged (has colspan or rowspan > 1)
+ */
+declare function isCellMerged(node: Node | null): boolean;
+/**
+ * Collect cells (and unique merged cells) from the current table.
+ * - If `columnIndex` is provided, scans that column.
+ * - If omitted, uses the first (leftmost) selected column based on the current selection.
+ */
+declare function getColumnCells(editor: Editor | null, columnIndex?: number, tablePos?: number): {
+    cells: CellInfo[];
+    mergedCells: CellInfo[];
+};
+/**
+ * Get information about the table at the current selection or a specific position.
+ *
+ * If `tablePos` is provided, it looks for a table at that exact position.
+ * Otherwise, it finds the nearest table containing the current selection.
+ *
+ * Returns an object with:
+ * - `node`: the table node
+ * - `pos`: the position of the table in the document
+ * - `start`: the position just after the table node (where its content starts)
+ * - `map`: the `TableMap` for layout info (rows, columns, spans)
+ *
+ * If no table is found, returns null.
+ */
+declare function getTable(editor: Editor | null, tablePos?: number): {
+    map: TableMap;
+    node: Node;
+    pos: number;
+    start: number;
+    depth: number;
+} | null;
+/**
+ * Get all (row, col) coordinates for a given row or column index.
+ *
+ * - If `orientation` is "row", returns all columns in that row.
+ * - If `orientation` is "column", returns all rows in that column.
+ *
+ * Returns null if:
+ * - the editor or table is not found
+ * - the index is out of bounds
+ *
+ * @param editor      The Tiptap editor instance
+ * @param index       The row or column index (0-based)
+ * @param orientation "row" to get row coordinates, "column" for column coordinates
+ * @param tablePos    Optional position of the table node in the document
+ * @returns Array of {row, col} objects or null if invalid
+ */
+declare function getIndexCoordinates({ editor, index, orientation, tablePos, }: {
+    editor: Editor | null;
+    index: number;
+    orientation?: Orientation;
+    tablePos?: number;
+}): {
+    row: number;
+    col: number;
+}[] | null;
+/**
+ * Collect cells (and unique merged cells) from a specific row.
+ * - If `rowIndex` is provided, scans that row.
+ * - If omitted, uses the first (topmost) selected row based on the current selection.
+ */
+declare function getRowCells(editor: Editor | null, rowIndex?: number, tablePos?: number): {
+    cells: CellInfo[];
+    mergedCells: CellInfo[];
+};
+/**
+ * Given a DOM element inside a table, find the corresponding table node and its position.
+ *
+ * This function:
+ * - Locates the nearest ancestor table element
+ * - Uses the editor's document model to resolve the table's position
+ * - Traverses up the node hierarchy to find the corresponding table node
+ *
+ * Returns null if:
+ * - the table cannot be found in the editor's document
+ * - any error occurs during position resolution
+ *
+ * @param tableElement The HTMLTableElement or an element inside it
+ * @param editor       The Tiptap editor instance
+ * @returns An object with { node: tableNode, pos: tablePos } or null if not found
+ */
+declare function getTableFromDOM(tableElement: HTMLElement, editor: Editor): {
+    node: Node;
+    pos: number;
+} | null;
+/**
+ * Checks if a node is a table node
+ */
+declare function isTableNode(node: Node | null | undefined): node is Node;
+type TransactionSelectionOptions = {
+    mode: "transaction";
+};
+type StateSelectionOptions = {
+    mode?: "state";
+};
+type SelectionReturnMode = "state" | "transaction" | "dispatch";
+type DispatchSelectionOptions = {
+    mode: "dispatch";
+    dispatch: (tr: Transaction) => void;
+};
+/**
+ * Selects table cells by their (row, col) coordinates.
+ *
+ * This function can be used in three modes:
+ * - `"state"` (default) → Returns a new `EditorState` with the selection applied, or null if failed.
+ * - `"transaction"` → Returns a `Transaction` with the selection set, or null if failed.
+ * - `"dispatch"` → Immediately dispatches the selection and returns boolean success status.
+ *
+ * @param editor - The editor instance
+ * @param tablePos - Position of the table in the document
+ * @param coords - Array of {row, col} coordinates to select
+ * @param options - Mode and dispatch options
+ */
+declare function selectCellsByCoords(editor: Editor | null, tablePos: number, coords: {
+    row: number;
+    col: number;
+}[], options?: StateSelectionOptions): EditorState;
+declare function selectCellsByCoords(editor: Editor | null, tablePos: number, coords: {
+    row: number;
+    col: number;
+}[], options: TransactionSelectionOptions): Transaction;
+declare function selectCellsByCoords(editor: Editor | null, tablePos: number, coords: {
+    row: number;
+    col: number;
+}[], options: DispatchSelectionOptions): void;
+/**
+ * Determine if the current selection is a full row or column selection.
+ *
+ * If the selection is a `CellSelection` that spans an entire row or column,
+ * returns an object indicating the type and index:
+ * - `{ type: "row", index: number }` for full row selections
+ * - `{ type: "column", index: number }` for full column selections
+ *
+ * If the selection is not a full row/column, or if no table is found, returns null.
+ */
+declare function getTableSelectionType(editor: Editor | null, index?: number, orientation?: Orientation, tablePos?: number): {
+    orientation: Orientation;
+    index: number;
+} | null;
+/**
+ * Get all cells (and unique merged cells) in the selected row or column.
+ *
+ * - If `index` is provided, uses that row/column index.
+ * - If omitted, uses the first selected row/column based on current selection.
+ *
+ * Returns an object with:
+ * - `cells`: all cells in the row/column
+ * - `mergedCells`: only the unique cells that have rowspan/colspan > 1
+ *
+ * If no valid selection or index is found, returns empty arrays.
+ */
+declare function getRowOrColumnCells(editor: Editor | null, index?: number, orientation?: Orientation, tablePos?: number): {
+    cells: CellInfo[];
+    mergedCells: CellInfo[];
+    index?: number;
+    orientation?: Orientation;
+    tablePos?: number;
+};
+/**
+ * After moving a row or column, update the selection to the moved item.
+ *
+ * This ensures that after a move operation, the selection remains on the
+ * moved row or column, providing better user feedback.
+ *
+ * @param editor - The editor instance
+ * @param orientation - "row" or "column" indicating what was moved
+ * @param newIndex - The new index of the moved row/column
+ * @param tablePos - Optional position of the table in the document
+ */
+declare function updateSelectionAfterAction(editor: Editor, orientation: Orientation, newIndex: number, tablePos?: number): void;
+/**
+ * Determines whether a table cell is effectively empty.
+ *
+ * A cell is considered empty when:
+ *  - it has no children, or
+ *  - it contains only whitespace text, or
+ *  - it contains no text and no non-text leaf nodes (images, embeds, etc.)
+ *
+ * Early-outs as soon as any meaningful content is found.
+ *
+ * @param cellNode - The table cell node to check
+ * @returns true if the cell is empty; false otherwise
+ */
+declare function isCellEmpty(cellNode: Node): boolean;
+/**
+ * Returns a command that sets the given attributes to the given values,
+ * and is only available when the currently selected cell doesn't
+ * already have those attributes set to those values.
+ *
+ * @public
+ */
+declare function setCellAttr(attrs: Record<string, unknown>): Command;
+declare function setCellAttr(name: string, value: unknown): Command;
+/**
+ * Cells overlap a rectangle if any of the cells in the rectangle are merged
+ * with cells outside the rectangle.
+ */
+declare function cellsOverlapRectangle({ width, height, map }: TableMap, rect: Rect): boolean;
+/**
+ * Compares two DOMRect objects for equality.
+ *
+ * Treats `undefined` as a valid state, where two `undefined` rects are equal,
+ * and `undefined` is not equal to any defined rect.
+ *
+ * @param a - The first DOMRect or undefined
+ * @param b - The second DOMRect or undefined
+ * @returns true if both rects are equal or both are undefined; false otherwise
+ */
+declare function rectEq(a?: DOMRect | null, b?: DOMRect | null): boolean;
+
+export { type CellInfo, type DispatchSelectionOptions, type DomCellAroundResult, type Orientation, type SelectionReturnMode, type StateSelectionOptions, type TableInfo, type TransactionSelectionOptions, cellsOverlapRectangle, domCellAround, getCellIndicesFromDOM, getColumnCells, getIndexCoordinates, getRowCells, getRowOrColumnCells, getTable, getTableFromDOM, getTableSelectionType, isCellEmpty, isCellMerged, isTableNode, rectEq, selectCellsByCoords, setCellAttr, updateSelectionAfterAction };