@ckeditor/ckeditor5-table 48.3.1 → 48.4.0-alpha.1

package/dist/index.js

@@ -6,10 +6,11 @@ import { Command, Plugin } from "@ckeditor/ckeditor5-core";
 import { Widget, WidgetToolbarRepository, isWidget, toWidget, toWidgetEditable } from "@ckeditor/ckeditor5-widget";
 import { CKEditorError, Collection, DomEmitterMixin, FocusTracker, KeystrokeHandler, Rect, first, getLocalizedArrowKeyCodeDirection, global, priorities, toUnit, uid } from "@ckeditor/ckeditor5-utils";
 import { debounce, isEqual, isObject, throttle } from "es-toolkit/compat";
+import { DomEventObserver, Matcher, ModelDocumentSelection, ModelElement, addBackgroundStylesRules, addBorderStylesRules, addMarginStylesRules, addPaddingStylesRules, enableViewPlaceholder, isColorStyleValue, isLengthStyleValue, isPercentageStyleValue } from "@ckeditor/ckeditor5-engine";
+import { _getCopyOnEnterAttributes } from "@ckeditor/ckeditor5-enter";
 import { IconAlignBottom, IconAlignCenter, IconAlignJustify, IconAlignLeft, IconAlignMiddle, IconAlignRight, IconAlignTop, IconCaption, IconObjectCenter, IconObjectInlineLeft, IconObjectInlineRight, IconObjectLeft, IconObjectRight, IconPreviousArrow, IconTable, IconTableCellProperties, IconTableColumn, IconTableLayout, IconTableMergeCell, IconTableProperties, IconTableRow } from "@ckeditor/ckeditor5-icons";
 import { BalloonPanelView, ButtonView, ColorSelectorView, ContextualBalloon, DropdownButtonView, FocusCycler, FormHeaderView, FormRowView, InputTextView, LabelView, LabeledFieldView, MenuBarMenuView, SplitButtonView, SwitchButtonView, ToolbarView, UIModel, View, ViewCollection, addKeyboardHandlingForGrid, addListToDropdown, clickOutsideHandler, createDropdown, createLabeledDropdown, createLabeledInputText, getLocalizedColorOptions, normalizeColorOptions, submitHandler } from "@ckeditor/ckeditor5-ui";
 import { ClipboardMarkersUtils, ClipboardPipeline } from "@ckeditor/ckeditor5-clipboard";
-import { DomEventObserver, Matcher, ModelElement, addBackgroundStylesRules, addBorderStylesRules, addMarginStylesRules, addPaddingStylesRules, enableViewPlaceholder, isColorStyleValue, isLengthStyleValue, isPercentageStyleValue } from "@ckeditor/ckeditor5-engine";
 
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -970,6 +971,20 @@ function isEntireCellsLineHeader({ table, row, column }) {
 function isTableCellTypeEnabled(editor) {
 	return editor.model.schema.checkAttribute("tableCell", "tableCellType");
 }
+/**
+* Yields every empty block (typically a `paragraph`) found inside the given table's cells.
+*
+* @internal
+*/
+function* getEmptyTableCellBlocks(table) {
+	for (const row of table.getChildren()) {
+		if (!row.is("element", "tableRow")) continue;
+		for (const cell of row.getChildren()) {
+			if (!cell.is("element", "tableCell")) continue;
+			for (const block of cell.getChildren()) if (block.is("element") && block.isEmpty) yield block;
+		}
+	}
+}
 
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -1809,6 +1824,16 @@ function getElementWidthInPixels(domElement) {
 	else return parseFloat(styles.width);
 }
 /**
+* Returns the inner pixel width of a given editing root, or `null` if the root has no
+* DOM element attached yet (e.g. it hasn't been rendered for the first time).
+*
+* @internal
+*/
+function getEditableWidth(editor, rootName) {
+	const domRoot = editor.editing.view.getDomRoot(rootName);
+	return domRoot ? getElementWidthInPixels(domRoot) : null;
+}
+/**
 * Returns the column indexes on the left and right edges of a cell. They differ if the cell spans
 * across multiple columns.
 *
@@ -1881,6 +1906,9 @@ function sumArray(array) {
 * @returns An array of column widths guaranteed to sum up to 100%.
 */
 function normalizeColumnWidths(columnWidths) {
+	const hasPixels = columnWidths.some((width) => typeof width === "string" && width.endsWith("px"));
+	const hasPercentages = columnWidths.some((width) => typeof width === "string" && width.endsWith("%"));
+	if (hasPixels && !hasPercentages) return columnWidths.map((width) => width === "auto" || width === void 0 ? "auto" : `${toPrecision(width)}px`);
 	let normalizedWidths = calculateMissingColumnWidths(columnWidths.map((width) => {
 		if (width === "auto" || width === void 0) return "auto";
 		return parseFloat(width.replace("%", ""));
@@ -1979,6 +2007,26 @@ function getTableColumnsWidths(element) {
 	return getTableColumnElements(element).map((column) => column.getAttribute("columnWidth"));
 }
 /**
+* Tells whether a table is in the pixel width mode, that is, its `tableWidth` attribute is expressed in pixels.
+* The `tableWidth` unit is the single source of truth for the whole table's width mode.
+*
+* @internal
+* @param table A 'table' model element.
+*/
+function isTableWidthInPixels(table) {
+	const tableWidth = table.getAttribute("tableWidth");
+	return typeof tableWidth === "string" && tableWidth.trim().endsWith("px");
+}
+/**
+* Tells whether the given column widths are expressed in pixels.
+*
+* @internal
+* @param columnWidths An array of column widths.
+*/
+function isColumnWidthsInPixels(columnWidths) {
+	return columnWidths.some((width) => typeof width === "string" && width.endsWith("px"));
+}
+/**
 * Translates the `colSpan` model attribute into additional column widths and returns the resulting array.
 *
 * @internal
@@ -1999,6 +2047,19 @@ function translateColSpanAttribute(element, writer) {
 		return acc;
 	}, []);
 }
+/**
+* Removes the `tableCellWidth` attribute from every cell of the given table. Once a column is resized (with the resize
+* handler or the column-width command), a per-cell width is obsolete - the column width governs the layout - so it is
+* dropped to keep the model clean.
+*
+* @internal
+*/
+function removeCellWidthsFromTable(writer, table) {
+	for (const row of table.getChildren()) {
+		if (!row.is("element", "tableRow")) continue;
+		for (const cell of row.getChildren()) writer.removeAttribute("tableCellWidth", cell);
+	}
+}
 
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -2388,10 +2449,12 @@ var TableUtils = class extends Plugin {
 				else if (column === removedColumnIndex) writer.remove(cell);
 				if (tableColumns[removedColumnIndex]) {
 					const adjacentColumn = removedColumnIndex === 0 ? tableColumns[1] : tableColumns[removedColumnIndex - 1];
-					const removedColumnWidth = parseFloat(tableColumns[removedColumnIndex].getAttribute("columnWidth"));
+					const removedColumnWidthAttribute = tableColumns[removedColumnIndex].getAttribute("columnWidth");
+					const removedColumnWidth = parseFloat(removedColumnWidthAttribute);
 					const adjacentColumnWidth = parseFloat(adjacentColumn.getAttribute("columnWidth"));
 					writer.remove(tableColumns[removedColumnIndex]);
-					writer.setAttribute("columnWidth", removedColumnWidth + adjacentColumnWidth + "%", adjacentColumn);
+					const unit = removedColumnWidthAttribute.trim().endsWith("px") ? "px" : "%";
+					writer.setAttribute("columnWidth", `${removedColumnWidth + adjacentColumnWidth}${unit}`, adjacentColumn);
 				}
 			}
 			if (!removeEmptyRows(table, this)) removeEmptyColumns(table, this);
@@ -3503,11 +3566,16 @@ var InsertTableCommand = class extends Command {
 	* @param options.footerRows The number of footer rows. If not provided it will default to
 	* {@link module:table/tableconfig~TableConfig#defaultFooters `config.table.defaultFooters`} table config.
 	* This option is ignored when {@link module:table/tableconfig~TableConfig#enableFooters `config.table.enableFooters`} is `false`.
+	* @param options.inheritTextFormattingAttributes Whether every empty cell should inherit the `copyOnEnter` text
+	* formatting attributes (e.g. bold, font color) that were uniformly active in the content right before
+	* the table, so that whichever cell the user starts typing in first continues that formatting. Defaults
+	* to `true`.
 	* @fires execute
 	*/
 	execute(options = {}) {
 		const editor = this.editor;
 		const model = editor.model;
+		const selection = model.document.selection;
 		const tableUtils = editor.plugins.get("TableUtils");
 		const areTableFootersEnabled = !!editor.config.get("table.enableFooters");
 		const defaultRows = editor.config.get("table.defaultHeadings.rows");
@@ -3518,6 +3586,7 @@ var InsertTableCommand = class extends Command {
 		if (areTableFootersEnabled && options.footerRows === void 0 && defaultFooterRows) options.footerRows = defaultFooterRows;
 		if (!areTableFootersEnabled && "footerRows" in options) delete options.footerRows;
 		model.change((writer) => {
+			const selectionAttributesToCopy = Array.from(_getCopyOnEnterAttributes(model.schema, selection.getAttributes()));
 			const table = tableUtils.createTable(writer, options);
 			model.insertObject(table, null, null, { findOptimalPosition: "auto" });
 			writer.setSelection(writer.createPositionAt(table.getNodeByPath([
@@ -3525,6 +3594,7 @@ var InsertTableCommand = class extends Command {
 				0,
 				0
 			]), 0));
+			if (options.inheritTextFormattingAttributes !== false && selectionAttributesToCopy.length) for (const cellBlock of getEmptyTableCellBlocks(table)) for (const [key, value] of selectionAttributesToCopy) writer.setAttribute(ModelDocumentSelection._getStoreAttributeKey(key), value, cellBlock);
 		});
 	}
 };
@@ -3695,7 +3765,8 @@ var InsertColumnCommand = class extends 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:
+* You can split any cell vertically or horizontally by executing this command. When multiple cells are selected, each of them
+* is split, and the whole operation is a single undo step. For example, to split the selected table cells vertically:
 *
 * ```ts
 * editor.execute( 'splitTableCellVertically' );
@@ -3721,16 +3792,19 @@ var SplitCellCommand = class extends Command {
 	*/
 	refresh() {
 		const selectedCells = this.editor.plugins.get("TableUtils").getSelectionAffectedTableCells(this.editor.model.document.selection);
-		this.isEnabled = selectedCells.length === 1;
+		this.isEnabled = selectedCells.length > 0;
 	}
 	/**
 	* @inheritDoc
 	*/
 	execute() {
 		const tableUtils = this.editor.plugins.get("TableUtils");
-		const tableCell = tableUtils.getSelectionAffectedTableCells(this.editor.model.document.selection)[0];
-		if (this.direction === "horizontally") tableUtils.splitCellHorizontally(tableCell, 2);
-		else tableUtils.splitCellVertically(tableCell, 2);
+		const tableCells = tableUtils.getSelectionAffectedTableCells(this.editor.model.document.selection);
+		const isHorizontal = this.direction === "horizontally";
+		this.editor.model.change(() => {
+			for (const tableCell of tableCells) if (isHorizontal) tableUtils.splitCellHorizontally(tableCell, 2);
+			else tableUtils.splitCellVertically(tableCell, 2);
+		});
 	}
 };
 
@@ -8552,7 +8626,8 @@ var TableCellPropertiesUI = class extends Plugin {
 		const commands = this.editor.commands;
 		const borderStyleCommand = commands.get("tableCellBorderStyle");
 		Object.entries(propertyToCommandMap$1).flatMap(([property, commandName]) => {
-			const command = commands.get(commandName);
+			const effectiveCommandName = property === "width" ? this._getWidthCommandName() : commandName;
+			const command = commands.get(effectiveCommandName);
 			if (!command) return [];
 			const propertyKey = property;
 			let defaultValue;
@@ -8652,7 +8727,8 @@ var TableCellPropertiesUI = class extends Plugin {
 			setErrorTextDebounced.cancel();
 			if (!this._isReady) return;
 			if (validator(newValue)) {
-				this.editor.execute(commandName, {
+				const executedCommandName = commandName === "tableCellWidth" ? this._getWidthCommandName() : commandName;
+				this.editor.execute(executedCommandName, {
 					value: newValue,
 					batch: this._undoStepBatch
 				});
@@ -8660,6 +8736,16 @@ var TableCellPropertiesUI = class extends Plugin {
 			} else setErrorTextDebounced();
 		};
 	}
+	/**
+	* Returns the command that drives the width field. When the table is resized and the selection maps onto a single
+	* column, the width field is bound to (and executes) the `'tableColumnWidth'` command, so the width applies to the
+	* column instead of being set as a per-cell width that the column group would shadow. Otherwise it falls back to
+	* the `'tableCellWidth'` command.
+	*/
+	_getWidthCommandName() {
+		const columnWidthCommand = this.editor.commands.get("tableColumnWidth");
+		return columnWidthCommand && columnWidthCommand.isEnabled ? "tableColumnWidth" : "tableCellWidth";
+	}
 };
 
 /**
@@ -9560,11 +9646,14 @@ function enableLegacyHorizontalAlignmentAttribute(conversion) {
 			if (!modelElement?.is("element")) return;
 			const alignValue = data.viewItem.getAttribute("align");
 			if (!conversionApi.consumable.consume(data.viewItem, { attributes: ["align"] })) return;
-			for (const child of modelElement.getChildren()) if (child.is("element")) applyAlignmentToChild(child, alignValue, conversionApi);
+			for (const child of modelElement.getChildren())
+ /* v8 ignore else -- A table cell only contains block elements, so its children are always elements. */
+			if (child.is("element")) applyAlignmentToChild(child, alignValue, conversionApi);
 		}, { priority: "low" });
 	});
 	function applyAlignmentToChild(child, alignValue, { schema, writer }) {
 		const definition = schema.getDefinition(child);
+		/* v8 ignore else -- A converted child element is always registered in the schema, so it always has a definition. */
 		if (definition) for (const attrName of definition.allowAttributes) {
 			if (child.hasAttribute(attrName)) continue;
 			const { blockAlignment } = schema.getAttributeProperties(attrName);
@@ -9704,12 +9793,14 @@ function enableCellTypeProperty(editor) {
 				const cell = change.range.start.nodeAfter;
 				if (cell?.is("element", "tableCell") && cell.root.rootName !== "$graveyard") {
 					const table = cell.findAncestor("table");
+					/* v8 ignore else -- A table cell always lives inside a table, so it always has a table ancestor here. */
 					if (table) tablesToCheck.add(table);
 				}
 			}
 			if (change.type === "insert" && change.position.nodeAfter) {
 				for (const { item } of model.createRangeOn(change.position.nodeAfter)) if (item.is("element", "tableCell") && item.getAttribute("tableCellType") && item.root.rootName !== "$graveyard") {
 					const table = item.findAncestor("table");
+					/* v8 ignore else -- An inserted table cell always lives inside a table, so it always has a table ancestor here. */
 					if (table) tablesToCheck.add(table);
 				}
 			}
@@ -9880,7 +9971,8 @@ var TableLayoutUI = class extends Plugin {
 		if (!editor.plugins.has("TablePropertiesUI")) return;
 		const tablePropertiesUI = plugins.get("TablePropertiesUI");
 		ui.componentFactory.add("tableProperties", (locale) => {
-			return createTableTypeDropdown(editor, new SplitButtonView(locale, tablePropertiesUI._createTablePropertiesButton()));
+			const splitButtonView = new SplitButtonView(locale, tablePropertiesUI._createTablePropertiesButton());
+			return createTableTypeDropdown(editor, splitButtonView);
 		});
 	}
 };
@@ -9980,13 +10072,19 @@ var InsertTableLayoutCommand = class extends Command {
 	*
 	* @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.inheritTextFormattingAttributes Whether every empty cell should inherit the `copyOnEnter` text
+	* formatting attributes (e.g. bold, font color) that were uniformly active in the content right before
+	* the table, so that whichever cell the user starts typing in first continues that formatting. Defaults
+	* to `true`.
 	* @fires execute
 	*/
 	execute(options = {}) {
 		const editor = this.editor;
 		const model = editor.model;
+		const selection = model.document.selection;
 		const tableUtils = editor.plugins.get("TableUtils");
 		model.change((writer) => {
+			const selectionAttributesToCopy = Array.from(_getCopyOnEnterAttributes(model.schema, selection.getAttributes()));
 			const normalizedOptions = {
 				rows: options.rows || 2,
 				columns: options.columns || 2
@@ -10006,6 +10104,7 @@ var InsertTableLayoutCommand = class extends Command {
 				0,
 				0
 			]), 0));
+			if (options.inheritTextFormattingAttributes !== false && selectionAttributesToCopy.length) for (const cellBlock of getEmptyTableCellBlocks(table)) for (const [key, value] of selectionAttributesToCopy) writer.setAttribute(ModelDocumentSelection._getStoreAttributeKey(key), value, cellBlock);
 		});
 	}
 };
@@ -10047,6 +10146,7 @@ var TableWidthsCommand = class extends Command {
 			if (!columnWidths && !tableColumnGroup) return;
 			if (!columnWidths) return writer.remove(tableColumnGroup);
 			const widths = normalizeColumnWidths(columnWidths);
+			removeCellWidthsFromTable(writer, table);
 			if (!tableColumnGroup) {
 				const colGroupElement = writer.createElement("tableColumnGroup");
 				widths.forEach((columnWidth) => writer.appendElement("tableColumn", { columnWidth }, colGroupElement));
@@ -10056,6 +10156,76 @@ var TableWidthsCommand = class extends Command {
 	}
 };
 
+/**
+* @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/tablecolumnresize/commands/tablecolumnwidthcommand
+*/
+/**
+* The table column width command.
+*
+* The command is registered by the {@link module:table/tablecolumnresize/tablecolumnresizeediting~TableColumnResizeEditing}
+* as the `'tableColumnWidth'` editor command.
+*
+* It sets the width of every column covered by the selected cells (keeping the whole table's width mode consistent),
+* so the change actually takes effect in a resized table - where a per-cell width would be shadowed by the column
+* group. The command is enabled whenever the selection maps onto the columns of a resized, regular table.
+*
+* ```ts
+* editor.execute( 'tableColumnWidth', {
+*   value: '150px'
+* } );
+* ```
+*
+* **Note**: This command adds a default `'px'` unit to numeric values. Executing:
+*
+* ```ts
+* editor.execute( 'tableColumnWidth', {
+*   value: '150'
+* } );
+* ```
+*
+* will set the column width to `'150px'`.
+*/
+var TableColumnWidthCommand = class extends Command {
+	/**
+	* @inheritDoc
+	*/
+	refresh() {
+		const editor = this.editor;
+		const tableUtils = editor.plugins.get("TableUtils");
+		const tableColumnResize = editor.plugins.get("TableColumnResizeEditing");
+		const tableCells = tableUtils.getSelectionAffectedTableCells(editor.model.document.selection);
+		const columns = tableColumnResize.getColumnIndexesForCells(tableCells);
+		if (!columns) {
+			this.isEnabled = false;
+			this.value = null;
+			return;
+		}
+		this.isEnabled = true;
+		this.value = tableColumnResize.getTableColumnElements(columns.table)[columns.columnIndexes[0]].getAttribute("columnWidth");
+	}
+	/**
+	* @inheritDoc
+	*/
+	execute(options = {}) {
+		const editor = this.editor;
+		const model = editor.model;
+		const tableUtils = editor.plugins.get("TableUtils");
+		const tableColumnResize = editor.plugins.get("TableColumnResizeEditing");
+		const value = addDefaultUnitToNumericValue(options.value, "px");
+		const tableCells = tableUtils.getSelectionAffectedTableCells(model.document.selection);
+		const columns = tableColumnResize.getColumnIndexesForCells(tableCells);
+		if (!value || !columns || Number.isNaN(parseFloat(value))) return;
+		model.enqueueChange(options.batch, (writer) => {
+			tableColumnResize.applyColumnWidths(writer, columns.table, columns.columnIndexes, value);
+			removeCellWidthsFromTable(writer, columns.table);
+		});
+	}
+};
+
 /**
 * @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
@@ -10118,10 +10288,6 @@ const toPx = /* #__PURE__ */ toUnit("px");
 * The table column resize editing plugin.
 */
 var TableColumnResizeEditing = class extends Plugin {
-	/**
-	* A flag indicating if the column resizing is in progress.
-	*/
-	_isResizingActive;
 	/**
 	* A temporary storage for the required data needed to correctly calculate the widths of the resized columns. This storage is
 	* initialized when column resizing begins, and is purged upon completion.
@@ -10175,7 +10341,7 @@ var TableColumnResizeEditing = class extends Plugin {
 	*/
 	constructor(editor) {
 		super(editor);
-		this._isResizingActive = false;
+		this.set("_isResizingActive", false);
 		this.set("_isResizingAllowed", true);
 		this._resizingData = null;
 		this._domEmitter = new (DomEmitterMixin())();
@@ -10186,6 +10352,10 @@ var TableColumnResizeEditing = class extends Plugin {
 				for (const root of editor.editing.view.document.roots) writer[classAction]("ck-column-resize_disabled", editor.editing.view.document.getRoot(root.rootName));
 			});
 		});
+		this.on("change:_isResizingActive", (evt, name, value) => {
+			const classAction = value ? "add" : "remove";
+			global.document.body.classList[classAction]("ck-table-column-resize__resizing-cursor");
+		});
 	}
 	/**
 	* @inheritDoc
@@ -10196,6 +10366,8 @@ var TableColumnResizeEditing = class extends Plugin {
 		this._registerConverters();
 		this._registerResizingListeners();
 		this._registerResizerInserter();
+		this.decorate("_setResizingTableWidth");
+		this.decorate("_getResizingTableWidth");
 		const editor = this.editor;
 		const columnResizePlugin = editor.plugins.get("TableColumnResize");
 		editor.plugins.get("TableEditing").registerAdditionalSlot({
@@ -10205,16 +10377,43 @@ var TableColumnResizeEditing = class extends Plugin {
 		const tableWidthsCommand = new TableWidthsCommand(editor);
 		editor.commands.add("resizeTableWidth", tableWidthsCommand);
 		editor.commands.add("resizeColumnWidths", tableWidthsCommand);
+		editor.commands.add("tableColumnWidth", new TableColumnWidthCommand(editor));
 		this.bind("_isResizingAllowed").to(editor, "isReadOnly", columnResizePlugin, "isEnabled", tableWidthsCommand, "isEnabled", (isEditorReadOnly, isPluginEnabled, isTableWidthsCommandCommandEnabled) => !isEditorReadOnly && isPluginEnabled && isTableWidthsCommandCommandEnabled);
 	}
 	/**
 	* @inheritDoc
 	*/
+	afterInit() {
+		const editor = this.editor;
+		const tableWidthCommand = editor.commands.get("tableWidth");
+		if (tableWidthCommand) {
+			this.listenTo(tableWidthCommand, "execute", (evt, args) => {
+				const options = args[0] || (args[0] = {});
+				if (!options.batch) options.batch = editor.model.createBatch();
+			}, { priority: "high" });
+			this.listenTo(tableWidthCommand, "execute", (evt, args) => {
+				const options = args[0];
+				const table = getSelectionAffectedTable(editor.model.document.selection);
+				editor.model.enqueueChange(options.batch, (writer) => this._reconcileColumnUnits(writer, table));
+			}, { priority: "low" });
+		}
+	}
+	/**
+	* @inheritDoc
+	*/
 	destroy() {
 		this._domEmitter.stopListening();
+		this._isResizingActive = false;
 		super.destroy();
 	}
 	/**
+	* The table for which a column resize is currently in progress, or `null` if no resize is active.
+	* Only one table can be resized at a time.
+	*/
+	get resizingTable() {
+		return this._resizingData ? this._resizingData.elements.modelTable : null;
+	}
+	/**
 	* Returns a 'tableColumnGroup' element from the 'table'.
 	*
 	* @param element A 'table' or 'tableColumnGroup' element.
@@ -10242,6 +10441,144 @@ var TableColumnResizeEditing = class extends Plugin {
 		return getTableColumnsWidths(element);
 	}
 	/**
+	* Returns the table and the sorted, unique indexes of the columns covered by the given cells (a `colspan` cell
+	* covers several columns). Returns `null` when the selection cannot be mapped onto columns - a non-resized table
+	* or an irregular column structure.
+	*
+	* @param cells An array of 'tableCell' model elements.
+	*/
+	getColumnIndexesForCells(cells) {
+		const table = cells.length ? cells[0].findAncestor("table") : null;
+		if (!table) return null;
+		const columns = getTableColumnElements(table);
+		if (!columns.length || columns.length !== this._tableUtilsPlugin.getColumns(table) || columns.some((column) => column.hasAttribute("colSpan"))) return null;
+		const columnIndexes = /* @__PURE__ */ new Set();
+		for (const cell of cells) {
+			const { leftEdge, rightEdge } = getColumnEdgesIndexes(cell, this._tableUtilsPlugin);
+			for (let index = leftEdge; index <= rightEdge; index++) columnIndexes.add(index);
+		}
+		return {
+			table,
+			columnIndexes: Array.from(columnIndexes).sort((indexA, indexB) => indexA - indexB)
+		};
+	}
+	/**
+	* Applies the given width to every column in `columnIndexes`, keeping the whole table's width mode consistent
+	* (see {@link module:table/tablecolumnresize/utils~isTableWidthInPixels}).
+	*
+	* @param writer A model writer instance.
+	* @param table A 'table' model element.
+	* @param columnIndexes Indexes of the columns the width is applied to.
+	* @param value The width to apply. May be expressed in pixels or as a percentage.
+	*/
+	applyColumnWidths(writer, table, columnIndexes, value) {
+		if (isTableWidthInPixels(table)) applyPixelColumnWidths(writer, table, columnIndexes, value);
+		else this._applyPercentageColumnWidths(writer, table, columnIndexes, value);
+	}
+	/**
+	* Converts the column widths of a resized table to the unit of the table's own width (`px` or `%`), so a table
+	* width change (in the table properties) also switches the columns' unit. It is a no-op when the table is not
+	* resized or the columns already use that unit.
+	*/
+	_reconcileColumnUnits(writer, table) {
+		const tableColumnGroup = getColumnGroupElement(table);
+		if (!tableColumnGroup) return;
+		const columnWidths = getTableColumnsWidths(tableColumnGroup);
+		const tableIsPixels = isTableWidthInPixels(table);
+		if (tableIsPixels === isColumnWidthsInPixels(columnWidths)) return;
+		let reconciledWidths;
+		if (tableIsPixels) {
+			const tableWidthInPixels = parseFloat(table.getAttribute("tableWidth"));
+			reconciledWidths = columnWidths.map((width) => `${toPrecision(parseFloat(width) / 100 * tableWidthInPixels)}px`);
+		} else {
+			const totalWidth = sumArray(columnWidths.map((width) => parseFloat(width)));
+			reconciledWidths = columnWidths.map((width) => `${toPrecision(parseFloat(width) / totalWidth * 100)}%`);
+		}
+		updateColumnElements(getTableColumnElements(tableColumnGroup), tableColumnGroup, reconciledWidths, writer);
+	}
+	/**
+	* Applies a column width in the percentage mode: the target column gets the (clamped) percentage and the remaining
+	* columns are redistributed proportionally so that all the widths keep summing up to 100%.
+	*/
+	_applyPercentageColumnWidths(writer, table, columnIndexes, value) {
+		const columns = getTableColumnElements(table);
+		const widths = getTableColumnsWidths(table).map((width) => parseFloat(width));
+		if (columnIndexes.includes(columns.length - 1)) {
+			this._growTableToColumnWidths(writer, table, columns, widths, columnIndexes, value);
+			return;
+		}
+		const targetPercentage = value.trim().endsWith("%") ? parseFloat(value) : parseFloat(value) / getTableWidthInPixels(table, this.editor) * 100;
+		const nextWidths = widths.slice();
+		for (const band of getContiguousBands(columnIndexes)) {
+			const neighbor = band.end + 1;
+			const bandCount = band.indexes.length;
+			const available = band.indexes.reduce((sum, index) => sum + widths[index], widths[neighbor]);
+			if (available < 5 * (bandCount + 1)) {
+				const equalWidth = available / (bandCount + 1);
+				for (const index of band.indexes) nextWidths[index] = equalWidth;
+				nextWidths[neighbor] = equalWidth;
+				continue;
+			}
+			const target = clamp(targetPercentage, 5, (available - 5) / bandCount);
+			for (const index of band.indexes) nextWidths[index] = target;
+			nextWidths[neighbor] = available - target * bandCount;
+		}
+		columns.forEach((columnElement, index) => {
+			writer.setAttribute("columnWidth", `${toPrecision(nextWidths[index])}%`, columnElement);
+		});
+	}
+	/**
+	* Applies a width to the target columns in the percentage mode when the selection reaches the last column. As
+	* there is no next column to balance against, the table itself grows or shrinks (like dragging the last column's
+	* right edge): every other column keeps its absolute width, so expressed against the resized table their
+	* percentages scale, and the table's own width scales by the inverse.
+	*/
+	_growTableToColumnWidths(writer, table, columns, widths, columnIndexes, value) {
+		const targetColumns = new Set(columnIndexes);
+		const targetCount = columnIndexes.length;
+		const otherColumnsShare = 100 - columnIndexes.reduce((sum, index) => sum + widths[index], 0);
+		if (otherColumnsShare <= 0) {
+			const equalWidth = 100 / columns.length;
+			columns.forEach((columnElement) => {
+				writer.setAttribute("columnWidth", `${toPrecision(equalWidth)}%`, columnElement);
+			});
+			return;
+		}
+		let targetPercentage;
+		if (value.trim().endsWith("%")) targetPercentage = parseFloat(value);
+		else {
+			const pixelWidth = parseFloat(value);
+			targetPercentage = pixelWidth / (otherColumnsShare / 100 * getTableWidthInPixels(table, this.editor) + targetCount * pixelWidth) * 100;
+		}
+		const target = clamp(targetPercentage, 5, Math.max(5, (100 - 5 * (columns.length - targetCount)) / targetCount));
+		const scale = (100 - target * targetCount) / otherColumnsShare;
+		columns.forEach((columnElement, index) => {
+			const next = targetColumns.has(index) ? target : widths[index] * scale;
+			writer.setAttribute("columnWidth", `${toPrecision(next)}%`, columnElement);
+		});
+		const tableWidth = parseFloat(table.getAttribute("tableWidth"));
+		if (!Number.isNaN(tableWidth)) writer.setAttribute("tableWidth", `${toPrecision(tableWidth / scale)}%`, table);
+	}
+	/**
+	* Applies `width` to whichever element currently represents the table's actual width - by default the
+	* widget's `<figure>`. Passing `null` clears it instead of setting anything.
+	*
+	* @internal
+	*/
+	_setResizingTableWidth(writer, viewFigure, width) {
+		if (width === null) writer.removeStyle("width", viewFigure);
+		else writer.setStyle("width", width, viewFigure);
+	}
+	/**
+	* Returns the table's current actual width, read from whichever element holds it - by default the
+	* widget's `<figure>`.
+	*
+	* @internal
+	*/
+	_getResizingTableWidth(viewFigure) {
+		return viewFigure.getStyle("width");
+	}
+	/**
 	* Registers new attributes for a table model element.
 	*/
 	_extendSchema() {
@@ -10273,8 +10610,11 @@ var TableColumnResizeEditing = class extends Plugin {
 				const tableColumnGroup = this.getColumnGroupElement(table);
 				const columns = this.getTableColumnElements(tableColumnGroup);
 				const columnWidths = this.getTableColumnsWidths(tableColumnGroup);
-				let normalizedWidths = normalizeColumnWidths(columnWidths);
+				const isPixelMode = isColumnWidthsInPixels(columnWidths);
+				let normalizedWidths = isPixelMode ? normalizePixelColumnWidths(columnWidths, table) : normalizeColumnWidths(columnWidths);
 				normalizedWidths = adjustColumnWidths(normalizedWidths, table, this);
+				if (isPixelMode && normalizedWidths.length !== columnWidths.length) writer.setAttribute("tableWidth", `${toPrecision(sumArray(normalizedWidths))}px`, table);
+				else normalizedWidths = scalePixelColumnsToTableWidth(normalizedWidths, table);
 				if (isEqual(columnWidths, normalizedWidths)) continue;
 				updateColumnElements(columns, tableColumnGroup, normalizedWidths, writer);
 				changed = true;
@@ -10290,7 +10630,8 @@ var TableColumnResizeEditing = class extends Plugin {
 		function adjustColumnWidths(columnWidths, table, plugin) {
 			const newTableColumnsCount = plugin._tableUtilsPlugin.getColumns(table);
 			if (newTableColumnsCount - columnWidths.length === 0) return columnWidths;
-			const widths = columnWidths.map((width) => Number(width.replace("%", "")));
+			const isPixelMode = isColumnWidthsInPixels(columnWidths);
+			const widths = columnWidths.map((width) => parseFloat(width));
 			const cellSet = getAffectedCells(plugin.editor.model.document.differ, table);
 			for (const cell of cellSet) {
 				const currentColumnsDelta = newTableColumnsCount - widths.length;
@@ -10298,14 +10639,14 @@ var TableColumnResizeEditing = class extends Plugin {
 				const hasMoreColumns = currentColumnsDelta > 0;
 				const currentColumnIndex = plugin._tableUtilsPlugin.getCellLocation(cell).column;
 				if (hasMoreColumns) {
-					const columnWidthsToInsert = createFilledArray(currentColumnsDelta, getColumnMinWidthAsPercentage(table, plugin.editor));
+					const columnWidthsToInsert = createFilledArray(currentColumnsDelta, isPixelMode ? 40 : getColumnMinWidthAsPercentage(table, plugin.editor));
 					widths.splice(currentColumnIndex, 0, ...columnWidthsToInsert);
 				} else {
 					const removedColumnWidths = widths.splice(currentColumnIndex, Math.abs(currentColumnsDelta));
 					widths[currentColumnIndex] += sumArray(removedColumnWidths);
 				}
 			}
-			return widths.map((width) => width + "%");
+			return widths.map((width) => `${width}${isPixelMode ? "px" : "%"}`);
 		}
 		/**
 		* Returns a set of cells that have been changed in a given table.
@@ -10369,7 +10710,7 @@ var TableColumnResizeEditing = class extends Plugin {
 				key: "columnWidth",
 				value: (viewElement) => {
 					const viewColWidth = viewElement.getStyle("width");
-					if (!viewColWidth || !viewColWidth.endsWith("%") && !viewColWidth.endsWith("pt")) return "auto";
+					if (!viewColWidth || !viewColWidth.endsWith("%") && !viewColWidth.endsWith("pt") && !(viewColWidth.endsWith("px") && isViewTableWidthInPixels(viewElement))) return "auto";
 					return viewColWidth;
 				}
 			}
@@ -10490,13 +10831,18 @@ var TableColumnResizeEditing = class extends Plugin {
 		const { target } = domEventData;
 		const modelTable = this.editor.editing.mapper.toModelElement(target.findAncestor("figure"));
 		const viewTable = target.findAncestor("table");
+		const viewFigure = target.findAncestor("figure");
+		const isPixelMode = isTableWidthInPixels(modelTable);
 		const columnWidthsInPx = _calculateDomColumnWidths(modelTable, this._tableUtilsPlugin, this.editor);
 		if (!Array.from(viewTable.getChildren()).find((viewCol) => viewCol.is("element", "colgroup"))) this.editor.editing.view.change((viewWriter) => {
-			_insertColgroupElement(viewWriter, columnWidthsInPx, viewTable);
+			_insertColgroupElement(viewWriter, columnWidthsInPx, viewTable, isPixelMode);
 		});
 		this._isResizingActive = true;
 		this._resizingData = this._getResizingData(domEventData, columnWidthsInPx);
-		this.editor.editing.view.change((writer) => _applyResizingAttributesToTable(writer, viewTable, this._resizingData));
+		this.editor.editing.view.change((writer) => {
+			const initialWidth = _applyResizingAttributesToTable(writer, viewTable, this._resizingData);
+			this._setResizingTableWidth(writer, viewFigure, initialWidth);
+		});
 		/**
 		* Calculates the DOM columns' widths. It is done by taking the width of the widest cell
 		* from each table column (we rely on the  {@link module:table/tablewalker~TableWalker}
@@ -10524,28 +10870,29 @@ var TableColumnResizeEditing = class extends Plugin {
 		* @param columnWidthsInPx Column widths.
 		* @param viewTable A table view element.
 		*/
-		function _insertColgroupElement(viewWriter, columnWidthsInPx, viewTable) {
+		function _insertColgroupElement(viewWriter, columnWidthsInPx, viewTable, isPixelMode) {
 			const colgroup = viewWriter.createContainerElement("colgroup");
 			for (let i = 0; i < columnWidthsInPx.length; i++) {
 				const viewColElement = viewWriter.createEmptyElement("col");
-				const columnWidthInPc = `${toPrecision(columnWidthsInPx[i] / sumArray(columnWidthsInPx) * 100)}%`;
-				viewWriter.setStyle("width", columnWidthInPc, viewColElement);
+				const columnWidth = isPixelMode ? `${toPrecision(columnWidthsInPx[i])}px` : `${toPrecision(columnWidthsInPx[i] / sumArray(columnWidthsInPx) * 100)}%`;
+				viewWriter.setStyle("width", columnWidth, viewColElement);
 				viewWriter.insert(viewWriter.createPositionAt(colgroup, "end"), viewColElement);
 			}
 			viewWriter.insert(viewWriter.createPositionAt(viewTable, 0), colgroup);
 		}
 		/**
-		* Applies the style and classes to the view table as the resizing begun.
+		* Applies the classes to the view table as the resizing begun, and computes the initial live width.
 		*
 		* @param viewWriter A writer instance.
 		* @param viewTable A table containing the clicked resizer.
 		* @param resizingData Data related to the resizing.
+		* @returns The table's current width as a `%` string, e.g. for seeding {@link #_setResizingTableWidth}.
 		*/
 		function _applyResizingAttributesToTable(viewWriter, viewTable, resizingData) {
-			const figureInitialPcWidth = resizingData.widths.viewFigureWidth / resizingData.widths.viewFigureParentWidth;
 			viewWriter.addClass("ck-table-resized", viewTable);
 			viewWriter.addClass("ck-table-column-resizer__active", resizingData.elements.viewResizer);
-			viewWriter.setStyle("width", `${toPrecision(figureInitialPcWidth * 100)}%`, viewTable.findAncestor("figure"));
+			const figureWidth = Math.max(resizingData.widths.tableWidth, resizingData.widths.viewFigureWidth);
+			return resizingData.flags.isPixelMode ? `${toPrecision(figureWidth)}px` : `${toPrecision(figureWidth / resizingData.widths.viewFigureParentWidth * 100)}%`;
 		}
 	}
 	/**
@@ -10570,22 +10917,40 @@ var TableColumnResizeEditing = class extends Plugin {
 			this._onMouseUpHandler();
 			return;
 		}
-		const { columnPosition, flags: { isRightEdge, isTableCentered, isLtrContent }, elements: { viewFigure, viewLeftColumn, viewRightColumn, viewResizer }, widths: { viewFigureParentWidth, tableWidth, leftColumnWidth, rightColumnWidth } } = this._resizingData;
+		const { plugins } = this.editor;
+		const { columnPosition, flags: { isRightEdge, isTableCentered, isLtrContent, isPixelMode, isTableWidthWithinContainerAtDragStart, isTableScrollAllowed }, elements: { modelTable, viewFigure, viewLeftColumn, viewRightColumn, viewResizer }, widths: { viewFigureParentWidth, tableWidth, leftColumnWidth, rightColumnWidth } } = this._resizingData;
 		const dxLowerBound = -leftColumnWidth + 40;
-		const dxUpperBound = isRightEdge ? viewFigureParentWidth - tableWidth : rightColumnWidth - 40;
-		const multiplier = (isLtrContent ? 1 : -1) * (isRightEdge && isTableCentered ? 2 : 1);
-		const dx = clamp((mouseEventData.clientX - columnPosition) * multiplier, Math.min(dxLowerBound, 0), Math.max(dxUpperBound, 0));
+		const isTableScrollActive = !!(plugins.has("TableScrollEditing") ? plugins.get("TableScrollEditing") : null) && isTableScrollAllowed;
+		const containerWidth = getEditableWidth(this.editor, modelTable.root.rootName);
+		let dxUpperBound;
+		if (isRightEdge) dxUpperBound = isTableScrollActive ? Infinity : viewFigureParentWidth - tableWidth;
+		else dxUpperBound = rightColumnWidth - 40;
+		const rawDx = mouseEventData.clientX - columnPosition;
+		const ltrSign = isLtrContent ? 1 : -1;
+		const isCenteredRightEdge = isRightEdge && isTableCentered;
+		let dx;
+		if (isTableScrollActive && isCenteredRightEdge) {
+			const mouseDelta = rawDx * ltrSign;
+			let newTableWidth;
+			if (isTableWidthWithinContainerAtDragStart) {
+				const crossoverPoint = (containerWidth - tableWidth) / 2;
+				newTableWidth = mouseDelta <= crossoverPoint ? tableWidth + 2 * mouseDelta : containerWidth + (mouseDelta - crossoverPoint);
+			} else {
+				const crossoverPoint = containerWidth - tableWidth;
+				newTableWidth = mouseDelta >= crossoverPoint ? tableWidth + mouseDelta : containerWidth + 2 * (mouseDelta - crossoverPoint);
+			}
+			dx = newTableWidth - tableWidth;
+		} else dx = rawDx * (ltrSign * (isCenteredRightEdge ? 2 : 1));
+		dx = clamp(dx, Math.min(dxLowerBound, 0), Math.max(dxUpperBound, 0));
+		if (isTableScrollActive && isRightEdge) dx = clamp(applyContainerWidthResistance(tableWidth + dx, containerWidth) - tableWidth, Math.min(dxLowerBound, 0), Math.max(dxUpperBound, 0));
 		if (dx === 0) return;
 		this.editor.editing.view.change((writer) => {
-			const leftColumnWidthAsPercentage = toPrecision((leftColumnWidth + dx) * 100 / tableWidth);
-			writer.setStyle("width", `${leftColumnWidthAsPercentage}%`, viewLeftColumn);
+			const toWidthValue = (widthInPx, basisInPx) => isPixelMode ? `${toPrecision(widthInPx)}px` : `${toPrecision(widthInPx * 100 / basisInPx)}%`;
+			writer.setStyle("width", toWidthValue(leftColumnWidth + dx, tableWidth), viewLeftColumn);
 			if (isRightEdge) {
-				const tableWidthAsPercentage = toPrecision((tableWidth + dx) * 100 / viewFigureParentWidth);
-				writer.setStyle("width", `${tableWidthAsPercentage}%`, viewFigure);
-			} else {
-				const rightColumnWidthAsPercentage = toPrecision((rightColumnWidth - dx) * 100 / tableWidth);
-				writer.setStyle("width", `${rightColumnWidthAsPercentage}%`, viewRightColumn);
-			}
+				const tableFigureWidth = isPixelMode ? `${toPrecision(tableWidth + dx)}px` : `${toPrecision((tableWidth + dx) * 100 / viewFigureParentWidth)}%`;
+				this._setResizingTableWidth(writer, viewFigure, tableFigureWidth);
+			} else writer.setStyle("width", toWidthValue(rightColumnWidth - dx, tableWidth), viewRightColumn);
 		});
 		this._recalculateResizerElement(viewResizer);
 	}
@@ -10598,7 +10963,8 @@ var TableColumnResizeEditing = class extends Plugin {
 	_onMouseUpHandler() {
 		this._initialMouseEventData = null;
 		if (!this._isResizingActive) return;
-		const { viewResizer, modelTable, viewFigure, viewColgroup } = this._resizingData.elements;
+		const { viewResizer, modelTable, viewFigure, viewTable, viewColgroup } = this._resizingData.elements;
+		const { isPixelMode } = this._resizingData.flags;
 		const editor = this.editor;
 		const editingView = editor.editing.view;
 		const tableColumnGroup = this.getColumnGroupElement(modelTable);
@@ -10607,19 +10973,22 @@ var TableColumnResizeEditing = class extends Plugin {
 		const columnWidthsAttributeNew = viewColumns.map((column) => column.getStyle("width"));
 		const isColumnWidthsAttributeChanged = !isEqual(columnWidthsAttributeOld, columnWidthsAttributeNew);
 		const tableWidthAttributeOld = modelTable.getAttribute("tableWidth");
-		const tableWidthAttributeNew = viewFigure.getStyle("width");
+		const tableWidthAttributeNew = this._getResizingTableWidth(viewFigure);
 		const isTableWidthAttributeChanged = tableWidthAttributeOld !== tableWidthAttributeNew;
-		if (isColumnWidthsAttributeChanged || isTableWidthAttributeChanged) if (this._isResizingAllowed) editor.execute("resizeTableWidth", {
-			table: modelTable,
-			tableWidth: `${toPrecision(tableWidthAttributeNew)}%`,
-			columnWidths: columnWidthsAttributeNew
-		});
-		else editingView.change((writer) => {
+		if (isColumnWidthsAttributeChanged || isTableWidthAttributeChanged) if (this._isResizingAllowed) {
+			const tableWidthInPixels = toPrecision(tableWidthAttributeNew);
+			const tableWidthInPixelsBeforeResize = toPrecision(tableWidthAttributeOld);
+			const columnWidths = isPixelMode ? columnWidthsAttributeNew.map((width) => typeof width === "string" && !width.endsWith("px") ? `${toPrecision(parseFloat(width) / 100 * tableWidthInPixelsBeforeResize)}px` : width) : columnWidthsAttributeNew;
+			editor.execute("resizeTableWidth", {
+				table: modelTable,
+				tableWidth: isPixelMode ? `${toPrecision(tableWidthInPixels)}px` : `${toPrecision(tableWidthAttributeNew)}%`,
+				columnWidths
+			});
+		} else editingView.change((writer) => {
 			if (columnWidthsAttributeOld) for (const viewCol of viewColumns) writer.setStyle("width", columnWidthsAttributeOld.shift(), viewCol);
 			else writer.remove(viewColgroup);
-			if (isTableWidthAttributeChanged) if (tableWidthAttributeOld) writer.setStyle("width", tableWidthAttributeOld, viewFigure);
-			else writer.removeStyle("width", viewFigure);
-			if (!columnWidthsAttributeOld && !tableWidthAttributeOld) writer.removeClass("ck-table-resized", [...viewFigure.getChildren()].find((element) => element.name === "table"));
+			if (isTableWidthAttributeChanged) this._setResizingTableWidth(writer, viewFigure, tableWidthAttributeOld || null);
+			if (!columnWidthsAttributeOld && !tableWidthAttributeOld) writer.removeClass("ck-table-resized", viewTable);
 		});
 		editingView.change((writer) => {
 			writer.removeClass("ck-table-column-resizer__active", viewResizer);
@@ -10652,6 +11021,7 @@ var TableColumnResizeEditing = class extends Plugin {
 		const isRightEdge = leftColumnIndex === lastColumnIndex;
 		const isLtrContent = editor.locale.contentLanguageDirection !== "rtl";
 		const isTableCentered = tableAlignment === "center";
+		const isPixelMode = isTableWidthInPixels(modelTable);
 		const viewTable = viewLeftCell.findAncestor("table");
 		const viewFigure = viewTable.findAncestor("figure");
 		const viewColgroup = [...viewTable.getChildren()].find((viewCol) => viewCol.is("element", "colgroup"));
@@ -10662,24 +11032,30 @@ var TableColumnResizeEditing = class extends Plugin {
 		const tableWidth = getTableWidthInPixels(modelTable, editor);
 		const leftColumnWidth = columnWidths[leftColumnIndex];
 		const rightColumnWidth = isRightEdge ? void 0 : columnWidths[leftColumnIndex + 1];
+		const isTableWidthWithinContainerAtDragStart = tableWidth <= getEditableWidth(editor, modelTable.root.rootName);
+		const tableScrollPlugin = editor.plugins.has("TableScrollEditing") ? editor.plugins.get("TableScrollEditing") : null;
 		return {
 			columnPosition,
 			flags: {
 				isRightEdge,
 				isTableCentered,
-				isLtrContent
+				isLtrContent,
+				isPixelMode,
+				isTableWidthWithinContainerAtDragStart,
+				isTableScrollAllowed: !!tableScrollPlugin && tableScrollPlugin._isTableScrollable(modelTable)
 			},
 			elements: {
 				viewResizer,
 				modelTable,
 				viewFigure,
+				viewTable,
 				viewColgroup,
 				viewLeftColumn,
 				viewRightColumn
 			},
 			widths: {
-				viewFigureParentWidth,
 				viewFigureWidth,
+				viewFigureParentWidth,
 				tableWidth,
 				leftColumnWidth,
 				rightColumnWidth
@@ -10700,6 +11076,104 @@ var TableColumnResizeEditing = class extends Plugin {
 		});
 	}
 };
+/**
+* Tells whether the table wrapping the given view `<col>` element is sized in pixels. The width is read from the
+* column's own table (or its wrapping `<figure>`), never from an ancestor further up, so a width-less table nested
+* inside a wider one is not mistaken for a pixel table.
+*/
+function isViewTableWidthInPixels(viewColElement) {
+	const viewTable = viewColElement.findAncestor((element) => element.is("element", "table"));
+	const viewParent = viewTable.parent;
+	const width = (viewParent.is("element", "figure") ? viewParent : viewTable).getStyle("width");
+	return typeof width === "string" && width.trim().endsWith("px");
+}
+/**
+* In the pixel mode keeps the sum of the column widths equal to the table width. If they differ (for example after a
+* manual table width change), the columns are scaled proportionally so that they sum up to the table width. In the
+* percentage mode (or when the columns already sum to the table width) it is a no-op.
+*/
+function scalePixelColumnsToTableWidth(columnWidths, table) {
+	if (!isTableWidthInPixels(table) || !isColumnWidthsInPixels(columnWidths)) return columnWidths;
+	const tableWidthInPixels = parseFloat(table.getAttribute("tableWidth"));
+	const totalWidth = sumArray(columnWidths);
+	if (!totalWidth || Math.abs(totalWidth - tableWidthInPixels) < .5) return columnWidths;
+	const factor = tableWidthInPixels / totalWidth;
+	return columnWidths.map((width) => `${toPrecision(parseFloat(width) * factor)}px`);
+}
+/**
+* Normalizes a pixel-mode column group to concrete pixel widths. It mirrors {@link ~normalizeColumnWidths} (the
+* percentage path): percentages are resolved against the table width, and missing (`auto`/`undefined`) columns are
+* filled from the width left over in the table - so the column group never keeps `auto` widths or mixes units, and
+* downstream arithmetic never sees a non-pixel value.
+*/
+function normalizePixelColumnWidths(columnWidths, table) {
+	const tableWidthInPixels = parseFloat(table.getAttribute("tableWidth"));
+	const pixelWidths = columnWidths.map((width) => {
+		if (width === "auto" || width === void 0) return null;
+		return width.endsWith("%") ? parseFloat(width) / 100 * tableWidthInPixels : parseFloat(width);
+	});
+	const missingColumns = pixelWidths.filter((width) => width === null).length;
+	if (missingColumns) {
+		const knownWidth = pixelWidths.reduce((sum, width) => width === null ? sum : sum + width, 0);
+		const widthForMissingColumn = Math.max((tableWidthInPixels - knownWidth) / missingColumns, 40);
+		return pixelWidths.map((width) => `${toPrecision(width === null ? widthForMissingColumn : width)}px`);
+	}
+	return pixelWidths.map((width) => `${toPrecision(width)}px`);
+}
+/**
+* Applies a column width in the pixel mode: the target column gets the absolute width and the table's own width
+* grows or shrinks to the sum of all column widths.
+*/
+function applyPixelColumnWidths(writer, table, columnIndexes, value) {
+	const columns = getTableColumnElements(table);
+	const tableWidthInPixels = parseFloat(table.getAttribute("tableWidth"));
+	const toPixels = (width) => width.trim().endsWith("%") ? parseFloat(width) / 100 * tableWidthInPixels : parseFloat(width);
+	const targetPixels = Math.max(toPixels(value), 40);
+	const widths = getTableColumnsWidths(table).map(toPixels);
+	for (const index of columnIndexes) widths[index] = targetPixels;
+	const roundedWidths = widths.map((width) => toPrecision(width));
+	columns.forEach((columnElement, index) => {
+		writer.setAttribute("columnWidth", `${roundedWidths[index]}px`, columnElement);
+	});
+	writer.setAttribute("tableWidth", `${toPrecision(sumArray(roundedWidths))}px`, table);
+}
+/**
+* Splits a sorted list of column indexes into maximal contiguous bands, for example `[ 0, 1, 3 ]` into `[ 0, 1 ]`
+* and `[ 3 ]`.
+*/
+function getContiguousBands(columnIndexes) {
+	const bands = [];
+	for (const index of columnIndexes) {
+		const lastBand = bands[bands.length - 1];
+		if (lastBand && index === lastBand.end + 1) {
+			lastBand.indexes.push(index);
+			lastBand.end = index;
+		} else bands.push({
+			indexes: [index],
+			end: index
+		});
+	}
+	return bands;
+}
+/**
+* Given the table width a drag would naturally produce, returns the width that should actually be applied
+* once snapping and growth resistance around the container's width are taken into account:
+*
+*  * if the natural width lands close to the container's width (on either side), it's pulled to exactly
+*    match it,
+*  * if the natural width is past the container's width, it stays pinned at the container's width until the
+*    drag has gone far enough beyond it (the "resistance" zone) - past that point it keeps growing 1:1,
+*    continuing smoothly from where the resistance was overcome instead of jumping,
+*  * shrinking below the container's width is never resisted, only snapped when close.
+*
+* @internal
+*/
+function applyContainerWidthResistance(naturalTableWidth, containerWidth) {
+	const distance = naturalTableWidth - containerWidth;
+	if (distance < 0) return -distance <= 5 ? containerWidth : naturalTableWidth;
+	const resistanceZone = 5 + 10;
+	return distance <= resistanceZone ? containerWidth : containerWidth + (distance - resistanceZone);
+}
 
 /**
 * @license Copyright (c) 2003-2026, CKSource Holding sp. z o.o. All rights reserved.
@@ -10920,7 +11394,9 @@ var TableLayoutEditing = class extends Plugin {
 					}
 				}
 				if (entry.type == "attribute" && entry.attributeKey == "tableType") {
-					for (const item of entry.range.getItems()) if (item.is("element", "table")) {
+					for (const item of entry.range.getItems())
+ /* v8 ignore else -- `tableType` is only ever set on a single `table`, so the range holds no other items. */
+					if (item.is("element", "table")) {
 						editor.model.schema.removeDisallowedAttributes([item], writer);
 						const tableChildren = item.getChildren();
 						for (const child of tableChildren) if (!editor.model.schema.checkChild(item, child)) {
@@ -11736,8 +12212,13 @@ function upcastTableAlignedDiv(defaultValue) {
 				name: true,
 				attributes: "align"
 			})) return;
-			const viewTable = getViewTableFromWrapper(data.viewItem);
-			if (!viewTable || !conversionApi.consumable.test(viewTable, { name: true })) return;
+			const significantChildren = Array.from(data.viewItem.getChildren()).filter((child) => {
+				if (child.is("$text") || child.is("$textProxy")) return child.data.trim() !== "";
+				return true;
+			});
+			if (significantChildren.length !== 1 || !significantChildren[0].is("element", "table")) return;
+			const [viewTable] = significantChildren;
+			if (!conversionApi.consumable.test(viewTable, { name: true })) return;
 			conversionApi.consumable.consume(data.viewItem, {
 				name: true,
 				attributes: "align"
@@ -11757,7 +12238,6 @@ function upcastTableAlignedDiv(defaultValue) {
 			}
 			const align = convertToTableAlignment(data.viewItem.getAttribute("align"), viewTable.getAttribute("align"), getDefaultValueAdjusted(defaultValue, "", data));
 			if (align) conversionApi.writer.setAttribute("tableAlignment", align, modelTable);
-			conversionApi.convertChildren(data.viewItem, conversionApi.writer.createPositionAt(modelTable, "end"));
 			conversionApi.updateConversionResult(modelTable, data);
 		});
 	};
@@ -13076,10 +13556,378 @@ var TableCaption = class extends Plugin {
 	}
 };
 
+/**
+* @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/tablescroll/watchers
+*/
+/**
+* Creates a live collection of all `table` model elements present in the document and keeps it
+* up to date as tables are inserted, moved, or removed.
+*
+* @internal
+*/
+function watchTableModelElements(model) {
+	const tables = new Collection();
+	model.document.on("change", () => {
+		const documentChanges = model.document.differ.getChanges();
+		const insertedTables = /* @__PURE__ */ new Set();
+		const movedTables = /* @__PURE__ */ new Set();
+		for (const change of documentChanges) if (change.type === "insert" && change.name !== "$text" && change.position.nodeAfter) {
+			const range = model.createRangeOn(change.position.nodeAfter);
+			for (const item of range.getItems()) {
+				if (!item.is("element", "table")) continue;
+				if (tables.has(item)) movedTables.add(item);
+				else insertedTables.add(item);
+			}
+		}
+		for (const table of Array.from(tables)) {
+			if (table.root.rootName !== "$graveyard") continue;
+			insertedTables.delete(table);
+			movedTables.delete(table);
+			if (tables.has(table)) tables.remove(table);
+		}
+		for (const table of movedTables)
+ /* v8 ignore else -- @preserve */
+		if (tables.has(table)) tables.remove(table);
+		if (insertedTables.size || movedTables.size) tables.addMany([...insertedTables, ...movedTables]);
+	});
+	return tables;
+}
+/**
+* Observes the DOM width of every editing root and calls `onResize` whenever any of them changes width.
+* Height-only changes are ignored, since only a root's width can make a table overflow it.
+*
+* @internal
+*/
+function watchRootsWidthResize(view, onResize) {
+	const { roots } = view.document;
+	const observedRoots = /* @__PURE__ */ new Map();
+	const lastKnownWidths = /* @__PURE__ */ new Map();
+	const attachRoot = (rootName) => {
+		if (observedRoots.has(rootName)) return;
+		const domRoot = view.getDomRoot(rootName);
+		if (!domRoot) return;
+		const observer = new ResizeObserver((entries) => {
+			for (const entry of entries) {
+				const width = entry.contentRect.width;
+				if (lastKnownWidths.get(rootName) === width) continue;
+				lastKnownWidths.set(rootName, width);
+				onResize();
+			}
+		});
+		observer.observe(domRoot);
+		observedRoots.set(rootName, observer);
+	};
+	const detachRoot = (rootName) => {
+		const observer = observedRoots.get(rootName);
+		if (observer) {
+			observer.disconnect();
+			observedRoots.delete(rootName);
+			lastKnownWidths.delete(rootName);
+		}
+	};
+	const onRootAdd = (evt, viewRoot) => attachRoot(viewRoot.rootName);
+	const onRootRemove = (evt, viewRoot) => detachRoot(viewRoot.rootName);
+	const attachAllRoots = () => {
+		for (const root of roots) attachRoot(root.rootName);
+	};
+	attachAllRoots();
+	roots.on("add", onRootAdd);
+	roots.on("remove", onRootRemove);
+	view.on("render", attachAllRoots);
+	return () => {
+		roots.off("add", onRootAdd);
+		roots.off("remove", onRootRemove);
+		view.off("render", attachAllRoots);
+		for (const observer of observedRoots.values()) observer.disconnect();
+		observedRoots.clear();
+		lastKnownWidths.clear();
+	};
+}
+
+/**
+* @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/tablescroll/tablescrollediting
+*/
+/**
+* The table scrolling editing plugin.
+*/
+var TableScrollEditing = class extends Plugin {
+	/**
+	* Used to listen to native DOM events.
+	*/
+	_domEmitter = new (DomEmitterMixin())();
+	/**
+	* @inheritDoc
+	*/
+	static get pluginName() {
+		return "TableScrollEditing";
+	}
+	/**
+	* @inheritDoc
+	*/
+	static get isOfficialPlugin() {
+		return true;
+	}
+	/**
+	* @inheritDoc
+	*/
+	static get requires() {
+		return [TableEditing];
+	}
+	/**
+	* @inheritDoc
+	*/
+	constructor(editor) {
+		super(editor);
+		editor.config.define("table.tableScroll.tableTypes", ["content"]);
+	}
+	/**
+	* @inheritDoc
+	*/
+	init() {
+		const { editor } = this;
+		const tables = watchTableModelElements(editor.model);
+		this._watchNewTables(tables);
+		this._watchRootEditables(tables);
+		this._registerConversion();
+		this._watchColumnResize();
+		this._watchFiguresScroll();
+	}
+	/**
+	* @inheritDoc
+	*/
+	destroy() {
+		this._domEmitter.stopListening();
+		super.destroy();
+	}
+	/**
+	* Whether a given table may overflow its container and become horizontally scrollable, and whether
+	* column/table resizing is allowed to grow it past the container's width.
+	*
+	* @internal
+	*/
+	_isTableScrollable(table) {
+		if (table.parent !== table.root) return false;
+		const tableType = table.getAttribute("tableType") || "content";
+		return this.editor.config.get("table.tableScroll.tableTypes").includes(tableType);
+	}
+	/**
+	* Determines whether a table overflows its container and applies the corresponding view state:
+	* the `ck-table-overflowing` class on the figure, and the actual (possibly container-exceeding)
+	* width on the inner `<table>` and a sibling `<figcaption>`, if present.
+	*
+	* @internal
+	*/
+	_updateTableScrollOverflowState(table, tableWidthOverride) {
+		const { editor } = this;
+		const containerWidth = getEditableWidth(editor, table.root.rootName);
+		if (containerWidth === null) return;
+		const viewFigure = editor.editing.mapper.toViewElement(table);
+		if (!viewFigure) return;
+		const viewTable = findChildElement(viewFigure, "table");
+		if (!viewTable) return;
+		const viewFigcaption = findChildElement(viewFigure, "figcaption");
+		let tableWidth = null;
+		let hasTableWidthSource = false;
+		if (tableWidthOverride !== void 0) {
+			tableWidth = tableWidthOverride;
+			hasTableWidthSource = true;
+		} else if (table.hasAttribute("tableWidth")) {
+			tableWidth = table.getAttribute("tableWidth");
+			hasTableWidthSource = true;
+		}
+		if (!hasTableWidthSource) return;
+		const isOverflowing = !!tableWidth && this._isTableScrollable(table) && isTableWidthOverflowing(tableWidth, containerWidth);
+		if (isOverflowing) this._scheduleScrollOffsetSync(viewFigure);
+		editor.editing.view.change((writer) => {
+			if (isOverflowing) {
+				writer.removeStyle("width", viewFigure);
+				writer.addClass("ck-table-overflowing", viewFigure);
+				writer.setStyle("width", tableWidth, viewTable);
+				if (viewFigcaption) writer.setStyle("width", tableWidth, viewFigcaption);
+			} else {
+				if (tableWidth) writer.setStyle("width", tableWidth, viewFigure);
+				else writer.removeStyle("width", viewFigure);
+				if (viewFigcaption) writer.removeStyle("width", viewFigcaption);
+				writer.removeClass("ck-table-overflowing", viewFigure);
+				writer.removeStyle("width", viewTable);
+				writer.removeStyle("--ck-table-scroll-offset", viewFigure);
+			}
+		});
+	}
+	/**
+	* Schedules a re-read of the widget figure's actual `scrollLeft` into `--ck-table-scroll-offset`, once
+	* the render reflecting the change that triggered it has actually happened - see the call site for why
+	* this can't just read (and force a reflow for) `scrollLeft` immediately instead.
+	*/
+	_scheduleScrollOffsetSync(viewFigure) {
+		const { view } = this.editor.editing;
+		view.once("render", () => {
+			const domFigure = view.domConverter.mapViewToDom(viewFigure);
+			/* v8 ignore else -- @preserve */
+			if (domFigure) view.change((writer) => {
+				writer.setStyle("--ck-table-scroll-offset", `${domFigure.scrollLeft}px`, viewFigure);
+			});
+		});
+	}
+	/**
+	* Registers editing-only downcast listeners that keep overflow state in sync.
+	*/
+	_registerConversion() {
+		const { editor } = this;
+		editor.conversion.for("editingDowncast").add((dispatcher) => {
+			dispatcher.on("attribute:tableWidth:table", (evt, data) => {
+				this._updateTableScrollOverflowState(data.item, data.attributeNewValue);
+			}, { priority: "low" });
+			dispatcher.on("attribute:tableType:table", (evt, data) => {
+				this._updateTableScrollOverflowState(data.item);
+			}, { priority: "low" });
+			dispatcher.on("insert:caption", (evt, data) => {
+				const modelTable = data.item.parent;
+				if (modelTable?.is("element", "table")) this._updateTableScrollOverflowState(modelTable);
+			}, { priority: "lowest" });
+			dispatcher.on("insert:table", (evt, data) => {
+				this._updateTableScrollOverflowState(data.item);
+			}, { priority: "lowest" });
+		});
+	}
+	/**
+	* Keeps every overflowing table's `--ck-table-scroll-offset` custom property in sync with its
+	* `scrollLeft`, using a single delegated listener instead of one native listener per table.
+	*/
+	_watchFiguresScroll() {
+		const { editor } = this;
+		const { view } = editor.editing;
+		const onScroll = (evt, domEvent) => {
+			const domFigure = domEvent.target;
+			if (!domFigure.classList?.contains("ck-table-overflowing")) return;
+			const viewFigure = view.domConverter.mapDomToView(domFigure);
+			if (!viewFigure) return;
+			view.change((writer) => {
+				writer.setStyle("--ck-table-scroll-offset", `${domFigure.scrollLeft}px`, viewFigure);
+			});
+		};
+		this._domEmitter.listenTo(global.document, "scroll", onScroll, { useCapture: true });
+	}
+	/**
+	* Listen for column resize events and updates proper view element size.
+	*/
+	_watchColumnResize() {
+		const { editor } = this;
+		const { plugins } = editor;
+		if (!plugins.has("TableColumnResizeEditing")) return;
+		const columnResizeEditing = plugins.get("TableColumnResizeEditing");
+		this.listenTo(columnResizeEditing, "_setResizingTableWidth", (evt, [, viewFigure, width]) => {
+			evt.stop();
+			const modelTable = editor.editing.mapper.toModelElement(viewFigure);
+			this._updateTableScrollOverflowState(modelTable, width);
+		}, { priority: "high" });
+		this.listenTo(columnResizeEditing, "_getResizingTableWidth", (evt, [viewFigure]) => {
+			evt.stop();
+			evt.return = getWidthHoldingElement(viewFigure).getStyle("width");
+		}, { priority: "high" });
+	}
+	/**
+	* Re-evaluates the overflow state of every table whenever the window or an editing root is resized.
+	*/
+	_watchRootEditables(tables) {
+		const { editor } = this;
+		const recalculateAll = () => {
+			const resizingTable = getCurrentlyResizingTable(editor);
+			for (const table of tables) {
+				if (table === resizingTable) continue;
+				this._updateTableScrollOverflowState(table);
+			}
+		};
+		const throttledRecalculateAll = throttle(recalculateAll, 100);
+		const stopWatchingRootsResize = watchRootsWidthResize(editor.editing.view, throttledRecalculateAll);
+		editor.ui.view.listenTo(global.window, "resize", throttledRecalculateAll);
+		editor.once("ready", recalculateAll);
+		this.listenTo(editor, "destroy", () => {
+			throttledRecalculateAll.cancel();
+			stopWatchingRootsResize();
+		});
+	}
+	/**
+	* Evaluates the overflow state of every newly inserted table.
+	*/
+	_watchNewTables(tables) {
+		this.listenTo(tables, "change", (evt, data) => {
+			for (const table of data.added) this._updateTableScrollOverflowState(table);
+		});
+	}
+};
+/**
+* Returns the table for which a column resize is currently in progress, if the
+* `TableColumnResizeEditing` plugin is loaded and such a resize is active.
+*/
+function getCurrentlyResizingTable(editor) {
+	const { plugins } = editor;
+	if (!plugins.has("TableColumnResizeEditing")) return null;
+	return plugins.get("TableColumnResizeEditing").resizingTable;
+}
+/**
+* Checks if given table width overflows container width.
+*/
+function isTableWidthOverflowing(tableWidth, containerWidth) {
+	if (tableWidth.endsWith("%")) return parseFloat(tableWidth) > 100;
+	if (tableWidth.endsWith("px")) return parseFloat(tableWidth) > containerWidth;
+	return false;
+}
+/**
+* Returns whichever element - the widget's `<figure>` or its inner `<table>` - currently holds the
+* table's actual (possibly container-exceeding) width: the `<table>` while overflowing, the `<figure>`
+* otherwise.
+*/
+function getWidthHoldingElement(viewFigure) {
+	return viewFigure.hasClass("ck-table-overflowing") ? findChildElement(viewFigure, "table") : viewFigure;
+}
+/**
+* Finds a direct child element of `parent` by its name.
+*/
+function findChildElement(parent, elementName) {
+	return Array.from(parent.getChildren()).find((child) => child.is("element", elementName));
+}
+
+/**
+* @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/tablescroll
+*/
+var TableScroll = class extends Plugin {
+	/**
+	* @inheritDoc
+	*/
+	static get pluginName() {
+		return "TableScroll";
+	}
+	/**
+	* @inheritDoc
+	*/
+	static get isOfficialPlugin() {
+		return true;
+	}
+	/**
+	* @inheritDoc
+	*/
+	static get requires() {
+		return [TableScrollEditing];
+	}
+};
+
 /**
 * @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 { InsertColumnCommand, InsertRowCommand, InsertTableCommand, InsertTableLayoutCommand, MergeCellCommand, MergeCellsCommand, PlainTableOutput, RemoveColumnCommand, RemoveRowCommand, SelectColumnCommand, SelectRowCommand, SetFooterRowCommand, SetHeaderColumnCommand, SetHeaderRowCommand, SplitCellCommand, Table, TableAlignmentCommand, TableBackgroundColorCommand, TableBorderColorCommand, TableBorderStyleCommand, TableBorderWidthCommand, TableCaption, TableCaptionEditing, TableCaptionUI, TableCellBackgroundColorCommand, TableCellBorderColorCommand, TableCellBorderStyleCommand, TableCellBorderWidthCommand, TableCellHeightCommand, TableCellHorizontalAlignmentCommand, TableCellPaddingCommand, TableCellProperties, TableCellPropertiesEditing, TableCellPropertiesUI, TableCellPropertiesView, TableCellPropertyCommand, TableCellTypeCommand, TableCellVerticalAlignmentCommand, TableCellWidthCommand, TableCellWidthEditing, TableClipboard, TableColumnResize, TableColumnResizeEditing, TableEditing, TableHeightCommand, TableKeyboard, TableLayout, TableLayoutEditing, TableLayoutUI, TableMouse, TableProperties, TablePropertiesEditing, TablePropertiesUI, TablePropertiesView, TablePropertyCommand, TableSelection, TableSlot, TableToolbar, TableTypeCommand, TableUI, TableUtils, TableWalker, TableWidthCommand, TableWidthsCommand, ToggleTableCaptionCommand, InsertTableView as _InsertTableView, COLUMN_MIN_WIDTH_AS_PERCENTAGE as _TABLE_COLUMN_MIN_WIDTH_AS_PERCENTAGE, COLUMN_MIN_WIDTH_IN_PIXELS as _TABLE_COLUMN_MIN_WIDTH_IN_PIXELS, COLUMN_RESIZE_DISTANCE_THRESHOLD as _TABLE_COLUMN_RESIZE_DISTANCE_THRESHOLD, COLUMN_WIDTH_PRECISION as _TABLE_COLUMN_WIDTH_PRECISION, defaultColors as _TABLE_DEFAULT_COLORS, ColorInputView as _TableColorInputView, MouseEventsObserver as _TableMouseEventsObserver, addDefaultUnitToNumericValue as _addDefaultUnitToNumericValue, adjustLastColumnIndex as _adjustLastTableColumnIndex, adjustLastRowIndex as _adjustLastTableRowIndex, clamp as _clamp, colorFieldValidator as _colorTableFieldValidator, convertParagraphInTableCell as _convertParagraphInTableCell, createEmptyTableCell as _createEmptyTableCell, createFilledArray as _createFilledArray, cropTableToDimensions as _cropTableToDimensions, downcastTable as _downcastTable, downcastTableAttribute as _downcastTableAttribute, downcastAttributeToStyle as _downcastTableAttributeToStyle, downcastCell as _downcastTableCell, downcastTableResizedClass as _downcastTableResizedClass, downcastRow as _downcastTableRow, enableProperty as _enableTableCellProperty, ensureParagraphInTableCell as _ensureParagraphInTableCell, fillToolbar as _fillTableOrCellToolbar, getBalloonCellPositionData as _getBalloonTableCellPositionData, getBalloonTablePositionData as _getBalloonTablePositionData, getBorderStyleLabels as _getBorderTableStyleLabels, getChangedResizedTables as _getChangedResizedTables, getDefaultValueAdjusted as _getDefaultTableValueAdjusted, getDomCellOuterWidth as _getDomTableCellOuterWidth, getElementWidthInPixels as _getElementWidthInPixels, getHorizontallyOverlappingCells as _getHorizontallyOverlappingTableCells, getLabeledColorInputCreator as _getLabeledTableColorInputCreator, getLocalizedColorErrorText as _getLocalizedTableColorErrorText, getLocalizedLengthErrorText as _getLocalizedTableLengthErrorText, getNormalizedDefaultProperties as _getNormalizedDefaultTableBaseProperties, getNormalizedDefaultCellProperties as _getNormalizedDefaultTableCellProperties, getNormalizedDefaultTableProperties as _getNormalizedDefaultTableProperties, getSelectedTableWidget as _getSelectedTableWidget, getSelectionAffectedTable as _getSelectionAffectedTable, getSelectionAffectedTableWidget as _getSelectionAffectedTableWidget, getSingleValue as _getTableBorderBoxSingleValue, getCaptionFromTableModelElement as _getTableCaptionFromModelElement, getCaptionFromModelSelection as _getTableCaptionFromModelSelection, getColumnEdgesIndexes as _getTableColumnEdgesIndexes, getTableColumnElements as _getTableColumnElements, getColumnGroupElement as _getTableColumnGroupElement, getColumnMinWidthAsPercentage as _getTableColumnMinWidthAsPercentage, getTableColumnsWidths as _getTableColumnsWidths, getBorderStyleDefinitions as _getTableOrCellBorderStyleDefinitions, getTableWidgetAncestor as _getTableWidgetAncestor, getTableWidthInPixels as _getTableWidthInPixels, getVerticallyOverlappingCells as _getVerticallyOverlappingTableCells, injectTableCaptionPostFixer as _injectTableCaptionPostFixer, injectTableCellParagraphPostFixer as _injectTableCellParagraphPostFixer, injectTableLayoutPostFixer as _injectTableLayoutPostFixer, isSingleParagraphWithoutAttributes as _isSingleTableParagraphWithoutAttributes, isHeadingColumnCell as _isTableHeadingColumnCell, isTable as _isTableModelElement, lengthFieldValidator as _lengthTableFieldValidator, lineWidthFieldValidator as _lineWidthTableFieldValidator, matchTableCaptionViewElement as _matchTableCaptionViewElement, normalizeColumnWidths as _normalizeTableColumnWidths, removeEmptyColumns as _removeEmptyTableColumns, removeEmptyRows as _removeEmptyTableRows, removeEmptyRowsColumns as _removeEmptyTableRowsColumns, repositionContextualBalloon as _repositionTableContextualBalloon, skipEmptyTableRow as _skipEmptyTableRow, splitHorizontally as _splitTableCellHorizontally, splitVertically as _splitTableCellVertically, sumArray as _sumArray, tableCellRefreshHandler as _tableCellRefreshHandler, tableStructureRefreshHandler as _tableStructureRefreshHandler, toPrecision as _toPrecision, translateColSpanAttribute as _translateTableColspanAttribute, trimTableCellIfNeeded as _trimTableCellIfNeeded, upcastStyleToAttribute as _upcastNormalizedTableStyleToAttribute, upcastTable as _upcastTable, upcastBorderStyles as _upcastTableBorderStyles, upcastColgroupElement as _upcastTableColgroupElement, upcastTableFigure as _upcastTableFigure, updateColumnElements as _updateTableColumnElements, updateNumericAttribute as _updateTableNumericAttribute, isTableHeaderCellType };
+export { InsertColumnCommand, InsertRowCommand, InsertTableCommand, InsertTableLayoutCommand, MergeCellCommand, MergeCellsCommand, PlainTableOutput, RemoveColumnCommand, RemoveRowCommand, SelectColumnCommand, SelectRowCommand, SetFooterRowCommand, SetHeaderColumnCommand, SetHeaderRowCommand, SplitCellCommand, Table, TableAlignmentCommand, TableBackgroundColorCommand, TableBorderColorCommand, TableBorderStyleCommand, TableBorderWidthCommand, TableCaption, TableCaptionEditing, TableCaptionUI, TableCellBackgroundColorCommand, TableCellBorderColorCommand, TableCellBorderStyleCommand, TableCellBorderWidthCommand, TableCellHeightCommand, TableCellHorizontalAlignmentCommand, TableCellPaddingCommand, TableCellProperties, TableCellPropertiesEditing, TableCellPropertiesUI, TableCellPropertiesView, TableCellPropertyCommand, TableCellTypeCommand, TableCellVerticalAlignmentCommand, TableCellWidthCommand, TableCellWidthEditing, TableClipboard, TableColumnResize, TableColumnResizeEditing, TableColumnWidthCommand, TableEditing, TableHeightCommand, TableKeyboard, TableLayout, TableLayoutEditing, TableLayoutUI, TableMouse, TableProperties, TablePropertiesEditing, TablePropertiesUI, TablePropertiesView, TablePropertyCommand, TableScroll, TableScrollEditing, TableSelection, TableSlot, TableToolbar, TableTypeCommand, TableUI, TableUtils, TableWalker, TableWidthCommand, TableWidthsCommand, ToggleTableCaptionCommand, InsertTableView as _InsertTableView, COLUMN_MIN_WIDTH_AS_PERCENTAGE as _TABLE_COLUMN_MIN_WIDTH_AS_PERCENTAGE, COLUMN_MIN_WIDTH_IN_PIXELS as _TABLE_COLUMN_MIN_WIDTH_IN_PIXELS, COLUMN_RESIZE_DISTANCE_THRESHOLD as _TABLE_COLUMN_RESIZE_DISTANCE_THRESHOLD, COLUMN_WIDTH_PRECISION as _TABLE_COLUMN_WIDTH_PRECISION, defaultColors as _TABLE_DEFAULT_COLORS, ColorInputView as _TableColorInputView, MouseEventsObserver as _TableMouseEventsObserver, addDefaultUnitToNumericValue as _addDefaultUnitToNumericValue, adjustLastColumnIndex as _adjustLastTableColumnIndex, adjustLastRowIndex as _adjustLastTableRowIndex, clamp as _clamp, colorFieldValidator as _colorTableFieldValidator, convertParagraphInTableCell as _convertParagraphInTableCell, createEmptyTableCell as _createEmptyTableCell, createFilledArray as _createFilledArray, cropTableToDimensions as _cropTableToDimensions, downcastTable as _downcastTable, downcastTableAttribute as _downcastTableAttribute, downcastAttributeToStyle as _downcastTableAttributeToStyle, downcastCell as _downcastTableCell, downcastTableResizedClass as _downcastTableResizedClass, downcastRow as _downcastTableRow, enableProperty as _enableTableCellProperty, ensureParagraphInTableCell as _ensureParagraphInTableCell, fillToolbar as _fillTableOrCellToolbar, getBalloonCellPositionData as _getBalloonTableCellPositionData, getBalloonTablePositionData as _getBalloonTablePositionData, getBorderStyleLabels as _getBorderTableStyleLabels, getChangedResizedTables as _getChangedResizedTables, getDefaultValueAdjusted as _getDefaultTableValueAdjusted, getDomCellOuterWidth as _getDomTableCellOuterWidth, getElementWidthInPixels as _getElementWidthInPixels, getHorizontallyOverlappingCells as _getHorizontallyOverlappingTableCells, getLabeledColorInputCreator as _getLabeledTableColorInputCreator, getLocalizedColorErrorText as _getLocalizedTableColorErrorText, getLocalizedLengthErrorText as _getLocalizedTableLengthErrorText, getNormalizedDefaultProperties as _getNormalizedDefaultTableBaseProperties, getNormalizedDefaultCellProperties as _getNormalizedDefaultTableCellProperties, getNormalizedDefaultTableProperties as _getNormalizedDefaultTableProperties, getSelectedTableWidget as _getSelectedTableWidget, getSelectionAffectedTable as _getSelectionAffectedTable, getSelectionAffectedTableWidget as _getSelectionAffectedTableWidget, getSingleValue as _getTableBorderBoxSingleValue, getCaptionFromTableModelElement as _getTableCaptionFromModelElement, getCaptionFromModelSelection as _getTableCaptionFromModelSelection, getColumnEdgesIndexes as _getTableColumnEdgesIndexes, getTableColumnElements as _getTableColumnElements, getColumnGroupElement as _getTableColumnGroupElement, getColumnMinWidthAsPercentage as _getTableColumnMinWidthAsPercentage, getTableColumnsWidths as _getTableColumnsWidths, getBorderStyleDefinitions as _getTableOrCellBorderStyleDefinitions, getTableWidgetAncestor as _getTableWidgetAncestor, getTableWidthInPixels as _getTableWidthInPixels, getVerticallyOverlappingCells as _getVerticallyOverlappingTableCells, injectTableCaptionPostFixer as _injectTableCaptionPostFixer, injectTableCellParagraphPostFixer as _injectTableCellParagraphPostFixer, injectTableLayoutPostFixer as _injectTableLayoutPostFixer, isSingleParagraphWithoutAttributes as _isSingleTableParagraphWithoutAttributes, isHeadingColumnCell as _isTableHeadingColumnCell, isTable as _isTableModelElement, lengthFieldValidator as _lengthTableFieldValidator, lineWidthFieldValidator as _lineWidthTableFieldValidator, matchTableCaptionViewElement as _matchTableCaptionViewElement, normalizeColumnWidths as _normalizeTableColumnWidths, removeEmptyColumns as _removeEmptyTableColumns, removeEmptyRows as _removeEmptyTableRows, removeEmptyRowsColumns as _removeEmptyTableRowsColumns, repositionContextualBalloon as _repositionTableContextualBalloon, skipEmptyTableRow as _skipEmptyTableRow, splitHorizontally as _splitTableCellHorizontally, splitVertically as _splitTableCellVertically, sumArray as _sumArray, tableCellRefreshHandler as _tableCellRefreshHandler, tableStructureRefreshHandler as _tableStructureRefreshHandler, toPrecision as _toPrecision, translateColSpanAttribute as _translateTableColspanAttribute, trimTableCellIfNeeded as _trimTableCellIfNeeded, upcastStyleToAttribute as _upcastNormalizedTableStyleToAttribute, upcastTable as _upcastTable, upcastBorderStyles as _upcastTableBorderStyles, upcastColgroupElement as _upcastTableColgroupElement, upcastTableFigure as _upcastTableFigure, updateColumnElements as _updateTableColumnElements, updateNumericAttribute as _updateTableNumericAttribute, isTableHeaderCellType };
 //# sourceMappingURL=index.js.map