@progress/kendo-editor-common 1.11.9-dev.202412020819 → 1.11.9-develop.2

package/dist/es/plugins/table-resize/table-resize.js

@@ -1,51 +1,58 @@
-import { __assign } from "tslib";
-import { NodeSelection, Plugin } from 'prosemirror-state';
-import { colgroupAttr, dataResizeDirTable, resizableAttr } from '../../config/constants';
-import { getTable, tableResizeKey as key } from './utils';
-import { parseStyle, setNodeStyle, parentNode } from './../../utils';
-import { directions } from './../resize-utils';
-var commonDir = {
+import { Plugin, NodeSelection } from 'prosemirror-state';
+import { resizableAttr, dataResizeDirTable, colgroupAttr } from '../../config/constants.js';
+import { tableResizeKey, getTable } from './utils.js';
+import { parentNode, parseStyle, setNodeStyle } from '../../utils.js';
+import { directions } from '../resize-utils.js';
+
+const commonDir = {
     'southeast': true,
     'southwest': true,
     'northwest': true,
     'northeast': true
 };
-var horizontalDir = __assign({ 'east': true, 'west': true }, commonDir);
-var verticalDir = __assign({ 'south': true, 'north': true }, commonDir);
-var ResizeState = /** @class */ (function () {
-    function ResizeState(activeHandle, dragging, nodePosition) {
+const horizontalDir = {
+    'east': true,
+    'west': true,
+    ...commonDir
+};
+const verticalDir = {
+    'south': true,
+    'north': true,
+    ...commonDir
+};
+class ResizeState {
+    constructor(activeHandle, dragging, nodePosition) {
         this.activeHandle = activeHandle;
         this.dragging = dragging;
         this.nodePosition = nodePosition;
     }
-    ResizeState.prototype.apply = function (tr) {
-        var next = tr.getMeta(key);
+    apply(tr) {
+        const next = tr.getMeta(tableResizeKey);
         if (next) {
-            var nextState = new ResizeState(next.activeHandle, next.setDragging, next.nodePosition);
+            const nextState = new ResizeState(next.activeHandle, next.setDragging, next.nodePosition);
             return nextState;
         }
         return this;
-    };
-    return ResizeState;
-}());
-var handleMouseMove = function (view, event) {
+    }
+}
+const handleMouseMove = (view, event) => {
     var _a;
-    var state = key.getState(view.state);
-    var dragging = state.dragging, nodePosition = state.nodePosition, activeHandle = state.activeHandle;
+    const state = tableResizeKey.getState(view.state);
+    const { dragging, nodePosition, activeHandle } = state;
     if (nodePosition < 0 || !dragging) {
         return;
     }
-    var tableDom = getTable(view.nodeDOM(nodePosition));
-    var rect = tableDom.getBoundingClientRect();
-    var dir = directions[activeHandle];
-    var diffX = (event.clientX - dragging.startX) * dir.x;
-    var diffY = (event.clientY - dragging.startY) * dir.y;
-    var win = (tableDom.ownerDocument && tableDom.ownerDocument.defaultView) || window;
-    var compStyles = win.getComputedStyle(tableDom);
-    var nodeWidth = /px/.test(compStyles.width) ? parseFloat(compStyles.width) : tableDom.offsetWidth;
-    var nodeHeight = /px/.test(compStyles.height) ? parseFloat(compStyles.height) : tableDom.offsetHeight;
-    var width = dir.x ? diffX + nodeWidth : rect.width;
-    var height = dir.y ? diffY + nodeHeight : rect.height;
+    const tableDom = getTable(view.nodeDOM(nodePosition));
+    const rect = tableDom.getBoundingClientRect();
+    const dir = directions[activeHandle];
+    const diffX = (event.clientX - dragging.startX) * dir.x;
+    const diffY = (event.clientY - dragging.startY) * dir.y;
+    const win = (tableDom.ownerDocument && tableDom.ownerDocument.defaultView) || window;
+    const compStyles = win.getComputedStyle(tableDom);
+    const nodeWidth = /px/.test(compStyles.width) ? parseFloat(compStyles.width) : tableDom.offsetWidth;
+    const nodeHeight = /px/.test(compStyles.height) ? parseFloat(compStyles.height) : tableDom.offsetHeight;
+    const width = dir.x ? diffX + nodeWidth : rect.width;
+    const height = dir.y ? diffY + nodeHeight : rect.height;
     dragging.startX = dir.x ? event.clientX : dragging.startX;
     dragging.startY = dir.y ? event.clientY : dragging.startY;
     if (horizontalDir[activeHandle]) {
@@ -55,34 +62,34 @@ var handleMouseMove = function (view, event) {
         tableDom.style.height = height + 'px';
     }
     if (/px/.test(tableDom.style.width)) {
-        var wrapper = (_a = tableDom.parentNode) === null || _a === void 0 ? void 0 : _a.parentNode;
+        const wrapper = (_a = tableDom.parentNode) === null || _a === void 0 ? void 0 : _a.parentNode;
         if (wrapper instanceof HTMLDivElement && wrapper.matches('div[table]') && /%/.test(wrapper.style.width)) {
             wrapper.style.width = '';
         }
     }
 };
-var toPercents = function (view, tr, tablePos) {
-    var tableNode = view.state.doc.nodeAt(tablePos);
-    var tableDom = getTable(view.nodeDOM(tablePos));
-    var _a = tableSize(tableDom), width = _a.width, height = _a.height, colsWidth = _a.colsWidth, rowsHeight = _a.rowsHeight, offsetWidth = _a.offsetWidth, offsetHeight = _a.offsetHeight;
-    var colgroup = tableDom.firstChild;
-    var cols = Array.from((colgroup && colgroup.children) || []);
-    var widthChanged = false;
-    cols.forEach(function (col, i) {
+const toPercents = (view, tr, tablePos) => {
+    const tableNode = view.state.doc.nodeAt(tablePos);
+    const tableDom = getTable(view.nodeDOM(tablePos));
+    const { width, height, colsWidth, rowsHeight, offsetWidth, offsetHeight } = tableSize(tableDom);
+    const colgroup = tableDom.firstChild;
+    const cols = Array.from((colgroup && colgroup.children) || []);
+    let widthChanged = false;
+    cols.forEach((col, i) => {
         if (col.style.width && !/%$/.test(col.style.width)) {
             col.style.width = ((colsWidth[i]) * 100 / width) + '%';
             widthChanged = true;
         }
     });
-    var heightChange = false;
-    tableNode.forEach(function (row, offset, index) {
-        var rowHeight = parseStyle(row.attrs.style).height;
+    let heightChange = false;
+    tableNode.forEach((row, offset, index) => {
+        const rowHeight = parseStyle(row.attrs.style).height;
         if (rowHeight && !/%$/.test(rowHeight)) {
             tr.setNodeMarkup(tablePos + offset + 1, null, setNodeStyle(row.attrs, 'height', (rowsHeight[index] * 100 / height) + '%'));
             heightChange = true;
         }
     });
-    var tableAttrs = tableNode.attrs;
+    let tableAttrs = tableNode.attrs;
     if (parseStyle(tableAttrs.style).width !== offsetWidth + 'px') {
         tableAttrs = setNodeStyle(tableAttrs, 'width', offsetWidth + 'px');
     }
@@ -96,55 +103,55 @@ var toPercents = function (view, tr, tablePos) {
         tr.setNodeMarkup(tablePos, null, tableAttrs);
     }
 };
-var toPixels = function (view, tr, tablePos, attrs) {
-    var tableNode = view.state.doc.nodeAt(tablePos);
-    var tableDom = getTable(view.nodeDOM(tablePos));
-    var win = (tableDom.ownerDocument && tableDom.ownerDocument.defaultView) || window;
-    var calcStyle = win.getComputedStyle;
-    var rows = Array.from(tableDom.rows);
-    tableNode.forEach(function (row, offset, index) {
-        var rowHeight = parseStyle(row.attrs.style).height;
+const toPixels = (view, tr, tablePos, attrs) => {
+    const tableNode = view.state.doc.nodeAt(tablePos);
+    const tableDom = getTable(view.nodeDOM(tablePos));
+    const win = (tableDom.ownerDocument && tableDom.ownerDocument.defaultView) || window;
+    const calcStyle = win.getComputedStyle;
+    const rows = Array.from(tableDom.rows);
+    tableNode.forEach((row, offset, index) => {
+        const rowHeight = parseStyle(row.attrs.style).height;
         if (rowHeight && !/px$/.test(rowHeight)) {
             tr.setNodeMarkup(tablePos + offset + 1, null, setNodeStyle(row.attrs, 'height', calcStyle(rows[index]).height));
         }
     });
-    var colgroup = tableDom.firstChild;
-    var cols = Array.from((colgroup && colgroup.children) || []);
-    var widthChanged = false;
-    cols.forEach(function (col, i) {
+    const colgroup = tableDom.firstChild;
+    const cols = Array.from((colgroup && colgroup.children) || []);
+    let widthChanged = false;
+    cols.forEach((col, i) => {
         if (col.style.width && !/px$/.test(col.style.width)) {
             col.style.width = calcStyle(cols[i]).width;
             widthChanged = true;
         }
     });
-    var tableAttrs = __assign({}, attrs);
+    const tableAttrs = { ...attrs };
     if (widthChanged) {
         tableAttrs[colgroupAttr] = colgroup.outerHTML;
     }
     return tableAttrs;
 };
-var tableSize = function (table) {
-    var cols = Array.from(table.firstChild.children);
-    var colsWidth = cols.map(function (c) { return c.offsetWidth; });
-    var rowsHeight = Array.from(table.rows).map(function (row) { return row.offsetHeight; });
-    var width = colsWidth.reduce(function (acc, cur) { return acc + cur; }, 0);
-    var height = rowsHeight.reduce(function (acc, cur) { return acc + cur; }, 0);
-    var offsetHeight = table.offsetHeight;
-    var offsetWidth = table.offsetWidth;
-    return { width: width, height: height, colsWidth: colsWidth, rowsHeight: rowsHeight, offsetWidth: offsetWidth, offsetHeight: offsetHeight };
+const tableSize = (table) => {
+    const cols = Array.from(table.firstChild.children);
+    const colsWidth = cols.map(c => c.offsetWidth);
+    const rowsHeight = Array.from(table.rows).map(row => row.offsetHeight);
+    const width = colsWidth.reduce((acc, cur) => acc + cur, 0);
+    const height = rowsHeight.reduce((acc, cur) => acc + cur, 0);
+    const offsetHeight = table.offsetHeight;
+    const offsetWidth = table.offsetWidth;
+    return { width, height, colsWidth, rowsHeight, offsetWidth, offsetHeight };
 };
-var handleMouseUp = function (view) {
-    var _a = key.getState(view.state), dragging = _a.dragging, nodePosition = _a.nodePosition, activeHandle = _a.activeHandle;
+const handleMouseUp = (view) => {
+    const { dragging, nodePosition, activeHandle } = tableResizeKey.getState(view.state);
     if (dragging) {
-        var node = view.state.doc.nodeAt(nodePosition);
-        var dom = getTable(view.nodeDOM(nodePosition));
-        var rect = tableSize(dom);
+        const node = view.state.doc.nodeAt(nodePosition);
+        const dom = getTable(view.nodeDOM(nodePosition));
+        const rect = tableSize(dom);
         if (node) {
-            var width = rect.offsetWidth + 'px';
-            var height = rect.offsetHeight + 'px';
-            var tr = view.state.tr;
-            var attrs = node.attrs;
-            var parsedStyles = parseStyle(attrs.style);
+            const width = rect.offsetWidth + 'px';
+            const height = rect.offsetHeight + 'px';
+            const tr = view.state.tr;
+            let attrs = node.attrs;
+            const parsedStyles = parseStyle(attrs.style);
             if (horizontalDir[activeHandle] && dom.style.width && parsedStyles.width !== width) {
                 attrs = setNodeStyle(attrs, 'width', width);
             }
@@ -155,17 +162,17 @@ var handleMouseUp = function (view) {
             tr.setNodeMarkup(nodePosition, null, attrs);
             tr.setMeta('commandName', 'node-resize');
             tr.setMeta('args', attrs);
-            tr.setMeta(key, {
+            tr.setMeta(tableResizeKey, {
                 setDragging: null,
                 activeHandle: null,
-                nodePosition: nodePosition
+                nodePosition
             });
             if (!/%/.test(parseStyle(attrs.style).width || '')) {
-                var $pos = tr.doc.resolve(nodePosition);
-                var wrapper = parentNode($pos, function (n) { return n.type.name === 'table_wrapper'; });
+                const $pos = tr.doc.resolve(nodePosition);
+                const wrapper = parentNode($pos, n => n.type.name === 'table_wrapper');
                 if (wrapper && /%/.test(parseStyle(wrapper.node.attrs.style).width || '')) {
-                    var wrapperAttrs = setNodeStyle(wrapper.node.attrs, 'width', '');
-                    var wrapperPos = $pos.start(wrapper.depth) - 1;
+                    const wrapperAttrs = setNodeStyle(wrapper.node.attrs, 'width', '');
+                    const wrapperPos = $pos.start(wrapper.depth) - 1;
                     tr.setNodeMarkup(wrapperPos, null, wrapperAttrs);
                 }
             }
@@ -173,24 +180,24 @@ var handleMouseUp = function (view) {
         }
     }
 };
-var handleMouseDown = function (view, event) {
-    var target = event.target;
-    var activeHandle = target.getAttribute(dataResizeDirTable);
+const handleMouseDown = (view, event) => {
+    const target = event.target;
+    const activeHandle = target.getAttribute(dataResizeDirTable);
     if (!activeHandle) {
         return false;
     }
-    var resizeState = key.getState(view.state);
+    const resizeState = tableResizeKey.getState(view.state);
     event.preventDefault();
-    var transaction = view.state.tr;
-    transaction.setMeta(key, {
+    const transaction = view.state.tr;
+    transaction.setMeta(tableResizeKey, {
         setDragging: { startX: event.clientX, startY: event.clientY },
-        activeHandle: activeHandle,
+        activeHandle,
         nodePosition: resizeState.nodePosition
     });
     transaction.setMeta('addToHistory', false);
     toPercents(view, transaction, resizeState.nodePosition);
     view.dispatch(transaction);
-    var curWindow = event.view || window;
+    const curWindow = event.view || window;
     function move(e) {
         handleMouseMove(view, e);
     }
@@ -203,77 +210,77 @@ var handleMouseDown = function (view, event) {
     curWindow.addEventListener('mousemove', move);
     return true;
 };
-export var tableResizing = function (options) {
-    if (options === void 0) { options = { node: 'table' }; }
+const tableResizing = (options = { node: 'table' }) => {
     return new Plugin({
-        key: key,
-        view: function () { return ({
-            selectedNode: function (state, nodeType) {
-                var selection = state.selection;
-                var isNodeSelected = selection instanceof NodeSelection && nodeType === selection.node.type;
+        key: tableResizeKey,
+        view: () => ({
+            selectedNode(state, nodeType) {
+                const selection = state.selection;
+                const isNodeSelected = selection instanceof NodeSelection && nodeType === selection.node.type;
                 if (isNodeSelected && selection instanceof NodeSelection) {
                     return { node: selection.node, pos: selection.from };
                 }
-                var parent = parentNode(selection.$from, function (n) { return n.type === nodeType; });
-                var node = parent && parent.node;
+                const parent = parentNode(selection.$from, (n) => n.type === nodeType);
+                const node = parent && parent.node;
                 if (node) {
-                    var pos = selection.$from.start(parent.depth) - 1;
-                    return { node: node, pos: pos };
+                    const pos = selection.$from.start(parent.depth) - 1;
+                    return { node, pos };
                 }
                 return null;
             },
-            update: function (view, prevState) {
-                var _a, _b, _c, _d, _e;
-                var state = view.state;
-                var nodeType = state.schema.nodes[options.node];
-                var selected = this.selectedNode(state, nodeType);
-                var prevSelected = this.selectedNode(prevState, nodeType);
+            update(view, prevState) {
+                const state = view.state;
+                const nodeType = state.schema.nodes[options.node];
+                const selected = this.selectedNode(state, nodeType);
+                const prevSelected = this.selectedNode(prevState, nodeType);
                 if (!selected && prevSelected && !prevState.doc.eq(view.state.doc)) {
                     // selected table is deleted
                     return;
                 }
                 if (selected || prevSelected) {
-                    var tr = state.tr;
+                    const tr = state.tr;
                     tr.setMeta('addToHistory', false);
                     if (selected && prevSelected && selected.pos !== prevSelected.pos) {
-                        tr.setMeta(key, { nodePosition: selected.pos });
-                        var prevNode = tr.doc.nodeAt(prevSelected.pos);
+                        tr.setMeta(tableResizeKey, { nodePosition: selected.pos });
+                        const prevNode = tr.doc.nodeAt(prevSelected.pos);
                         if (prevNode && prevNode.type.name === nodeType.name) {
-                            tr.setNodeMarkup(prevSelected.pos, nodeType, __assign(__assign({}, prevSelected.node.attrs), (_a = {}, _a[resizableAttr] = false, _a)));
+                            tr.setNodeMarkup(prevSelected.pos, nodeType, { ...prevSelected.node.attrs, [resizableAttr]: false });
                         }
-                        tr.setNodeMarkup(selected.pos, nodeType, __assign(__assign({}, selected.node.attrs), (_b = {}, _b[resizableAttr] = true, _b)));
+                        tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [resizableAttr]: true });
                         view.dispatch(tr);
                     }
                     else if (selected && prevSelected && selected.pos === prevSelected.pos &&
                         !selected.node.attrs[resizableAttr] && !state.selection.eq(prevState.selection)) {
-                        tr.setMeta(key, { nodePosition: selected.pos });
-                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, __assign(__assign({}, selected.node.attrs), (_c = {}, _c[resizableAttr] = true, _c))));
+                        tr.setMeta(tableResizeKey, { nodePosition: selected.pos });
+                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [resizableAttr]: true }));
                     }
                     else if (selected && !prevSelected) {
-                        tr.setMeta(key, { nodePosition: selected.pos });
-                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, __assign(__assign({}, selected.node.attrs), (_d = {}, _d[resizableAttr] = true, _d))));
+                        tr.setMeta(tableResizeKey, { nodePosition: selected.pos });
+                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [resizableAttr]: true }));
                     }
                     else if (!selected && prevSelected) {
-                        tr.setMeta(key, { nodePosition: -1 });
-                        view.dispatch(tr.setNodeMarkup(prevSelected.pos, nodeType, __assign(__assign({}, prevSelected.node.attrs), (_e = {}, _e[resizableAttr] = false, _e))));
+                        tr.setMeta(tableResizeKey, { nodePosition: -1 });
+                        view.dispatch(tr.setNodeMarkup(prevSelected.pos, nodeType, { ...prevSelected.node.attrs, [resizableAttr]: false }));
                     }
                 }
             }
-        }); },
+        }),
         state: {
-            init: function () {
+            init() {
                 return new ResizeState('', null, -1);
             },
-            apply: function (tr, prev) {
+            apply(tr, prev) {
                 return prev.apply(tr);
             }
         },
         props: {
             handleDOMEvents: {
-                mousedown: function (view, event) {
+                mousedown(view, event) {
                     return handleMouseDown(view, event);
                 }
             }
         }
     });
 };
+
+export { tableResizing };

package/dist/es/plugins/table-resize/table-view.js

@@ -1,9 +1,10 @@
-import { colgroupAttr, dataResizeDirTable, resizableAttr, resizableWrap, resizeHandle } from '../../config/constants';
-import { parseStrColgroup } from '../../config/schema';
-import { handles } from './../resize-utils';
-import { parseStyle, setAttribute } from './../../utils';
-var TableView = /** @class */ (function () {
-    function TableView(node, view) {
+import { resizableWrap, colgroupAttr, resizeHandle, dataResizeDirTable, resizableAttr } from '../../config/constants.js';
+import { parseStrColgroup } from '../../config/schema.js';
+import { handles } from '../resize-utils.js';
+import { setAttribute, parseStyle } from '../../utils.js';
+
+class TableView {
+    constructor(node, view) {
         this.node = node;
         this.view = view;
         this.dom = document.createElement('div');
@@ -12,54 +13,53 @@ var TableView = /** @class */ (function () {
         if (node.attrs[colgroupAttr]) {
             this.renderColgroup(node.attrs[colgroupAttr]);
         }
-        var tBody = this.table.appendChild(document.createElement('tbody'));
+        const tBody = this.table.appendChild(document.createElement('tbody'));
         this.setAttributes(this.table, node.attrs);
-        this.resizeHandles = handles.map(function (dir) {
-            var handle = document.createElement('span');
+        this.resizeHandles = handles.map(dir => {
+            const handle = document.createElement('span');
             handle.className = resizeHandle + ' ' + dir;
             handle.setAttribute(dataResizeDirTable, dir);
             return handle;
         });
         this.contentDOM = tBody;
     }
-    TableView.prototype.update = function (node) {
-        var _this = this;
+    update(node) {
         if (node.type !== this.node.type) {
             return false;
         }
-        var prev = this.node;
+        const prev = this.node;
         this.node = node;
         if (node.attrs[resizableAttr]) {
-            this.resizeHandles.forEach(function (handle) {
-                _this.dom.appendChild(handle);
+            this.resizeHandles.forEach(handle => {
+                this.dom.appendChild(handle);
             });
         }
         else {
             Array.from(this.dom.children)
-                .filter(function (e) { return e.classList.contains(resizeHandle); })
-                .forEach(function (e) { return e.remove(); });
+                .filter((e) => e.classList.contains(resizeHandle))
+                .forEach((e) => e.remove());
         }
         this.setAttributes(this.table, node.attrs);
         if (prev.attrs[colgroupAttr] !== node.attrs[colgroupAttr]) {
             this.renderColgroup(node.attrs[colgroupAttr]);
         }
         return true;
-    };
-    TableView.prototype.ignoreMutation = function (record) {
-        var result = record.type === 'attributes' &&
+    }
+    ignoreMutation(record) {
+        const result = record.type === 'attributes' &&
             (record.target === this.table ||
                 record.target.firstChild === this.table ||
                 (this.colgroup && this.colgroup.contains(record.target)));
         return result;
-    };
-    TableView.prototype.destroy = function () {
+    }
+    destroy() {
         this.node = undefined;
         this.view = undefined;
         this.table = undefined;
         this.colgroup = undefined;
         this.resizeHandles = undefined;
-    };
-    TableView.prototype.renderColgroup = function (colgroupStr) {
+    }
+    renderColgroup(colgroupStr) {
         if (this.table && this.table.firstChild && this.table.firstChild.nodeName === 'COLGROUP') {
             this.table.removeChild(this.table.firstChild);
         }
@@ -67,10 +67,10 @@ var TableView = /** @class */ (function () {
             this.colgroup = parseStrColgroup(colgroupStr);
             this.table.insertBefore(this.colgroup, this.table.firstChild);
         }
-    };
-    TableView.prototype.setAttributes = function (table, attrs) {
-        var skip = [colgroupAttr, resizableAttr];
-        for (var attrName in attrs) {
+    }
+    setAttributes(table, attrs) {
+        const skip = [colgroupAttr, resizableAttr];
+        for (const attrName in attrs) {
             if (attrName && skip.indexOf(attrName) === -1) {
                 setAttribute(table, attrName, attrs[attrName]);
             }
@@ -82,49 +82,47 @@ var TableView = /** @class */ (function () {
         else {
             this.dom.style.width = '';
         }
-    };
-    return TableView;
-}());
-export { TableView };
-var TableWrapperView = /** @class */ (function () {
-    function TableWrapperView(node, view) {
+    }
+}
+class TableWrapperView {
+    constructor(node, view) {
         this.node = node;
         this.view = view;
         this.dom = document.createElement('div');
         this.setAttributes(this.dom, node.attrs);
         this.contentDOM = this.dom;
     }
-    TableWrapperView.prototype.update = function (node) {
+    update(node) {
         if (node.type !== this.node.type) {
             return false;
         }
         this.node = node;
         this.setAttributes(this.dom, node.attrs);
         return true;
-    };
-    TableWrapperView.prototype.ignoreMutation = function (record) {
+    }
+    ignoreMutation(record) {
         return record.type === 'attributes' && record.attributeName === 'style';
-    };
-    TableWrapperView.prototype.destroy = function () {
+    }
+    destroy() {
         this.node = undefined;
         this.view = undefined;
-    };
-    TableWrapperView.prototype.setAttributes = function (dom, attrs) {
-        for (var attrName in attrs) {
+    }
+    setAttributes(dom, attrs) {
+        for (const attrName in attrs) {
             if (attrName) {
                 setAttribute(dom, attrName, attrs[attrName]);
             }
         }
         dom.setAttribute('table', '');
         if (/%/.test(dom.style.width)) {
-            var table = this.node && this.node.lastChild;
-            var tableStyles = table ? parseStyle(table.attrs.style) : {};
-            var tableWidth = tableStyles.width || '';
+            const table = this.node && this.node.lastChild;
+            const tableStyles = table ? parseStyle(table.attrs.style) : {};
+            const tableWidth = tableStyles.width || '';
             if (tableWidth && !/%/.test(tableWidth)) {
                 dom.style.width = '';
             }
         }
-    };
-    return TableWrapperView;
-}());
-export { TableWrapperView };
+    }
+}
+
+export { TableView, TableWrapperView };