@ckeditor/ckeditor5-table 0.0.0-nightly-next-20260127.0 → 0.0.0-nightly-20260128.0

package/package.json

@@ -1,45 +1,68 @@
 {
   "name": "@ckeditor/ckeditor5-table",
-  "version": "0.0.0-nightly-next-20260127.0",
+  "version": "0.0.0-nightly-20260128.0",
   "description": "Table feature for CKEditor 5.",
-  "license": "SEE LICENSE IN LICENSE.md",
-  "author": "CKSource (http://cksource.com/)",
-  "homepage": "https://ckeditor.com/ckeditor-5",
-  "bugs": "https://github.com/ckeditor/ckeditor5/issues",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/ckeditor/ckeditor5.git",
-    "directory": "packages/ckeditor5-table"
-  },
   "keywords": [
     "ckeditor",
     "ckeditor5",
     "ckeditor 5",
     "ckeditor5-feature",
-    "ckeditor5-plugin"
+    "ckeditor5-plugin",
+    "ckeditor5-dll"
   ],
   "type": "module",
-  "main": "./dist/index.js",
-  "exports": {
-    ".": "./dist/index.js",
-    "./dist/*": "./dist/*",
-    "./package.json": "./package.json"
-  },
+  "main": "src/index.js",
   "dependencies": {
-    "@ckeditor/ckeditor5-clipboard": "0.0.0-nightly-next-20260127.0",
-    "@ckeditor/ckeditor5-core": "0.0.0-nightly-next-20260127.0",
-    "@ckeditor/ckeditor5-engine": "0.0.0-nightly-next-20260127.0",
-    "@ckeditor/ckeditor5-icons": "0.0.0-nightly-next-20260127.0",
-    "@ckeditor/ckeditor5-typing": "0.0.0-nightly-next-20260127.0",
-    "@ckeditor/ckeditor5-ui": "0.0.0-nightly-next-20260127.0",
-    "@ckeditor/ckeditor5-utils": "0.0.0-nightly-next-20260127.0",
-    "@ckeditor/ckeditor5-widget": "0.0.0-nightly-next-20260127.0",
+    "ckeditor5": "0.0.0-nightly-20260128.0",
+    "@ckeditor/ckeditor5-clipboard": "0.0.0-nightly-20260128.0",
+    "@ckeditor/ckeditor5-core": "0.0.0-nightly-20260128.0",
+    "@ckeditor/ckeditor5-engine": "0.0.0-nightly-20260128.0",
+    "@ckeditor/ckeditor5-icons": "0.0.0-nightly-20260128.0",
+    "@ckeditor/ckeditor5-ui": "0.0.0-nightly-20260128.0",
+    "@ckeditor/ckeditor5-utils": "0.0.0-nightly-20260128.0",
+    "@ckeditor/ckeditor5-widget": "0.0.0-nightly-20260128.0",
     "es-toolkit": "1.39.5"
   },
+  "author": "CKSource (http://cksource.com/)",
+  "license": "SEE LICENSE IN LICENSE.md",
+  "homepage": "https://ckeditor.com/ckeditor-5",
+  "bugs": "https://github.com/ckeditor/ckeditor5/issues",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ckeditor/ckeditor5.git",
+    "directory": "packages/ckeditor5-table"
+  },
   "files": [
     "dist",
+    "lang",
+    "src/**/*.js",
+    "src/**/*.d.ts",
+    "theme",
+    "build",
     "ckeditor5-metadata.json",
     "CHANGELOG.md"
   ],
-  "types": "./dist/index.d.ts"
+  "types": "src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js",
+      "default": "./src/index.js"
+    },
+    "./dist/*": {
+      "types": "./src/index.d.ts",
+      "import": "./dist/*",
+      "default": "./dist/*"
+    },
+    "./src/*": {
+      "types": "./src/*.d.ts",
+      "import": "./src/*",
+      "default": "./src/*"
+    },
+    "./build/*": "./build/*",
+    "./lang/*": "./lang/*",
+    "./theme/*": "./theme/*",
+    "./ckeditor5-metadata.json": "./ckeditor5-metadata.json",
+    "./package.json": "./package.json"
+  }
 }

package/{dist → src}/augmentation.d.ts

@@ -15,6 +15,21 @@ declare module '@ckeditor/ckeditor5-engine' {
          * This will be enabled by default in the future CKEditor 5 releases.
          */
         upcastTableBorderZeroAttributes?: boolean;
+        /**
+         * When enabled, the the {@link module:table/tableproperties/tablepropertiesediting~TablePropertiesEditing table properties feature}
+         * will support extended alignment options for tables, i.e. `blockLeft` and `blockRight`, using CSS `margin` property.
+         *
+         * This will be enabled by default in the future CKEditor 5 releases.
+         */
+        useExtendedTableBlockAlignment?: boolean;
+        /**
+         * When enabled, the
+         * {@link module:table/tablecellproperties/tablecellpropertiesediting~TableCellPropertiesEditing table cell properties feature}
+         * will introduce a special selector for table cell types (i.e. header and data cells) in the cell properties dropdown.
+         *
+         * This will be enabled by default in the future CKEditor 5 releases.
+         */
+        tableCellTypeSupport?: boolean;
     }
 }
 declare module '@ckeditor/ckeditor5-core' {

package/src/augmentation.js

@@ -0,0 +1,5 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+export {};

package/{dist → src}/commands/insertcolumncommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/insertcolumncommand
  */
-import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import { Command, type Editor } from 'ckeditor5/src/core.js';
 /**
  * The insert column command.
  *

package/src/commands/insertcolumncommand.js

@@ -0,0 +1,71 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+ * @module table/commands/insertcolumncommand
+ */
+import { Command } from 'ckeditor5/src/core.js';
+/**
+ * The insert column command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'insertTableColumnLeft'` and
+ * `'insertTableColumnRight'` editor commands.
+ *
+ * To insert a column to the left of the selected cell, execute the following command:
+ *
+ * ```ts
+ * editor.execute( 'insertTableColumnLeft' );
+ * ```
+ *
+ * To insert a column to the right of the selected cell, execute the following command:
+ *
+ * ```ts
+ * editor.execute( 'insertTableColumnRight' );
+ * ```
+ */
+export class InsertColumnCommand extends Command {
+    /**
+     * The order of insertion relative to the column in which the caret is located.
+     */
+    order;
+    /**
+     * Creates a new `InsertColumnCommand` instance.
+     *
+     * @param editor An editor on which this command will be used.
+     * @param options.order The order of insertion relative to the column in which the caret is located.
+     * Possible values: `"left"` and `"right"`. Default value is "right".
+     */
+    constructor(editor, options = {}) {
+        super(editor);
+        this.order = options.order || 'right';
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const selection = this.editor.model.document.selection;
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const isAnyCellSelected = !!tableUtils.getSelectionAffectedTableCells(selection).length;
+        this.isEnabled = isAnyCellSelected;
+    }
+    /**
+     * Executes the command.
+     *
+     * Depending on the command's {@link #order} value, it inserts a column to the `'left'` or `'right'` of the column
+     * in which the selection is set.
+     *
+     * @fires execute
+     */
+    execute() {
+        const editor = this.editor;
+        const selection = editor.model.document.selection;
+        const tableUtils = editor.plugins.get('TableUtils');
+        const insertBefore = this.order === 'left';
+        const affectedTableCells = tableUtils.getSelectionAffectedTableCells(selection);
+        const columnIndexes = tableUtils.getColumnIndexes(affectedTableCells);
+        const column = insertBefore ? columnIndexes.first : columnIndexes.last;
+        const table = affectedTableCells[0].findAncestor('table');
+        tableUtils.insertColumns(table, { columns: 1, at: insertBefore ? column : column + 1 });
+    }
+}

package/{dist → src}/commands/insertrowcommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/insertrowcommand
  */
-import { Command, type Editor } from '@ckeditor/ckeditor5-core';
+import { Command, type Editor } from 'ckeditor5/src/core.js';
 /**
  * The insert row command.
  *

package/src/commands/insertrowcommand.js

@@ -0,0 +1,70 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+ * @module table/commands/insertrowcommand
+ */
+import { Command } from 'ckeditor5/src/core.js';
+/**
+ * The insert row command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'insertTableRowBelow'` and
+ * `'insertTableRowAbove'` editor commands.
+ *
+ * To insert a row below the selected cell, execute the following command:
+ *
+ * ```ts
+ * editor.execute( 'insertTableRowBelow' );
+ * ```
+ *
+ * To insert a row above the selected cell, execute the following command:
+ *
+ * ```ts
+ * editor.execute( 'insertTableRowAbove' );
+ * ```
+ */
+export class InsertRowCommand extends Command {
+    /**
+     * The order of insertion relative to the row in which the caret is located.
+     */
+    order;
+    /**
+     * Creates a new `InsertRowCommand` instance.
+     *
+     * @param editor The editor on which this command will be used.
+     * @param options.order The order of insertion relative to the row in which the caret is located.
+     * Possible values: `"above"` and `"below"`. Default value is "below"
+     */
+    constructor(editor, options = {}) {
+        super(editor);
+        this.order = options.order || 'below';
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const selection = this.editor.model.document.selection;
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const isAnyCellSelected = !!tableUtils.getSelectionAffectedTableCells(selection).length;
+        this.isEnabled = isAnyCellSelected;
+    }
+    /**
+     * Executes the command.
+     *
+     * Depending on the command's {@link #order} value, it inserts a row `'below'` or `'above'` the row in which selection is set.
+     *
+     * @fires execute
+     */
+    execute() {
+        const editor = this.editor;
+        const selection = editor.model.document.selection;
+        const tableUtils = editor.plugins.get('TableUtils');
+        const insertAbove = this.order === 'above';
+        const affectedTableCells = tableUtils.getSelectionAffectedTableCells(selection);
+        const rowIndexes = tableUtils.getRowIndexes(affectedTableCells);
+        const row = insertAbove ? rowIndexes.first : rowIndexes.last;
+        const table = affectedTableCells[0].findAncestor('table');
+        tableUtils.insertRows(table, { at: insertAbove ? row : row + 1, copyStructureFromAbove: !insertAbove });
+    }
+}

package/{dist → src}/commands/inserttablecommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/inserttablecommand
  */
-import { Command } from '@ckeditor/ckeditor5-core';
+import { Command } from 'ckeditor5/src/core.js';
 /**
  * The insert table command.
  *

package/src/commands/inserttablecommand.js

@@ -0,0 +1,69 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+ * @module table/commands/inserttablecommand
+ */
+import { Command } from 'ckeditor5/src/core.js';
+/**
+ * The insert table command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'insertTable'` editor command.
+ *
+ * To insert a table at the current selection, execute the command and specify the dimensions:
+ *
+ * ```ts
+ * editor.execute( 'insertTable', { rows: 20, columns: 5 } );
+ * ```
+ */
+export class InsertTableCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const model = this.editor.model;
+        const selection = model.document.selection;
+        const schema = model.schema;
+        this.isEnabled = isAllowedInParent(selection, schema);
+    }
+    /**
+     * Executes the command.
+     *
+     * Inserts a table with the given number of rows and columns into the editor.
+     *
+     * @param options.rows The number of rows to create in the inserted table. Default value is 2.
+     * @param options.columns The number of columns to create in the inserted table. Default value is 2.
+     * @param options.headingRows The number of heading rows. If not provided it will default to
+     * {@link module:table/tableconfig~TableConfig#defaultHeadings `config.table.defaultHeadings.rows`} table config.
+     * @param options.headingColumns The number of heading columns. If not provided it will default to
+     * {@link module:table/tableconfig~TableConfig#defaultHeadings `config.table.defaultHeadings.columns`} table config.
+     * @fires execute
+     */
+    execute(options = {}) {
+        const editor = this.editor;
+        const model = editor.model;
+        const tableUtils = editor.plugins.get('TableUtils');
+        const defaultRows = editor.config.get('table.defaultHeadings.rows');
+        const defaultColumns = editor.config.get('table.defaultHeadings.columns');
+        if (options.headingRows === undefined && defaultRows) {
+            options.headingRows = defaultRows;
+        }
+        if (options.headingColumns === undefined && defaultColumns) {
+            options.headingColumns = defaultColumns;
+        }
+        model.change(writer => {
+            const table = tableUtils.createTable(writer, options);
+            model.insertObject(table, null, null, { findOptimalPosition: 'auto' });
+            writer.setSelection(writer.createPositionAt(table.getNodeByPath([0, 0, 0]), 0));
+        });
+    }
+}
+/**
+ * Checks if the table is allowed in the parent.
+ */
+function isAllowedInParent(selection, schema) {
+    const positionParent = selection.getFirstPosition().parent;
+    const validParent = positionParent === positionParent.root ? positionParent : positionParent.parent;
+    return schema.checkChild(validParent, 'table');
+}

package/{dist → src}/commands/inserttablelayoutcommand.d.ts

@@ -5,7 +5,7 @@
 /**
  * @module table/commands/inserttablelayoutcommand
  */
-import { Command } from '@ckeditor/ckeditor5-core';
+import { Command } from 'ckeditor5/src/core.js';
 /**
  * The insert table layout command.
  *

package/src/commands/inserttablelayoutcommand.js

@@ -0,0 +1,65 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+/**
+ * @module table/commands/inserttablelayoutcommand
+ */
+import { Command } from 'ckeditor5/src/core.js';
+/**
+ * The insert table layout command.
+ *
+ * The command is registered by {@link module:table/tablelayout/tablelayoutediting~TableLayoutEditing}
+ * as the `'insertTableLayout'` editor command.
+ *
+ * To insert a layout table at the current selection, execute the command and specify the dimensions:
+ *
+ * ```ts
+ * editor.execute( 'insertTableLayout', { rows: 20, columns: 5 } );
+ * ```
+ */
+export class InsertTableLayoutCommand extends Command {
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const model = this.editor.model;
+        const selection = model.document.selection;
+        const schema = model.schema;
+        this.isEnabled = isAllowedInParent(selection, schema);
+    }
+    /**
+     * Executes the command.
+     *
+     * Inserts a layout table with the given number of rows and columns into the editor.
+     *
+     * @param options.rows The number of rows to create in the inserted table. Default value is 2.
+     * @param options.columns The number of columns to create in the inserted table. Default value is 2.
+     * @fires execute
+     */
+    execute(options = {}) {
+        const editor = this.editor;
+        const model = editor.model;
+        const tableUtils = editor.plugins.get('TableUtils');
+        model.change(writer => {
+            const normalizedOptions = { rows: options.rows || 2, columns: options.columns || 2 };
+            const table = tableUtils.createTable(writer, normalizedOptions);
+            writer.setAttribute('tableType', 'layout', table);
+            model.insertObject(table, null, null, { findOptimalPosition: 'auto' });
+            const singleColumnWidth = `${100 / normalizedOptions.columns}%`;
+            const columnWidths = Array(normalizedOptions.columns).fill(singleColumnWidth);
+            const tableWidthsCommand = editor.commands.get('resizeColumnWidths');
+            // Make the table full-width with equal columns width.
+            tableWidthsCommand.execute({ tableWidth: '100%', columnWidths, table });
+            writer.setSelection(writer.createPositionAt(table.getNodeByPath([0, 0, 0]), 0));
+        });
+    }
+}
+/**
+ * Checks if the table is allowed in the parent.
+ */
+function isAllowedInParent(selection, schema) {
+    const positionParent = selection.getFirstPosition().parent;
+    const validParent = positionParent === positionParent.root ? positionParent : positionParent.parent;
+    return schema.checkChild(validParent, 'table');
+}

package/{dist → src}/commands/mergecellcommand.d.ts

@@ -5,9 +5,9 @@
 /**
  * @module table/commands/mergecellcommand
  */
-import type { ModelNode } from '@ckeditor/ckeditor5-engine';
-import { Command, type Editor } from '@ckeditor/ckeditor5-core';
-import type { ArrowKeyCodeDirection } from '@ckeditor/ckeditor5-utils';
+import type { ModelNode } from 'ckeditor5/src/engine.js';
+import { Command, type Editor } from 'ckeditor5/src/core.js';
+import type { ArrowKeyCodeDirection } from 'ckeditor5/src/utils.js';
 /**
  * The merge cell command.
  *

package/src/commands/mergecellcommand.js

@@ -0,0 +1,206 @@
+/**
+ * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
+ * For licensing, see LICENSE.md or https://ckeditor.com/legal/ckeditor-licensing-options
+ */
+import { Command } from 'ckeditor5/src/core.js';
+import { TableWalker } from '../tablewalker.js';
+import { isHeadingColumnCell } from '../utils/common.js';
+import { removeEmptyRowsColumns } from '../utils/structure.js';
+/**
+ * The merge cell command.
+ *
+ * The command is registered by {@link module:table/tableediting~TableEditing} as the `'mergeTableCellRight'`, `'mergeTableCellLeft'`,
+ * `'mergeTableCellUp'` and `'mergeTableCellDown'` editor commands.
+ *
+ * To merge a table cell at the current selection with another cell, execute the command corresponding with the preferred direction.
+ *
+ * For example, to merge with a cell to the right:
+ *
+ * ```ts
+ * editor.execute( 'mergeTableCellRight' );
+ * ```
+ *
+ * **Note**: If a table cell has a different [`rowspan`](https://www.w3.org/TR/html50/tabular-data.html#attr-tdth-rowspan)
+ * (for `'mergeTableCellRight'` and `'mergeTableCellLeft'`) or [`colspan`](https://www.w3.org/TR/html50/tabular-data.html#attr-tdth-colspan)
+ * (for `'mergeTableCellUp'` and `'mergeTableCellDown'`), the command will be disabled.
+ */
+export class MergeCellCommand extends Command {
+    /**
+     * The direction that indicates which cell will be merged with the currently selected one.
+     */
+    direction;
+    /**
+     * Whether the merge is horizontal (left/right) or vertical (up/down).
+     */
+    isHorizontal;
+    /**
+     * Creates a new `MergeCellCommand` instance.
+     *
+     * @param editor The editor on which this command will be used.
+     * @param options.direction Indicates which cell to merge with the currently selected one.
+     * Possible values are: `'left'`, `'right'`, `'up'` and `'down'`.
+     */
+    constructor(editor, options) {
+        super(editor);
+        this.direction = options.direction;
+        this.isHorizontal = this.direction == 'right' || this.direction == 'left';
+    }
+    /**
+     * @inheritDoc
+     */
+    refresh() {
+        const cellToMerge = this._getMergeableCell();
+        this.value = cellToMerge;
+        this.isEnabled = !!cellToMerge;
+    }
+    /**
+     * Executes the command.
+     *
+     * Depending on the command's {@link #direction} value, it will merge the cell that is to the `'left'`, `'right'`, `'up'` or `'down'`.
+     *
+     * @fires execute
+     */
+    execute() {
+        const model = this.editor.model;
+        const doc = model.document;
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const tableCell = tableUtils.getTableCellsContainingSelection(doc.selection)[0];
+        const cellToMerge = this.value;
+        const direction = this.direction;
+        model.change(writer => {
+            const isMergeNext = direction == 'right' || direction == 'down';
+            // The merge mechanism is always the same so sort cells to be merged.
+            const cellToExpand = (isMergeNext ? tableCell : cellToMerge);
+            const cellToRemove = (isMergeNext ? cellToMerge : tableCell);
+            // Cache the parent of cell to remove for later check.
+            const removedTableCellRow = cellToRemove.parent;
+            mergeTableCells(cellToRemove, cellToExpand, writer);
+            const spanAttribute = this.isHorizontal ? 'colspan' : 'rowspan';
+            const cellSpan = parseInt(tableCell.getAttribute(spanAttribute) || '1');
+            const cellToMergeSpan = parseInt(cellToMerge.getAttribute(spanAttribute) || '1');
+            // Update table cell span attribute and merge set selection on merged contents.
+            writer.setAttribute(spanAttribute, cellSpan + cellToMergeSpan, cellToExpand);
+            writer.setSelection(writer.createRangeIn(cellToExpand));
+            const tableUtils = this.editor.plugins.get('TableUtils');
+            const table = removedTableCellRow.findAncestor('table');
+            // Remove empty rows and columns after merging.
+            removeEmptyRowsColumns(table, tableUtils);
+        });
+    }
+    /**
+     * Returns a cell that can be merged with the current cell depending on the command's direction.
+     */
+    _getMergeableCell() {
+        const model = this.editor.model;
+        const doc = model.document;
+        const tableUtils = this.editor.plugins.get('TableUtils');
+        const tableCell = tableUtils.getTableCellsContainingSelection(doc.selection)[0];
+        if (!tableCell) {
+            return;
+        }
+        // First get the cell on proper direction.
+        const cellToMerge = this.isHorizontal ?
+            getHorizontalCell(tableCell, this.direction, tableUtils) :
+            getVerticalCell(tableCell, this.direction, tableUtils);
+        if (!cellToMerge) {
+            return;
+        }
+        // If found check if the span perpendicular to merge direction is equal on both cells.
+        const spanAttribute = this.isHorizontal ? 'rowspan' : 'colspan';
+        const span = parseInt(tableCell.getAttribute(spanAttribute) || '1');
+        const cellToMergeSpan = parseInt(cellToMerge.getAttribute(spanAttribute) || '1');
+        if (cellToMergeSpan === span) {
+            return cellToMerge;
+        }
+    }
+}
+/**
+ * Returns the cell that can be merged horizontally.
+ */
+function getHorizontalCell(tableCell, direction, tableUtils) {
+    const tableRow = tableCell.parent;
+    const table = tableRow.parent;
+    const horizontalCell = direction == 'right' ? tableCell.nextSibling : tableCell.previousSibling;
+    const hasHeadingColumns = (table.getAttribute('headingColumns') || 0) > 0;
+    if (!horizontalCell) {
+        return;
+    }
+    // Sort cells:
+    const cellOnLeft = (direction == 'right' ? tableCell : horizontalCell);
+    const cellOnRight = (direction == 'right' ? horizontalCell : tableCell);
+    // Get their column indexes:
+    const { column: leftCellColumn } = tableUtils.getCellLocation(cellOnLeft);
+    const { column: rightCellColumn } = tableUtils.getCellLocation(cellOnRight);
+    const leftCellSpan = parseInt(cellOnLeft.getAttribute('colspan') || '1');
+    const isCellOnLeftInHeadingColumn = isHeadingColumnCell(tableUtils, cellOnLeft);
+    const isCellOnRightInHeadingColumn = isHeadingColumnCell(tableUtils, cellOnRight);
+    // We cannot merge heading columns cells with regular cells.
+    if (hasHeadingColumns && isCellOnLeftInHeadingColumn != isCellOnRightInHeadingColumn) {
+        return;
+    }
+    // The cell on the right must have index that is distant to the cell on the left by the left cell's width (colspan).
+    const cellsAreTouching = leftCellColumn + leftCellSpan === rightCellColumn;
+    // If the right cell's column index is different it means that there are rowspanned cells between them.
+    return cellsAreTouching ? horizontalCell : undefined;
+}
+/**
+ * Returns the cell that can be merged vertically.
+ */
+function getVerticalCell(tableCell, direction, tableUtils) {
+    const tableRow = tableCell.parent;
+    const table = tableRow.parent;
+    const rowIndex = table.getChildIndex(tableRow);
+    // Don't search for mergeable cell if direction points out of the table.
+    if ((direction == 'down' && rowIndex === tableUtils.getRows(table) - 1) || (direction == 'up' && rowIndex === 0)) {
+        return null;
+    }
+    const rowspan = parseInt(tableCell.getAttribute('rowspan') || '1');
+    const headingRows = table.getAttribute('headingRows') || 0;
+    const isMergeWithBodyCell = direction == 'down' && (rowIndex + rowspan) === headingRows;
+    const isMergeWithHeadCell = direction == 'up' && rowIndex === headingRows;
+    // Don't search for mergeable cell if direction points out of the current table section.
+    if (headingRows && (isMergeWithBodyCell || isMergeWithHeadCell)) {
+        return null;
+    }
+    const currentCellRowSpan = parseInt(tableCell.getAttribute('rowspan') || '1');
+    const rowOfCellToMerge = direction == 'down' ? rowIndex + currentCellRowSpan : rowIndex;
+    const tableMap = [...new TableWalker(table, { endRow: rowOfCellToMerge })];
+    const currentCellData = tableMap.find(value => value.cell === tableCell);
+    const mergeColumn = currentCellData.column;
+    const cellToMergeData = tableMap.find(({ row, cellHeight, column }) => {
+        if (column !== mergeColumn) {
+            return false;
+        }
+        if (direction == 'down') {
+            // If merging a cell below the mergeRow is already calculated.
+            return row === rowOfCellToMerge;
+        }
+        else {
+            // If merging a cell above calculate if it spans to mergeRow.
+            return rowOfCellToMerge === row + cellHeight;
+        }
+    });
+    return cellToMergeData && cellToMergeData.cell ? cellToMergeData.cell : null;
+}
+/**
+ * Merges two table cells. It will ensure that after merging cells with an empty paragraph, the resulting table cell will only have one
+ * paragraph. If one of the merged table cells is empty, the merged table cell will have the contents of the non-empty table cell.
+ * If both are empty, the merged table cell will have only one empty paragraph.
+ */
+function mergeTableCells(cellToRemove, cellToExpand, writer) {
+    if (!isEmpty(cellToRemove)) {
+        if (isEmpty(cellToExpand)) {
+            writer.remove(writer.createRangeIn(cellToExpand));
+        }
+        writer.move(writer.createRangeIn(cellToRemove), writer.createPositionAt(cellToExpand, 'end'));
+    }
+    // Remove merged table cell.
+    writer.remove(cellToRemove);
+}
+/**
+ * Checks if the passed table cell contains an empty paragraph.
+ */
+function isEmpty(tableCell) {
+    const firstTableChild = tableCell.getChild(0);
+    return tableCell.childCount == 1 && firstTableChild.is('element', 'paragraph') && firstTableChild.isEmpty;
+}