handsontable 18.0.0 → 18.1.0-rc7

package/3rdparty/walkontable/src/table/cellAccess.js

@@ -0,0 +1,238 @@
+/**
+ * Cell / header DOM-access queries for `Table` and every subclass.
+ *
+ * These methods translate between source coordinates and the rendered DOM (finding a `TD`/`TH`, a row,
+ * a header, or the coords for a given element). They are universal — every table type (master and each
+ * overlay clone) needs them — so the mixin is applied once to the base `Table` (`mixin(Table,
+ * cellAccess)` in `table.ts`) and inherited by all subclasses, unlike the axis-selective range-query /
+ * sticky mixins that are applied per subclass. The methods run on the `Table` instance (`this`),
+ * reading its public fields (`THEAD`/`TBODY`/`rowFilter`/`columnFilter`/`wtSettings`/`wot`/
+ * `wtRootElement`). They use no `#`-private state, so no `deps` getter is needed here.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "cellAccess", {
+    enumerable: true,
+    get: function() {
+        return cellAccess;
+    }
+});
+const _element = require("../../../../helpers/dom/element");
+const _object = require("../../../../helpers/object");
+const _errors = require("../../../../helpers/errors");
+const _overlay = require("../overlay");
+const cellAccess = {
+    /**
+   * Returns the TD element for the provided coordinates (from the rendered DOM) if it is rendered on
+   * the screen, or the exit code otherwise (a negative number when the coordinates are out of the
+   * rendered viewport). The exit codes are checked in the order the arguments are given. Thus, if both
+   * the row and the column coords are out of the rendered bounds, the method returns the error code for
+   * the row.
+   *
+   * @param {CellCoords} coords The cell coordinates.
+   * @returns {HTMLElement|number} HTMLElement on success or Number one of the exit codes on error:
+   *  -1 row before viewport
+   *  -2 row after viewport
+   *  -3 column before viewport
+   *  -4 column after viewport.
+   * @this Table
+   */ getCell (coords) {
+        if (coords.row === null || coords.col === null) {
+            return -5;
+        }
+        let row = coords.row;
+        let column = coords.col;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const hookResult = this.wtSettings.getSetting('onModifyGetCellCoords', row, column, !this.isMaster, 'render');
+        if (hookResult && Array.isArray(hookResult)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            [row, column] = hookResult;
+        }
+        if (this.isRowBeforeRenderedRows(row)) {
+            // row before rendered rows
+            return -1;
+        } else if (this.isRowAfterRenderedRows(row)) {
+            // row after rendered rows
+            return -2;
+        } else if (this.isColumnBeforeRenderedColumns(column)) {
+            // column before rendered columns
+            return -3;
+        } else if (this.isColumnAfterRenderedColumns(column)) {
+            // column after rendered columns
+            return -4;
+        }
+        const TR = this.getRow(row);
+        if (!TR && row >= 0) {
+            (0, _errors.throwWithCause)('TR was expected to be rendered but is not');
+        }
+        const trElement = TR !== false ? TR : null;
+        const TD = trElement?.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(column)];
+        if (!TD && column >= 0) {
+            (0, _errors.throwWithCause)('TD or TH was expected to be rendered but is not');
+        }
+        // TD is a TD/TH HTMLElement guaranteed by DOM structure. TypeScript cannot narrow ChildNode
+        // to HTMLElement without instanceof, but adding a throw here would change the existing contract
+        // for negative column (header) lookups where TD may be undefined.
+        return TD;
+    },
+    /**
+   * Get the DOM element of the row with the provided index.
+   *
+   * @param {number} rowIndex Row index.
+   * @returns {HTMLTableRowElement|boolean} Return the row's DOM element or `false` if the row with the
+   * provided index doesn't exist.
+   * @this Table
+   */ getRow (rowIndex) {
+        let renderedRowIndex = null;
+        let parentElement = null;
+        if (rowIndex < 0) {
+            renderedRowIndex = this.rowFilter?.sourceRowToVisibleColHeadedRow(rowIndex);
+            parentElement = this.THEAD;
+        } else {
+            renderedRowIndex = this.rowFilter?.sourceToRendered(rowIndex);
+            parentElement = this.TBODY;
+        }
+        if (renderedRowIndex !== undefined && renderedRowIndex !== null && parentElement !== null) {
+            if (parentElement.childNodes.length < renderedRowIndex + 1) {
+                return false;
+            } else {
+                return parentElement.childNodes[renderedRowIndex];
+            }
+        }
+        return false;
+    },
+    /**
+   * GetColumnHeader.
+   *
+   * @param {number} col Column index.
+   * @param {number} [level=0] Header level (0 = most distant to the table).
+   * @returns {object} HTMLElement on success or undefined on error.
+   * @this Table
+   */ getColumnHeader (col, level = 0) {
+        const TR = this.THEAD.childNodes[level];
+        const TH = TR?.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(col)];
+        return (0, _element.isHTMLElement)(TH) ? TH : undefined;
+    },
+    /**
+   * Gets all columns headers (TH elements) from the table.
+   *
+   * @param {number} column A source column index.
+   * @returns {HTMLTableCellElement[]}
+   * @this Table
+   */ getColumnHeaders (column) {
+        const THs = [];
+        const visibleColumn = this.columnFilter.sourceColumnToVisibleRowHeadedColumn(column);
+        this.THEAD.childNodes.forEach((TR)=>{
+            const TH = TR.childNodes[visibleColumn];
+            if ((0, _element.isHTMLTableCellElement)(TH)) {
+                THs.push(TH);
+            }
+        });
+        return THs;
+    },
+    /**
+   * GetRowHeader.
+   *
+   * @param {number} row Row index.
+   * @param {number} [level=0] Header level (0 = most distant to the table).
+   * @returns {HTMLElement} HTMLElement on success or Number one of the exit codes on error: `null table
+   *   doesn't have row headers`.
+   * @this Table
+   */ getRowHeader (row, level = 0) {
+        const rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
+        if (level >= rowHeadersCount) {
+            return undefined;
+        }
+        const renderedRow = this.rowFilter.sourceToRendered(row);
+        const visibleRow = renderedRow < 0 ? this.rowFilter.sourceRowToVisibleColHeadedRow(row) : renderedRow;
+        const parentElement = renderedRow < 0 ? this.THEAD : this.TBODY;
+        const TR = parentElement?.childNodes[visibleRow];
+        const TH = TR?.childNodes[level];
+        return (0, _element.isHTMLElement)(TH) ? TH : undefined;
+    },
+    /**
+   * Gets all rows headers (TH elements) from the table.
+   *
+   * @param {number} row A source row index.
+   * @returns {HTMLTableCellElement[]}
+   * @this Table
+   */ getRowHeaders (row) {
+        const THs = [];
+        const rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
+        for(let renderedRowIndex = 0; renderedRowIndex < rowHeadersCount; renderedRowIndex++){
+            const TR = this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
+            const TH = TR?.childNodes[renderedRowIndex];
+            if (TH) {
+                THs.push(TH);
+            }
+        }
+        return THs;
+    },
+    /**
+   * Returns cell coords object for a given TD (or a child element of a TD element).
+   *
+   * @param {HTMLTableCellElement} TD A cell DOM element (or a child of one).
+   * @returns {CellCoords|null} The coordinates of the provided TD element (or the closest TD element) or
+   *   null, if the provided element is not applicable.
+   * @this Table
+   */ getCoords (TD) {
+        let cellElement = TD;
+        if (cellElement.nodeName !== 'TD' && cellElement.nodeName !== 'TH') {
+            cellElement = (0, _element.closest)(cellElement, [
+                'TD',
+                'TH'
+            ]);
+        }
+        if (cellElement === null) {
+            return null;
+        }
+        const TR = cellElement.parentNode;
+        if (!TR) {
+            return null;
+        }
+        const CONTAINER = TR.parentNode;
+        if (!CONTAINER) {
+            return null;
+        }
+        let row = (0, _element.isHTMLElement)(TR) ? (0, _element.index)(TR) : 0;
+        let col = (0, _element.isHTMLTableCellElement)(cellElement) ? cellElement.cellIndex : 0;
+        if ((0, _element.overlayContainsElement)(_overlay.CLONE_TOP_INLINE_START_CORNER, cellElement, this.wtRootElement) || (0, _element.overlayContainsElement)(_overlay.CLONE_TOP, cellElement, this.wtRootElement)) {
+            if (CONTAINER.nodeName === 'THEAD') {
+                row -= CONTAINER.childNodes.length;
+            }
+        } else if ((0, _element.overlayContainsElement)(_overlay.CLONE_BOTTOM_INLINE_START_CORNER, cellElement, this.wtRootElement) || (0, _element.overlayContainsElement)(_overlay.CLONE_BOTTOM, cellElement, this.wtRootElement)) {
+            const totalRows = this.wtSettings.getSetting('totalRows');
+            row = totalRows - CONTAINER.childNodes.length + row;
+        } else if (CONTAINER === this.THEAD) {
+            row = this.rowFilter.visibleColHeadedRowToSourceRow(row);
+        } else if (this.rowFilter) {
+            row = this.rowFilter.renderedToSource(row);
+        }
+        if ((0, _element.overlayContainsElement)(_overlay.CLONE_TOP_INLINE_START_CORNER, cellElement, this.wtRootElement) || (0, _element.overlayContainsElement)(_overlay.CLONE_INLINE_START, cellElement, this.wtRootElement) || (0, _element.overlayContainsElement)(_overlay.CLONE_BOTTOM_INLINE_START_CORNER, cellElement, this.wtRootElement)) {
+            col = this.columnFilter.offsettedTH(col);
+        } else if (this.columnFilter) {
+            col = this.columnFilter.visibleRowHeadedColumnToSourceColumn(col);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const hookResult = this.wtSettings.getSetting('onModifyGetCoordsElement', row, col);
+        if (hookResult && Array.isArray(hookResult)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            [row, col] = hookResult;
+        }
+        return this.wot.createCellCoords(row, col);
+    },
+    /**
+   * Returns the TR element for the provided visual row index.
+   *
+   * @param {number} row The visual row index.
+   * @returns {HTMLTableRowElement}
+   * @this Table
+   */ getTrForRow (row) {
+        return this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
+    }
+};
+(0, _object.defineGetter)(cellAccess, 'MIXIN_NAME', 'cellAccess', {
+    writable: false,
+    enumerable: false
+});

package/3rdparty/walkontable/src/table/cellAccess.mjs

@@ -0,0 +1,229 @@
+/**
+ * Cell / header DOM-access queries for `Table` and every subclass.
+ *
+ * These methods translate between source coordinates and the rendered DOM (finding a `TD`/`TH`, a row,
+ * a header, or the coords for a given element). They are universal — every table type (master and each
+ * overlay clone) needs them — so the mixin is applied once to the base `Table` (`mixin(Table,
+ * cellAccess)` in `table.ts`) and inherited by all subclasses, unlike the axis-selective range-query /
+ * sticky mixins that are applied per subclass. The methods run on the `Table` instance (`this`),
+ * reading its public fields (`THEAD`/`TBODY`/`rowFilter`/`columnFilter`/`wtSettings`/`wot`/
+ * `wtRootElement`). They use no `#`-private state, so no `deps` getter is needed here.
+ */ import { index, isHTMLElement, isHTMLTableCellElement, overlayContainsElement, closest } from '../../../../helpers/dom/element.mjs';
+import { defineGetter } from '../../../../helpers/object.mjs';
+import { throwWithCause } from '../../../../helpers/errors.mjs';
+import { CLONE_TOP, CLONE_BOTTOM, CLONE_INLINE_START, CLONE_TOP_INLINE_START_CORNER, CLONE_BOTTOM_INLINE_START_CORNER } from '../overlay/index.mjs';
+const cellAccess = {
+    /**
+   * Returns the TD element for the provided coordinates (from the rendered DOM) if it is rendered on
+   * the screen, or the exit code otherwise (a negative number when the coordinates are out of the
+   * rendered viewport). The exit codes are checked in the order the arguments are given. Thus, if both
+   * the row and the column coords are out of the rendered bounds, the method returns the error code for
+   * the row.
+   *
+   * @param {CellCoords} coords The cell coordinates.
+   * @returns {HTMLElement|number} HTMLElement on success or Number one of the exit codes on error:
+   *  -1 row before viewport
+   *  -2 row after viewport
+   *  -3 column before viewport
+   *  -4 column after viewport.
+   * @this Table
+   */ getCell (coords) {
+        if (coords.row === null || coords.col === null) {
+            return -5;
+        }
+        let row = coords.row;
+        let column = coords.col;
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const hookResult = this.wtSettings.getSetting('onModifyGetCellCoords', row, column, !this.isMaster, 'render');
+        if (hookResult && Array.isArray(hookResult)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            [row, column] = hookResult;
+        }
+        if (this.isRowBeforeRenderedRows(row)) {
+            // row before rendered rows
+            return -1;
+        } else if (this.isRowAfterRenderedRows(row)) {
+            // row after rendered rows
+            return -2;
+        } else if (this.isColumnBeforeRenderedColumns(column)) {
+            // column before rendered columns
+            return -3;
+        } else if (this.isColumnAfterRenderedColumns(column)) {
+            // column after rendered columns
+            return -4;
+        }
+        const TR = this.getRow(row);
+        if (!TR && row >= 0) {
+            throwWithCause('TR was expected to be rendered but is not');
+        }
+        const trElement = TR !== false ? TR : null;
+        const TD = trElement?.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(column)];
+        if (!TD && column >= 0) {
+            throwWithCause('TD or TH was expected to be rendered but is not');
+        }
+        // TD is a TD/TH HTMLElement guaranteed by DOM structure. TypeScript cannot narrow ChildNode
+        // to HTMLElement without instanceof, but adding a throw here would change the existing contract
+        // for negative column (header) lookups where TD may be undefined.
+        return TD;
+    },
+    /**
+   * Get the DOM element of the row with the provided index.
+   *
+   * @param {number} rowIndex Row index.
+   * @returns {HTMLTableRowElement|boolean} Return the row's DOM element or `false` if the row with the
+   * provided index doesn't exist.
+   * @this Table
+   */ getRow (rowIndex) {
+        let renderedRowIndex = null;
+        let parentElement = null;
+        if (rowIndex < 0) {
+            renderedRowIndex = this.rowFilter?.sourceRowToVisibleColHeadedRow(rowIndex);
+            parentElement = this.THEAD;
+        } else {
+            renderedRowIndex = this.rowFilter?.sourceToRendered(rowIndex);
+            parentElement = this.TBODY;
+        }
+        if (renderedRowIndex !== undefined && renderedRowIndex !== null && parentElement !== null) {
+            if (parentElement.childNodes.length < renderedRowIndex + 1) {
+                return false;
+            } else {
+                return parentElement.childNodes[renderedRowIndex];
+            }
+        }
+        return false;
+    },
+    /**
+   * GetColumnHeader.
+   *
+   * @param {number} col Column index.
+   * @param {number} [level=0] Header level (0 = most distant to the table).
+   * @returns {object} HTMLElement on success or undefined on error.
+   * @this Table
+   */ getColumnHeader (col, level = 0) {
+        const TR = this.THEAD.childNodes[level];
+        const TH = TR?.childNodes[this.columnFilter.sourceColumnToVisibleRowHeadedColumn(col)];
+        return isHTMLElement(TH) ? TH : undefined;
+    },
+    /**
+   * Gets all columns headers (TH elements) from the table.
+   *
+   * @param {number} column A source column index.
+   * @returns {HTMLTableCellElement[]}
+   * @this Table
+   */ getColumnHeaders (column) {
+        const THs = [];
+        const visibleColumn = this.columnFilter.sourceColumnToVisibleRowHeadedColumn(column);
+        this.THEAD.childNodes.forEach((TR)=>{
+            const TH = TR.childNodes[visibleColumn];
+            if (isHTMLTableCellElement(TH)) {
+                THs.push(TH);
+            }
+        });
+        return THs;
+    },
+    /**
+   * GetRowHeader.
+   *
+   * @param {number} row Row index.
+   * @param {number} [level=0] Header level (0 = most distant to the table).
+   * @returns {HTMLElement} HTMLElement on success or Number one of the exit codes on error: `null table
+   *   doesn't have row headers`.
+   * @this Table
+   */ getRowHeader (row, level = 0) {
+        const rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
+        if (level >= rowHeadersCount) {
+            return undefined;
+        }
+        const renderedRow = this.rowFilter.sourceToRendered(row);
+        const visibleRow = renderedRow < 0 ? this.rowFilter.sourceRowToVisibleColHeadedRow(row) : renderedRow;
+        const parentElement = renderedRow < 0 ? this.THEAD : this.TBODY;
+        const TR = parentElement?.childNodes[visibleRow];
+        const TH = TR?.childNodes[level];
+        return isHTMLElement(TH) ? TH : undefined;
+    },
+    /**
+   * Gets all rows headers (TH elements) from the table.
+   *
+   * @param {number} row A source row index.
+   * @returns {HTMLTableCellElement[]}
+   * @this Table
+   */ getRowHeaders (row) {
+        const THs = [];
+        const rowHeadersCount = this.wtSettings.getSetting('rowHeaders').length;
+        for(let renderedRowIndex = 0; renderedRowIndex < rowHeadersCount; renderedRowIndex++){
+            const TR = this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
+            const TH = TR?.childNodes[renderedRowIndex];
+            if (TH) {
+                THs.push(TH);
+            }
+        }
+        return THs;
+    },
+    /**
+   * Returns cell coords object for a given TD (or a child element of a TD element).
+   *
+   * @param {HTMLTableCellElement} TD A cell DOM element (or a child of one).
+   * @returns {CellCoords|null} The coordinates of the provided TD element (or the closest TD element) or
+   *   null, if the provided element is not applicable.
+   * @this Table
+   */ getCoords (TD) {
+        let cellElement = TD;
+        if (cellElement.nodeName !== 'TD' && cellElement.nodeName !== 'TH') {
+            cellElement = closest(cellElement, [
+                'TD',
+                'TH'
+            ]);
+        }
+        if (cellElement === null) {
+            return null;
+        }
+        const TR = cellElement.parentNode;
+        if (!TR) {
+            return null;
+        }
+        const CONTAINER = TR.parentNode;
+        if (!CONTAINER) {
+            return null;
+        }
+        let row = isHTMLElement(TR) ? index(TR) : 0;
+        let col = isHTMLTableCellElement(cellElement) ? cellElement.cellIndex : 0;
+        if (overlayContainsElement(CLONE_TOP_INLINE_START_CORNER, cellElement, this.wtRootElement) || overlayContainsElement(CLONE_TOP, cellElement, this.wtRootElement)) {
+            if (CONTAINER.nodeName === 'THEAD') {
+                row -= CONTAINER.childNodes.length;
+            }
+        } else if (overlayContainsElement(CLONE_BOTTOM_INLINE_START_CORNER, cellElement, this.wtRootElement) || overlayContainsElement(CLONE_BOTTOM, cellElement, this.wtRootElement)) {
+            const totalRows = this.wtSettings.getSetting('totalRows');
+            row = totalRows - CONTAINER.childNodes.length + row;
+        } else if (CONTAINER === this.THEAD) {
+            row = this.rowFilter.visibleColHeadedRowToSourceRow(row);
+        } else if (this.rowFilter) {
+            row = this.rowFilter.renderedToSource(row);
+        }
+        if (overlayContainsElement(CLONE_TOP_INLINE_START_CORNER, cellElement, this.wtRootElement) || overlayContainsElement(CLONE_INLINE_START, cellElement, this.wtRootElement) || overlayContainsElement(CLONE_BOTTOM_INLINE_START_CORNER, cellElement, this.wtRootElement)) {
+            col = this.columnFilter.offsettedTH(col);
+        } else if (this.columnFilter) {
+            col = this.columnFilter.visibleRowHeadedColumnToSourceColumn(col);
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const hookResult = this.wtSettings.getSetting('onModifyGetCoordsElement', row, col);
+        if (hookResult && Array.isArray(hookResult)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            [row, col] = hookResult;
+        }
+        return this.wot.createCellCoords(row, col);
+    },
+    /**
+   * Returns the TR element for the provided visual row index.
+   *
+   * @param {number} row The visual row index.
+   * @returns {HTMLTableRowElement}
+   * @this Table
+   */ getTrForRow (row) {
+        return this.TBODY.childNodes[this.rowFilter.sourceToRendered(row)];
+    }
+};
+defineGetter(cellAccess, 'MIXIN_NAME', 'cellAccess', {
+    writable: false,
+    enumerable: false
+});
+export { cellAccess };

package/3rdparty/walkontable/src/table/domScaffold.d.mts

@@ -0,0 +1 @@
+export * from './domScaffold.js';

package/3rdparty/walkontable/src/table/domScaffold.d.ts

@@ -0,0 +1,37 @@
+import type { default as Table } from './baseTable';
+/**
+ * Construction-time DOM scaffolding, mixed into every `Table` type.
+ */
+export interface DomScaffold {
+    fixTableDomTree(): void;
+    createSpreader(table: HTMLTableElement): HTMLElement | undefined;
+    createHider(spreader: HTMLElement): HTMLElement | undefined;
+    createHolder(hider: HTMLElement): HTMLElement | undefined;
+}
+declare const domScaffold: {
+    /**
+     * Ensures the table has `tbody`, `thead`, and `colgroup` sections, creating any that are missing.
+     *
+     * @this Table
+     */
+    fixTableDomTree(this: Table): void;
+    /**
+     * @param {HTMLTableElement} table An element to process.
+     * @returns {HTMLElement}
+     * @this Table
+     */
+    createSpreader(this: Table, table: HTMLTableElement): HTMLElement | undefined;
+    /**
+     * @param {HTMLElement} spreader An element to the hider element is injected.
+     * @returns {HTMLElement}
+     * @this Table
+     */
+    createHider(this: Table, spreader: HTMLElement): HTMLElement | undefined;
+    /**
+     * @param {HTMLElement} hider An element to the holder element is injected.
+     * @returns {HTMLElement}
+     * @this Table
+     */
+    createHolder(this: Table, hider: HTMLElement): HTMLElement | undefined;
+};
+export { domScaffold };

package/3rdparty/walkontable/src/table/domScaffold.js

@@ -0,0 +1,145 @@
+/**
+ * Construction-time DOM scaffolding for `Table` and every subclass.
+ *
+ * These methods build the wrapper DOM the engine renders into — the `wtSpreader` / `wtHider` /
+ * `wtHolder` wrapper chain around the `<table>`, and the `thead`/`tbody`/`colgroup` sections. They run
+ * once from the `Table` constructor. They are universal (every table type needs them), so the mixin is
+ * applied once to the base `Table` (`mixin(Table, domScaffold)` in `table.ts`) and inherited by all
+ * subclasses. The methods run on the `Table` instance (`this`), assigning its public fields
+ * (`TABLE`/`THEAD`/`TBODY`/`COLGROUP`) and reading the settings. They reach the injected deps through
+ * the read-only `this.deps` getter, since a mixin cannot see the class's `#deps` private field.
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "domScaffold", {
+    enumerable: true,
+    get: function() {
+        return domScaffold;
+    }
+});
+const _element = require("../../../../helpers/dom/element");
+const _a11y = require("../../../../helpers/a11y");
+const _object = require("../../../../helpers/object");
+const domScaffold = {
+    /**
+   * Ensures the table has `tbody`, `thead`, and `colgroup` sections, creating any that are missing.
+   *
+   * @this Table
+   */ fixTableDomTree () {
+        const rootDocument = this.deps.rootDocument;
+        this.TBODY = this.TABLE.querySelector('tbody');
+        if (!this.TBODY) {
+            this.TBODY = rootDocument.createElement('tbody');
+            this.TABLE.appendChild(this.TBODY);
+        }
+        this.THEAD = this.TABLE.querySelector('thead');
+        if (!this.THEAD) {
+            this.THEAD = rootDocument.createElement('thead');
+            this.TABLE.insertBefore(this.THEAD, this.TBODY);
+        }
+        this.COLGROUP = this.TABLE.querySelector('colgroup');
+        if (!this.COLGROUP) {
+            this.COLGROUP = rootDocument.createElement('colgroup');
+            this.TABLE.insertBefore(this.COLGROUP, this.THEAD);
+        }
+    },
+    /**
+   * @param {HTMLTableElement} table An element to process.
+   * @returns {HTMLElement}
+   * @this Table
+   */ createSpreader (table) {
+        const parent = table.parentNode;
+        let spreader;
+        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.isHTMLElement)(parent) || !(0, _element.hasClass)(parent, 'wtHolder')) {
+            spreader = this.deps.rootDocument.createElement('div');
+            spreader.className = 'wtSpreader';
+            if (parent) {
+                // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
+                table.before(spreader);
+            }
+            spreader.appendChild(table);
+        }
+        if (spreader) {
+            spreader.style.position = 'relative';
+            if (this.wtSettings.getSetting('ariaTags')) {
+                (0, _element.setAttribute)(spreader, [
+                    (0, _a11y.A11Y_PRESENTATION)()
+                ]);
+            }
+        }
+        return spreader;
+    },
+    /**
+   * @param {HTMLElement} spreader An element to the hider element is injected.
+   * @returns {HTMLElement}
+   * @this Table
+   */ createHider (spreader) {
+        const parent = spreader.parentNode;
+        let hider;
+        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.isHTMLElement)(parent) || !(0, _element.hasClass)(parent, 'wtHolder')) {
+            hider = this.deps.rootDocument.createElement('div');
+            hider.className = 'wtHider';
+            if (parent) {
+                // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
+                spreader.before(hider);
+            }
+            hider.appendChild(spreader);
+        }
+        if (hider && this.wtSettings.getSetting('ariaTags')) {
+            (0, _element.setAttribute)(hider, [
+                (0, _a11y.A11Y_PRESENTATION)()
+            ]);
+        }
+        return hider;
+    },
+    /**
+   * @param {HTMLElement} hider An element to the holder element is injected.
+   * @returns {HTMLElement}
+   * @this Table
+   */ createHolder (hider) {
+        const parent = hider.parentNode;
+        let holder;
+        if (!parent || parent.nodeType !== Node.ELEMENT_NODE || !(0, _element.isHTMLElement)(parent) || !(0, _element.hasClass)(parent, 'wtHolder')) {
+            holder = this.deps.rootDocument.createElement('div');
+            holder.style.position = 'relative';
+            holder.className = 'wtHolder';
+            if (this.isMaster) {
+                (0, _element.setAttribute)(holder, [
+                    (0, _a11y.A11Y_TABINDEX)(-1)
+                ]);
+            }
+            if (parent) {
+                // if TABLE is detached (e.g. in Jasmine test), it has no parentNode so we cannot attach holder to it
+                hider.before(holder);
+            }
+            if (this.isMaster) {
+                const holderParent = holder.parentNode;
+                // holderParent is null when TABLE is detached (e.g. in Jasmine tests); skip class assignment in that case.
+                // isHTMLElement() is used instead of `instanceof HTMLElement` because the latter fails in
+                // cross-frame contexts (e.g. when HoT is mounted inside an <iframe> via React portals):
+                // the iframe's HTMLElement constructor !== the parent frame's HTMLElement.
+                if ((0, _element.isHTMLElement)(holderParent)) {
+                    holderParent.className += 'ht_master handsontable';
+                    holderParent.setAttribute('dir', this.wtSettings.getSettingPure('rtlMode') ? 'rtl' : 'ltr');
+                    if (this.wtSettings.getSetting('ariaTags')) {
+                        (0, _element.setAttribute)(holderParent, [
+                            (0, _a11y.A11Y_PRESENTATION)()
+                        ]);
+                    }
+                }
+            }
+            holder.appendChild(hider);
+        }
+        if (holder && this.wtSettings.getSetting('ariaTags')) {
+            (0, _element.setAttribute)(holder, [
+                (0, _a11y.A11Y_PRESENTATION)()
+            ]);
+        }
+        return holder;
+    }
+};
+(0, _object.defineGetter)(domScaffold, 'MIXIN_NAME', 'domScaffold', {
+    writable: false,
+    enumerable: false
+});