@ckeditor/ckeditor5-table 0.0.0-nightly-20260118.0 → 0.0.0-nightly-next-20260118.0

package/src/commands/setheadercolumncommand.js

@@ -1,76 +0,0 @@
-/**
- * @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/setheadercolumncommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-import { isHeadingColumnCell } from '../utils/common.js';
-import { getHorizontallyOverlappingCells, splitVertically } from '../utils/structure.js';
-/**
- * The header column command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'setTableColumnHeader'` editor command.
- *
- * You can make the column containing the selected cell a [header](https://www.w3.org/TR/html50/tabular-data.html#the-th-element)
- * by executing:
- *
- * ```ts
- * editor.execute( 'setTableColumnHeader' );
- * ```
- *
- * **Note:** All preceding columns will also become headers. If the current column is already a header, executing this command
- * will make it a regular column back again (including the following columns).
- */
-export class SetHeaderColumnCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const model = this.editor.model;
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
-        if (selectedCells.length === 0) {
-            this.isEnabled = false;
-            this.value = false;
-            return;
-        }
-        const table = selectedCells[0].findAncestor('table');
-        this.isEnabled = model.schema.checkAttribute(table, 'headingColumns');
-        this.value = selectedCells.every(cell => isHeadingColumnCell(tableUtils, cell));
-    }
-    /**
-     * Executes the command.
-     *
-     * When the selection is in a non-header column, the command will set the `headingColumns` table attribute to cover that column.
-     *
-     * When the selection is already in a header column, it will set `headingColumns` so the heading section will end before that column.
-     *
-     * @fires execute
-     * @param options.forceValue If set, the command will set (`true`) or unset (`false`) the header columns according to
-     * the `forceValue` parameter instead of the current model state.
-     */
-    execute(options = {}) {
-        if (options.forceValue === this.value) {
-            return;
-        }
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const model = this.editor.model;
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
-        const table = selectedCells[0].findAncestor('table');
-        const { first, last } = tableUtils.getColumnIndexes(selectedCells);
-        const headingColumnsToSet = this.value ? first : last + 1;
-        model.change(writer => {
-            if (headingColumnsToSet) {
-                // Changing heading columns requires to check if any of a heading cell is overlapping horizontally the table head.
-                // Any table cell that has a colspan attribute > 1 will not exceed the table head so we need to fix it in columns before.
-                const overlappingCells = getHorizontallyOverlappingCells(table, headingColumnsToSet);
-                for (const { cell, column } of overlappingCells) {
-                    splitVertically(cell, column, headingColumnsToSet, writer);
-                }
-            }
-            tableUtils.setHeadingColumnsCount(writer, table, headingColumnsToSet);
-        });
-    }
-}

package/src/commands/setheaderrowcommand.js

@@ -1,83 +0,0 @@
-/**
- * @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/setheaderrowcommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-import { getVerticallyOverlappingCells, splitHorizontally } from '../utils/structure.js';
-/**
- * The header row command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'setTableColumnHeader'` editor command.
- *
- * You can make the row containing the selected cell a [header](https://www.w3.org/TR/html50/tabular-data.html#the-th-element) by executing:
- *
- * ```ts
- * editor.execute( 'setTableRowHeader' );
- * ```
- *
- * **Note:** All preceding rows will also become headers. If the current row is already a header, executing this command
- * will make it a regular row back again (including the following rows).
- */
-export class SetHeaderRowCommand extends Command {
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const model = this.editor.model;
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
-        if (selectedCells.length === 0) {
-            this.isEnabled = false;
-            this.value = false;
-            return;
-        }
-        const table = selectedCells[0].findAncestor('table');
-        this.isEnabled = model.schema.checkAttribute(table, 'headingRows');
-        this.value = selectedCells.every(cell => this._isInHeading(cell, cell.parent.parent));
-    }
-    /**
-     * Executes the command.
-     *
-     * When the selection is in a non-header row, the command will set the `headingRows` table attribute to cover that row.
-     *
-     * When the selection is already in a header row, it will set `headingRows` so the heading section will end before that row.
-     *
-     * @fires execute
-     * @param options.forceValue If set, the command will set (`true`) or unset (`false`) the header rows according to
-     * the `forceValue` parameter instead of the current model state.
-     */
-    execute(options = {}) {
-        if (options.forceValue === this.value) {
-            return;
-        }
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const model = this.editor.model;
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
-        const table = selectedCells[0].findAncestor('table');
-        const { first, last } = tableUtils.getRowIndexes(selectedCells);
-        const headingRowsToSet = this.value ? first : last + 1;
-        const currentHeadingRows = table.getAttribute('headingRows') || 0;
-        model.change(writer => {
-            if (headingRowsToSet) {
-                // Changing heading rows requires to check if any of a heading cell is overlapping vertically the table head.
-                // Any table cell that has a rowspan attribute > 1 will not exceed the table head so we need to fix it in rows below.
-                const startRow = headingRowsToSet > currentHeadingRows ? currentHeadingRows : 0;
-                const overlappingCells = getVerticallyOverlappingCells(table, headingRowsToSet, startRow);
-                for (const { cell } of overlappingCells) {
-                    splitHorizontally(cell, headingRowsToSet, writer);
-                }
-            }
-            tableUtils.setHeadingRowsCount(writer, table, headingRowsToSet);
-        });
-    }
-    /**
-     * Checks if a table cell is in the heading section.
-     */
-    _isInHeading(tableCell, table) {
-        const headingRows = parseInt(table.getAttribute('headingRows') || '0');
-        return !!headingRows && tableCell.parent.index < headingRows;
-    }
-}

package/src/commands/splitcellcommand.js

@@ -1,58 +0,0 @@
-/**
- * @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/splitcellcommand
- */
-import { Command } from 'ckeditor5/src/core.js';
-/**
- * The split cell command.
- *
- * The command is registered by {@link module:table/tableediting~TableEditing} as the `'splitTableCellVertically'`
- * and `'splitTableCellHorizontally'`  editor commands.
- *
- * You can split any cell vertically or horizontally by executing this command. For example, to split the selected table cell vertically:
- *
- * ```ts
- * editor.execute( 'splitTableCellVertically' );
- * ```
- */
-export class SplitCellCommand extends Command {
-    /**
-     * The direction that indicates which cell will be split.
-     */
-    direction;
-    /**
-     * Creates a new `SplitCellCommand` instance.
-     *
-     * @param editor The editor on which this command will be used.
-     * @param options.direction Indicates whether the command should split cells `'horizontally'` or `'vertically'`.
-     */
-    constructor(editor, options = {}) {
-        super(editor);
-        this.direction = options.direction || 'horizontally';
-    }
-    /**
-     * @inheritDoc
-     */
-    refresh() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const selectedCells = tableUtils.getSelectionAffectedTableCells(this.editor.model.document.selection);
-        this.isEnabled = selectedCells.length === 1;
-    }
-    /**
-     * @inheritDoc
-     */
-    execute() {
-        const tableUtils = this.editor.plugins.get('TableUtils');
-        const tableCell = tableUtils.getSelectionAffectedTableCells(this.editor.model.document.selection)[0];
-        const isHorizontal = this.direction === 'horizontally';
-        if (isHorizontal) {
-            tableUtils.splitCellHorizontally(tableCell, 2);
-        }
-        else {
-            tableUtils.splitCellVertically(tableCell, 2);
-        }
-    }
-}

package/src/converters/downcast.js

@@ -1,298 +0,0 @@
-/**
- * @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 { toWidget, toWidgetEditable } from 'ckeditor5/src/widget.js';
-import { downcastTableAlignmentConfig } from './tableproperties.js';
-import { getNormalizedDefaultTableProperties } from '../utils/table-properties.js';
-import { TableWalker } from '../tablewalker.js';
-/**
- * Model table element to view table element conversion helper.
- *
- * @internal
- */
-export function downcastTable(tableUtils, options) {
-    return (table, { writer }) => {
-        const headingRows = table.getAttribute('headingRows') || 0;
-        const tableElement = writer.createContainerElement('table', null, []);
-        const figureElement = writer.createContainerElement('figure', { class: 'table' }, tableElement);
-        // Table head slot.
-        if (headingRows > 0) {
-            writer.insert(writer.createPositionAt(tableElement, 'end'), writer.createContainerElement('thead', null, writer.createSlot(element => element.is('element', 'tableRow') && element.index < headingRows)));
-        }
-        // Table body slot.
-        if (headingRows < tableUtils.getRows(table)) {
-            writer.insert(writer.createPositionAt(tableElement, 'end'), writer.createContainerElement('tbody', null, writer.createSlot(element => element.is('element', 'tableRow') && element.index >= headingRows)));
-        }
-        // Dynamic slots.
-        for (const { positionOffset, filter } of options.additionalSlots) {
-            writer.insert(writer.createPositionAt(tableElement, positionOffset), writer.createSlot(filter));
-        }
-        // Create a slot with items that don't fit into the table.
-        writer.insert(writer.createPositionAt(tableElement, 'after'), writer.createSlot(element => {
-            if (element.is('element', 'tableRow')) {
-                return false;
-            }
-            return !options.additionalSlots.some(({ filter }) => filter(element));
-        }));
-        return options.asWidget ? toTableWidget(figureElement, writer) : figureElement;
-    };
-}
-/**
- * Model table row element to view `<tr>` element conversion helper.
- *
- * @internal
- * @returns Element creator.
- */
-export function downcastRow() {
-    return (tableRow, { writer }) => {
-        return tableRow.isEmpty ?
-            writer.createEmptyElement('tr') :
-            writer.createContainerElement('tr');
-    };
-}
-/**
- * Model table cell element to view `<td>` or `<th>` element conversion helper.
- *
- * This conversion helper will create proper `<th>` elements for table cells that are in the heading section (heading row or column)
- * and `<td>` otherwise.
- *
- * @internal
- * @param options.asWidget If set to `true`, the downcast conversion will produce a widget.
- * @param options.cellTypeEnabled If returns `true`, the downcast conversion will use the `tableCellType` attribute to determine cell type.
- * @returns Element creator.
- */
-export function downcastCell(options) {
-    return (tableCell, { writer }) => {
-        // If the table cell type feature is enabled, then we can simply check the cell type attribute.
-        if (options.cellTypeEnabled?.()) {
-            const cellElementName = (tableCell.getAttribute('tableCellType') === 'header' ?
-                'th' :
-                'td');
-            return createCellElement(writer, cellElementName);
-        }
-        // If the table cell type feature is not enabled, we should iterate through the table structure
-        // to determine whether the cell is in the heading section.
-        const tableRow = tableCell.parent;
-        const table = tableRow.parent;
-        const rowIndex = table.getChildIndex(tableRow);
-        const tableWalker = new TableWalker(table, { row: rowIndex });
-        const headingRows = table.getAttribute('headingRows') || 0;
-        const headingColumns = table.getAttribute('headingColumns') || 0;
-        let result = null;
-        // We need to iterate over a table in order to get proper row & column values from a walker.
-        for (const tableSlot of tableWalker) {
-            if (tableSlot.cell == tableCell) {
-                const isHeading = tableSlot.row < headingRows || tableSlot.column < headingColumns;
-                result = createCellElement(writer, isHeading ? 'th' : 'td');
-                break;
-            }
-        }
-        return result;
-    };
-    function createCellElement(writer, name) {
-        return (options.asWidget ?
-            toWidgetEditable(writer.createEditableElement(name), writer, { withAriaRole: false }) :
-            writer.createContainerElement(name));
-    }
-}
-/**
- * Overrides paragraph inside table cell conversion.
- *
- * This converter:
- * * should be used to override default paragraph conversion.
- * * It will only convert `<paragraph>` placed directly inside `<tableCell>`.
- * * For a single paragraph without attributes it returns `<span>` to simulate data table.
- * * For all other cases it returns `<p>` element.
- *
- * @internal
- * @param options.asWidget If set to `true`, the downcast conversion will produce a widget.
- * @returns Element creator.
- */
-export function convertParagraphInTableCell(options = {}) {
-    return (modelElement, { writer }) => {
-        if (!modelElement.parent.is('element', 'tableCell')) {
-            return null;
-        }
-        if (!isSingleParagraphWithoutAttributes(modelElement)) {
-            return null;
-        }
-        if (options.asWidget) {
-            return writer.createContainerElement('span', { class: 'ck-table-bogus-paragraph' });
-        }
-        else {
-            // Using `<p>` in case there are some markers on it and transparentRendering will render it anyway.
-            const viewElement = writer.createContainerElement('p');
-            writer.setCustomProperty('dataPipeline:transparentRendering', true, viewElement);
-            return viewElement;
-        }
-    };
-}
-/**
- * Checks if given model `<paragraph>` is an only child of a parent (`<tableCell>`) and if it has any attribute set.
- *
- * The paragraph should be converted in the editing view to:
- *
- * * If returned `true` - to a `<span class="ck-table-bogus-paragraph">`
- * * If returned `false` - to a `<p>`
- *
- * @internal
- */
-export function isSingleParagraphWithoutAttributes(modelElement) {
-    const tableCell = modelElement.parent;
-    const isSingleParagraph = tableCell.childCount == 1;
-    return isSingleParagraph && !hasAnyAttribute(modelElement);
-}
-/**
- * Converts a given {@link module:engine/view/element~ViewElement} to a table widget:
- * * Adds a {@link module:engine/view/element~ViewElement#_setCustomProperty custom property}
- * allowing to recognize the table widget element.
- * * Calls the {@link module:widget/utils~toWidget} function with the proper element's label creator.
- *
- * @param writer An instance of the view writer.
- * @param label The element's label. It will be concatenated with the table `alt` attribute if one is present.
- */
-function toTableWidget(viewElement, writer) {
-    writer.setCustomProperty('table', true, viewElement);
-    return toWidget(viewElement, writer, { hasSelectionHandle: true });
-}
-/**
- * Checks if an element has any attributes set.
- */
-function hasAnyAttribute(element) {
-    for (const attributeKey of element.getAttributeKeys()) {
-        // Ignore selection attributes stored on block elements.
-        if (attributeKey.startsWith('selection:') || attributeKey == 'htmlEmptyBlock') {
-            continue;
-        }
-        return true;
-    }
-    return false;
-}
-/**
- * Downcasts a plain table (also used in the clipboard pipeline).
- */
-export function convertPlainTable(editor) {
-    return (table, conversionApi) => {
-        const hasPlainTableOutput = editor.plugins.has('PlainTableOutput');
-        const isClipboardPipeline = conversionApi.options.isClipboardPipeline;
-        const useExtendedAlignment = editor.config.get('experimentalFlags.useExtendedTableBlockAlignment');
-        if (!hasPlainTableOutput && !(useExtendedAlignment && isClipboardPipeline)) {
-            return null;
-        }
-        return downcastPlainTable(table, conversionApi, editor);
-    };
-}
-/**
- * Downcasts a plain table caption (also used in the clipboard pipeline).
- */
-export function convertPlainTableCaption(editor) {
-    return (modelElement, { writer, options }) => {
-        const hasPlainTableOutput = editor.plugins.has('PlainTableOutput');
-        const isClipboardPipeline = options.isClipboardPipeline;
-        const useExtendedAlignment = editor.config.get('experimentalFlags.useExtendedTableBlockAlignment');
-        if (!hasPlainTableOutput && !(useExtendedAlignment && isClipboardPipeline)) {
-            return null;
-        }
-        if (modelElement.parent.name === 'table') {
-            return writer.createContainerElement('caption');
-        }
-        return null;
-    };
-}
-/**
- * Downcasts a plain table.
- *
- * @param table Table model element.
- * @param conversionApi The conversion API object.
- * @param editor The editor instance.
- * @returns Created element.
- */
-export function downcastPlainTable(table, conversionApi, editor) {
-    const writer = conversionApi.writer;
-    const headingRows = table.getAttribute('headingRows') || 0;
-    // Table head rows slot.
-    const headRowsSlot = writer.createSlot((element) => element.is('element', 'tableRow') && element.index < headingRows);
-    // Table body rows slot.
-    const bodyRowsSlot = writer.createSlot((element) => element.is('element', 'tableRow') && element.index >= headingRows);
-    // Table children slot.
-    const childrenSlot = writer.createSlot((element) => !element.is('element', 'tableRow'));
-    // Table <thead> element with all the heading rows.
-    const theadElement = writer.createContainerElement('thead', null, headRowsSlot);
-    // Table <tbody> element with all the body rows.
-    const tbodyElement = writer.createContainerElement('tbody', null, bodyRowsSlot);
-    // Table contents element containing <thead> and <tbody> when necessary.
-    const tableContentElements = [];
-    if (headingRows) {
-        tableContentElements.push(theadElement);
-    }
-    if (headingRows < table.childCount) {
-        tableContentElements.push(tbodyElement);
-    }
-    const tableAttributes = { class: 'table' };
-    if (editor.plugins.has('TablePropertiesEditing') && conversionApi.options.isClipboardPipeline) {
-        const defaultTableProperties = getNormalizedDefaultTableProperties(editor.config.get('table.tableProperties.defaultProperties'), {
-            includeAlignmentProperty: true
-        });
-        const tableAlignment = table.getAttribute('tableAlignment');
-        let localDefaultValue = defaultTableProperties.alignment;
-        if (table.getAttribute('tableType') === 'layout') {
-            localDefaultValue = '';
-        }
-        const tableAlignmentValue = tableAlignment || localDefaultValue;
-        if (tableAlignmentValue) {
-            tableAttributes.class += ' ' + downcastTableAlignmentConfig[tableAlignmentValue].className;
-            tableAttributes.style = downcastTableAlignmentConfig[tableAlignmentValue].style;
-            if (downcastTableAlignmentConfig[tableAlignmentValue].align !== undefined) {
-                tableAttributes.align = downcastTableAlignmentConfig[tableAlignmentValue].align;
-            }
-        }
-    }
-    // Create table structure.
-    //
-    // <table>
-    //    {children-slot-like-caption}
-    //    <thead>
-    //        {table-head-rows-slot}
-    //    </thead>
-    //    <tbody>
-    //        {table-body-rows-slot}
-    //    </tbody>
-    // </table>
-    return writer.createContainerElement('table', tableAttributes, [childrenSlot, ...tableContentElements]);
-}
-/**
- * Registers border and background attributes converters for plain tables or when the clipboard pipeline is used.
- */
-export function downcastTableBorderAndBackgroundAttributes(editor) {
-    const modelAttributes = {
-        'border-width': 'tableBorderWidth',
-        'border-color': 'tableBorderColor',
-        'border-style': 'tableBorderStyle',
-        'background-color': 'tableBackgroundColor'
-    };
-    for (const [styleName, modelAttribute] of Object.entries(modelAttributes)) {
-        editor.conversion.for('dataDowncast').add(dispatcher => {
-            return dispatcher.on(`attribute:${modelAttribute}:table`, (evt, data, conversionApi) => {
-                const { item, attributeNewValue } = data;
-                const { mapper, writer } = conversionApi;
-                const hasPlainTableOutput = editor.plugins.has('PlainTableOutput');
-                const isClipboardPipeline = conversionApi.options.isClipboardPipeline;
-                const useExtendedAlignment = editor.config.get('experimentalFlags.useExtendedTableBlockAlignment');
-                if (!hasPlainTableOutput && !(useExtendedAlignment && isClipboardPipeline)) {
-                    return;
-                }
-                if (!conversionApi.consumable.consume(item, evt.name)) {
-                    return;
-                }
-                const table = mapper.toViewElement(item);
-                if (attributeNewValue) {
-                    writer.setStyle(styleName, attributeNewValue, table);
-                }
-                else {
-                    writer.removeStyle(styleName, table);
-                }
-            }, { priority: 'high' });
-        });
-    }
-}

package/src/converters/table-caption-post-fixer.js

@@ -1,55 +0,0 @@
-/**
- * @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
- */
-/**
- * Injects a table caption post-fixer into the model.
- *
- * The role of the table caption post-fixer is to ensure that the table with caption have the correct structure
- * after a {@link module:engine/model/model~Model#change `change()`} block was executed.
- *
- * The correct structure means that:
- *
- * * If there are many caption model element, they are merged into one model.
- * * A final, merged caption model is placed at the end of the table.
- *
- * @internal
- */
-export function injectTableCaptionPostFixer(model) {
-    model.document.registerPostFixer(writer => tableCaptionPostFixer(writer, model));
-}
-/**
- * The table caption post-fixer.
- */
-function tableCaptionPostFixer(writer, model) {
-    const changes = model.document.differ.getChanges();
-    let wasFixed = false;
-    for (const entry of changes) {
-        if (entry.type != 'insert') {
-            continue;
-        }
-        const positionParent = entry.position.parent;
-        if (positionParent.is('element', 'table') || entry.name == 'table') {
-            const table = (entry.name == 'table' ? entry.position.nodeAfter : positionParent);
-            const captionsToMerge = Array.from(table.getChildren())
-                .filter((child) => child.is('element', 'caption'));
-            const firstCaption = captionsToMerge.shift();
-            if (!firstCaption) {
-                continue;
-            }
-            // Move all the contents of the captions to the first one.
-            for (const caption of captionsToMerge) {
-                writer.move(writer.createRangeIn(caption), firstCaption, 'end');
-                writer.remove(caption);
-            }
-            // Make sure the final caption is at the end of the table.
-            if (firstCaption.nextSibling) {
-                writer.move(writer.createRangeOn(firstCaption), table, 'end');
-                wasFixed = true;
-            }
-            // Do we merged captions and/or moved the single caption to the end of the table?
-            wasFixed = !!captionsToMerge.length || wasFixed;
-        }
-    }
-    return wasFixed;
-}

package/src/converters/table-cell-paragraph-post-fixer.js

@@ -1,109 +0,0 @@
-/**
- * @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
- */
-/**
- * Injects a table cell post-fixer into the model which inserts a `paragraph` element into empty table cells.
- *
- * A table cell must contain at least one block element as a child. An empty table cell will have an empty `paragraph` as a child.
- *
- * ```xml
- * <table>
- *   <tableRow>
- *      <tableCell></tableCell>
- *   </tableRow>
- * </table>
- * ```
- *
- * Will be fixed to:
- *
- * ```xml
- * <table>
- *   <tableRow>
- *      <tableCell><paragraph></paragraph></tableCell>
- *   </tableRow>
- * </table>
- * ```
- *
- * @internal
- */
-export function injectTableCellParagraphPostFixer(model) {
-    model.document.registerPostFixer(writer => tableCellContentsPostFixer(writer, model));
-}
-/**
- * The table cell contents post-fixer.
- */
-function tableCellContentsPostFixer(writer, model) {
-    const changes = model.document.differ.getChanges();
-    let wasFixed = false;
-    for (const entry of changes) {
-        if (entry.type == 'insert' && entry.name == 'table') {
-            wasFixed = fixTable(entry.position.nodeAfter, writer) || wasFixed;
-        }
-        if (entry.type == 'insert' && entry.name == 'tableRow') {
-            wasFixed = fixTableRow(entry.position.nodeAfter, writer) || wasFixed;
-        }
-        if (entry.type == 'insert' && entry.name == 'tableCell') {
-            wasFixed = fixTableCellContent(entry.position.nodeAfter, writer) || wasFixed;
-        }
-        if ((entry.type == 'remove' || entry.type == 'insert') && checkTableCellChange(entry)) {
-            wasFixed = fixTableCellContent(entry.position.parent, writer) || wasFixed;
-        }
-    }
-    return wasFixed;
-}
-/**
- * Fixes all table cells in a table.
- */
-function fixTable(table, writer) {
-    let wasFixed = false;
-    for (const row of table.getChildren()) {
-        if (row.is('element', 'tableRow')) {
-            wasFixed = fixTableRow(row, writer) || wasFixed;
-        }
-    }
-    return wasFixed;
-}
-/**
- * Fixes all table cells in a table row.
- */
-function fixTableRow(tableRow, writer) {
-    let wasFixed = false;
-    for (const tableCell of tableRow.getChildren()) {
-        wasFixed = fixTableCellContent(tableCell, writer) || wasFixed;
-    }
-    return wasFixed;
-}
-/**
- * Fixes all table cell content by:
- * - Adding a paragraph to a table cell without any child.
- * - Wrapping direct $text in a `<paragraph>`.
- */
-function fixTableCellContent(tableCell, writer) {
-    // Insert paragraph to an empty table cell.
-    if (tableCell.childCount == 0) {
-        // @if CK_DEBUG_TABLE // console.log( 'Post-fixing table: insert paragraph in empty cell.' );
-        writer.insertElement('paragraph', tableCell);
-        return true;
-    }
-    // Check table cell children for directly placed text nodes.
-    // Temporary solution. See https://github.com/ckeditor/ckeditor5/issues/1464.
-    const textNodes = Array.from(tableCell.getChildren()).filter(child => child.is('$text'));
-    // @if CK_DEBUG_TABLE // textNodes.length && console.log( 'Post-fixing table: wrap cell content with paragraph.' );
-    for (const child of textNodes) {
-        writer.wrap(writer.createRangeOn(child), 'paragraph');
-    }
-    // Return true when there were text nodes to fix.
-    return !!textNodes.length;
-}
-/**
- * Checks if a differ change should fix the table cell. This happens on:
- * - Removing content from the table cell (i.e. `tableCell` can be left empty).
- * - Adding a text node directly into a table cell.
- */
-function checkTableCellChange(entry) {
-    if (!entry.position.parent.is('element', 'tableCell')) {
-        return false;
-    }
-    return entry.type == 'insert' && entry.name == '$text' || entry.type == 'remove';
-}