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

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

@@ -1,54 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.tableResizing = void 0;
-var tslib_1 = require("tslib");
-var prosemirror_state_1 = require("prosemirror-state");
-var constants_1 = require("../../config/constants");
-var utils_1 = require("./utils");
-var utils_2 = require("./../../utils");
-var resize_utils_1 = require("./../resize-utils");
-var commonDir = {
+'use strict';
+
+var prosemirrorState = require('prosemirror-state');
+var constants = require('../../config/constants.js');
+var utils = require('./utils.js');
+var utils$1 = require('../../utils.js');
+var resizeUtils = require('../resize-utils.js');
+
+const commonDir = {
     'southeast': true,
     'southwest': true,
     'northwest': true,
     'northeast': true
 };
-var horizontalDir = tslib_1.__assign({ 'east': true, 'west': true }, commonDir);
-var verticalDir = tslib_1.__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(utils_1.tableResizeKey);
+    apply(tr) {
+        const next = tr.getMeta(utils.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 = utils_1.tableResizeKey.getState(view.state);
-    var dragging = state.dragging, nodePosition = state.nodePosition, activeHandle = state.activeHandle;
+    const state = utils.tableResizeKey.getState(view.state);
+    const { dragging, nodePosition, activeHandle } = state;
     if (nodePosition < 0 || !dragging) {
         return;
     }
-    var tableDom = (0, utils_1.getTable)(view.nodeDOM(nodePosition));
-    var rect = tableDom.getBoundingClientRect();
-    var dir = resize_utils_1.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 = utils.getTable(view.nodeDOM(nodePosition));
+    const rect = tableDom.getBoundingClientRect();
+    const dir = resizeUtils.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]) {
@@ -58,117 +64,117 @@ 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 = (0, utils_1.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 = utils.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 = (0, utils_2.parseStyle)(row.attrs.style).height;
+    let heightChange = false;
+    tableNode.forEach((row, offset, index) => {
+        const rowHeight = utils$1.parseStyle(row.attrs.style).height;
         if (rowHeight && !/%$/.test(rowHeight)) {
-            tr.setNodeMarkup(tablePos + offset + 1, null, (0, utils_2.setNodeStyle)(row.attrs, 'height', (rowsHeight[index] * 100 / height) + '%'));
+            tr.setNodeMarkup(tablePos + offset + 1, null, utils$1.setNodeStyle(row.attrs, 'height', (rowsHeight[index] * 100 / height) + '%'));
             heightChange = true;
         }
     });
-    var tableAttrs = tableNode.attrs;
-    if ((0, utils_2.parseStyle)(tableAttrs.style).width !== offsetWidth + 'px') {
-        tableAttrs = (0, utils_2.setNodeStyle)(tableAttrs, 'width', offsetWidth + 'px');
+    let tableAttrs = tableNode.attrs;
+    if (utils$1.parseStyle(tableAttrs.style).width !== offsetWidth + 'px') {
+        tableAttrs = utils$1.setNodeStyle(tableAttrs, 'width', offsetWidth + 'px');
     }
     if (widthChanged) {
-        tableAttrs[constants_1.colgroupAttr] = colgroup.outerHTML;
+        tableAttrs[constants.colgroupAttr] = colgroup.outerHTML;
     }
     if (heightChange) {
-        tableAttrs = (0, utils_2.setNodeStyle)(tableAttrs, 'height', offsetHeight + 'px');
+        tableAttrs = utils$1.setNodeStyle(tableAttrs, 'height', offsetHeight + 'px');
     }
     if (widthChanged || heightChange) {
         tr.setNodeMarkup(tablePos, null, tableAttrs);
     }
 };
-var toPixels = function (view, tr, tablePos, attrs) {
-    var tableNode = view.state.doc.nodeAt(tablePos);
-    var tableDom = (0, utils_1.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 = (0, utils_2.parseStyle)(row.attrs.style).height;
+const toPixels = (view, tr, tablePos, attrs) => {
+    const tableNode = view.state.doc.nodeAt(tablePos);
+    const tableDom = utils.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 = utils$1.parseStyle(row.attrs.style).height;
         if (rowHeight && !/px$/.test(rowHeight)) {
-            tr.setNodeMarkup(tablePos + offset + 1, null, (0, utils_2.setNodeStyle)(row.attrs, 'height', calcStyle(rows[index]).height));
+            tr.setNodeMarkup(tablePos + offset + 1, null, utils$1.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 = tslib_1.__assign({}, attrs);
+    const tableAttrs = { ...attrs };
     if (widthChanged) {
-        tableAttrs[constants_1.colgroupAttr] = colgroup.outerHTML;
+        tableAttrs[constants.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 = utils_1.tableResizeKey.getState(view.state), dragging = _a.dragging, nodePosition = _a.nodePosition, activeHandle = _a.activeHandle;
+const handleMouseUp = (view) => {
+    const { dragging, nodePosition, activeHandle } = utils.tableResizeKey.getState(view.state);
     if (dragging) {
-        var node = view.state.doc.nodeAt(nodePosition);
-        var dom = (0, utils_1.getTable)(view.nodeDOM(nodePosition));
-        var rect = tableSize(dom);
+        const node = view.state.doc.nodeAt(nodePosition);
+        const dom = utils.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 = (0, utils_2.parseStyle)(attrs.style);
+            const width = rect.offsetWidth + 'px';
+            const height = rect.offsetHeight + 'px';
+            const tr = view.state.tr;
+            let attrs = node.attrs;
+            const parsedStyles = utils$1.parseStyle(attrs.style);
             if (horizontalDir[activeHandle] && dom.style.width && parsedStyles.width !== width) {
-                attrs = (0, utils_2.setNodeStyle)(attrs, 'width', width);
+                attrs = utils$1.setNodeStyle(attrs, 'width', width);
             }
             if (verticalDir[activeHandle] && dom.style.height && parsedStyles.height !== height) {
-                attrs = (0, utils_2.setNodeStyle)(attrs, 'height', height);
+                attrs = utils$1.setNodeStyle(attrs, 'height', height);
             }
             attrs = toPixels(view, tr, nodePosition, attrs);
             tr.setNodeMarkup(nodePosition, null, attrs);
             tr.setMeta('commandName', 'node-resize');
             tr.setMeta('args', attrs);
-            tr.setMeta(utils_1.tableResizeKey, {
+            tr.setMeta(utils.tableResizeKey, {
                 setDragging: null,
                 activeHandle: null,
-                nodePosition: nodePosition
+                nodePosition
             });
-            if (!/%/.test((0, utils_2.parseStyle)(attrs.style).width || '')) {
-                var $pos = tr.doc.resolve(nodePosition);
-                var wrapper = (0, utils_2.parentNode)($pos, function (n) { return n.type.name === 'table_wrapper'; });
-                if (wrapper && /%/.test((0, utils_2.parseStyle)(wrapper.node.attrs.style).width || '')) {
-                    var wrapperAttrs = (0, utils_2.setNodeStyle)(wrapper.node.attrs, 'width', '');
-                    var wrapperPos = $pos.start(wrapper.depth) - 1;
+            if (!/%/.test(utils$1.parseStyle(attrs.style).width || '')) {
+                const $pos = tr.doc.resolve(nodePosition);
+                const wrapper = utils$1.parentNode($pos, n => n.type.name === 'table_wrapper');
+                if (wrapper && /%/.test(utils$1.parseStyle(wrapper.node.attrs.style).width || '')) {
+                    const wrapperAttrs = utils$1.setNodeStyle(wrapper.node.attrs, 'width', '');
+                    const wrapperPos = $pos.start(wrapper.depth) - 1;
                     tr.setNodeMarkup(wrapperPos, null, wrapperAttrs);
                 }
             }
@@ -176,24 +182,24 @@ var handleMouseUp = function (view) {
         }
     }
 };
-var handleMouseDown = function (view, event) {
-    var target = event.target;
-    var activeHandle = target.getAttribute(constants_1.dataResizeDirTable);
+const handleMouseDown = (view, event) => {
+    const target = event.target;
+    const activeHandle = target.getAttribute(constants.dataResizeDirTable);
     if (!activeHandle) {
         return false;
     }
-    var resizeState = utils_1.tableResizeKey.getState(view.state);
+    const resizeState = utils.tableResizeKey.getState(view.state);
     event.preventDefault();
-    var transaction = view.state.tr;
-    transaction.setMeta(utils_1.tableResizeKey, {
+    const transaction = view.state.tr;
+    transaction.setMeta(utils.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);
     }
@@ -206,78 +212,77 @@ var handleMouseDown = function (view, event) {
     curWindow.addEventListener('mousemove', move);
     return true;
 };
-var tableResizing = function (options) {
-    if (options === void 0) { options = { node: 'table' }; }
-    return new prosemirror_state_1.Plugin({
-        key: utils_1.tableResizeKey,
-        view: function () { return ({
-            selectedNode: function (state, nodeType) {
-                var selection = state.selection;
-                var isNodeSelected = selection instanceof prosemirror_state_1.NodeSelection && nodeType === selection.node.type;
-                if (isNodeSelected && selection instanceof prosemirror_state_1.NodeSelection) {
+const tableResizing = (options = { node: 'table' }) => {
+    return new prosemirrorState.Plugin({
+        key: utils.tableResizeKey,
+        view: () => ({
+            selectedNode(state, nodeType) {
+                const selection = state.selection;
+                const isNodeSelected = selection instanceof prosemirrorState.NodeSelection && nodeType === selection.node.type;
+                if (isNodeSelected && selection instanceof prosemirrorState.NodeSelection) {
                     return { node: selection.node, pos: selection.from };
                 }
-                var parent = (0, utils_2.parentNode)(selection.$from, function (n) { return n.type === nodeType; });
-                var node = parent && parent.node;
+                const parent = utils$1.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(utils_1.tableResizeKey, { nodePosition: selected.pos });
-                        var prevNode = tr.doc.nodeAt(prevSelected.pos);
+                        tr.setMeta(utils.tableResizeKey, { nodePosition: selected.pos });
+                        const prevNode = tr.doc.nodeAt(prevSelected.pos);
                         if (prevNode && prevNode.type.name === nodeType.name) {
-                            tr.setNodeMarkup(prevSelected.pos, nodeType, tslib_1.__assign(tslib_1.__assign({}, prevSelected.node.attrs), (_a = {}, _a[constants_1.resizableAttr] = false, _a)));
+                            tr.setNodeMarkup(prevSelected.pos, nodeType, { ...prevSelected.node.attrs, [constants.resizableAttr]: false });
                         }
-                        tr.setNodeMarkup(selected.pos, nodeType, tslib_1.__assign(tslib_1.__assign({}, selected.node.attrs), (_b = {}, _b[constants_1.resizableAttr] = true, _b)));
+                        tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants.resizableAttr]: true });
                         view.dispatch(tr);
                     }
                     else if (selected && prevSelected && selected.pos === prevSelected.pos &&
-                        !selected.node.attrs[constants_1.resizableAttr] && !state.selection.eq(prevState.selection)) {
-                        tr.setMeta(utils_1.tableResizeKey, { nodePosition: selected.pos });
-                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, tslib_1.__assign(tslib_1.__assign({}, selected.node.attrs), (_c = {}, _c[constants_1.resizableAttr] = true, _c))));
+                        !selected.node.attrs[constants.resizableAttr] && !state.selection.eq(prevState.selection)) {
+                        tr.setMeta(utils.tableResizeKey, { nodePosition: selected.pos });
+                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants.resizableAttr]: true }));
                     }
                     else if (selected && !prevSelected) {
-                        tr.setMeta(utils_1.tableResizeKey, { nodePosition: selected.pos });
-                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, tslib_1.__assign(tslib_1.__assign({}, selected.node.attrs), (_d = {}, _d[constants_1.resizableAttr] = true, _d))));
+                        tr.setMeta(utils.tableResizeKey, { nodePosition: selected.pos });
+                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants.resizableAttr]: true }));
                     }
                     else if (!selected && prevSelected) {
-                        tr.setMeta(utils_1.tableResizeKey, { nodePosition: -1 });
-                        view.dispatch(tr.setNodeMarkup(prevSelected.pos, nodeType, tslib_1.__assign(tslib_1.__assign({}, prevSelected.node.attrs), (_e = {}, _e[constants_1.resizableAttr] = false, _e))));
+                        tr.setMeta(utils.tableResizeKey, { nodePosition: -1 });
+                        view.dispatch(tr.setNodeMarkup(prevSelected.pos, nodeType, { ...prevSelected.node.attrs, [constants.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);
                 }
             }
         }
     });
 };
+
 exports.tableResizing = tableResizing;

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

@@ -1,81 +1,80 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TableWrapperView = exports.TableView = void 0;
-var constants_1 = require("../../config/constants");
-var schema_1 = require("../../config/schema");
-var resize_utils_1 = require("./../resize-utils");
-var utils_1 = require("./../../utils");
-var TableView = /** @class */ (function () {
-    function TableView(node, view) {
+'use strict';
+
+var constants = require('../../config/constants.js');
+var schema = require('../../config/schema.js');
+var resizeUtils = require('../resize-utils.js');
+var utils = require('../../utils.js');
+
+class TableView {
+    constructor(node, view) {
         this.node = node;
         this.view = view;
         this.dom = document.createElement('div');
-        this.dom.className = constants_1.resizableWrap;
+        this.dom.className = constants.resizableWrap;
         this.table = this.dom.appendChild(document.createElement('table'));
-        if (node.attrs[constants_1.colgroupAttr]) {
-            this.renderColgroup(node.attrs[constants_1.colgroupAttr]);
+        if (node.attrs[constants.colgroupAttr]) {
+            this.renderColgroup(node.attrs[constants.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 = resize_utils_1.handles.map(function (dir) {
-            var handle = document.createElement('span');
-            handle.className = constants_1.resizeHandle + ' ' + dir;
-            handle.setAttribute(constants_1.dataResizeDirTable, dir);
+        this.resizeHandles = resizeUtils.handles.map(dir => {
+            const handle = document.createElement('span');
+            handle.className = constants.resizeHandle + ' ' + dir;
+            handle.setAttribute(constants.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[constants_1.resizableAttr]) {
-            this.resizeHandles.forEach(function (handle) {
-                _this.dom.appendChild(handle);
+        if (node.attrs[constants.resizableAttr]) {
+            this.resizeHandles.forEach(handle => {
+                this.dom.appendChild(handle);
             });
         }
         else {
             Array.from(this.dom.children)
-                .filter(function (e) { return e.classList.contains(constants_1.resizeHandle); })
-                .forEach(function (e) { return e.remove(); });
+                .filter((e) => e.classList.contains(constants.resizeHandle))
+                .forEach((e) => e.remove());
         }
         this.setAttributes(this.table, node.attrs);
-        if (prev.attrs[constants_1.colgroupAttr] !== node.attrs[constants_1.colgroupAttr]) {
-            this.renderColgroup(node.attrs[constants_1.colgroupAttr]);
+        if (prev.attrs[constants.colgroupAttr] !== node.attrs[constants.colgroupAttr]) {
+            this.renderColgroup(node.attrs[constants.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);
         }
         if (colgroupStr) {
-            this.colgroup = (0, schema_1.parseStrColgroup)(colgroupStr);
+            this.colgroup = schema.parseStrColgroup(colgroupStr);
             this.table.insertBefore(this.colgroup, this.table.firstChild);
         }
-    };
-    TableView.prototype.setAttributes = function (table, attrs) {
-        var skip = [constants_1.colgroupAttr, constants_1.resizableAttr];
-        for (var attrName in attrs) {
+    }
+    setAttributes(table, attrs) {
+        const skip = [constants.colgroupAttr, constants.resizableAttr];
+        for (const attrName in attrs) {
             if (attrName && skip.indexOf(attrName) === -1) {
-                (0, utils_1.setAttribute)(table, attrName, attrs[attrName]);
+                utils.setAttribute(table, attrName, attrs[attrName]);
             }
         }
         if (/%$/.test(table.style.width)) {
@@ -85,49 +84,48 @@ var TableView = /** @class */ (function () {
         else {
             this.dom.style.width = '';
         }
-    };
-    return TableView;
-}());
-exports.TableView = 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) {
-                (0, utils_1.setAttribute)(dom, attrName, attrs[attrName]);
+                utils.setAttribute(dom, attrName, attrs[attrName]);
             }
         }
         dom.setAttribute('table', '');
         if (/%/.test(dom.style.width)) {
-            var table = this.node && this.node.lastChild;
-            var tableStyles = table ? (0, utils_1.parseStyle)(table.attrs.style) : {};
-            var tableWidth = tableStyles.width || '';
+            const table = this.node && this.node.lastChild;
+            const tableStyles = table ? utils.parseStyle(table.attrs.style) : {};
+            const tableWidth = tableStyles.width || '';
             if (tableWidth && !/%/.test(tableWidth)) {
                 dom.style.width = '';
             }
         }
-    };
-    return TableWrapperView;
-}());
+    }
+}
+
+exports.TableView = TableView;
 exports.TableWrapperView = TableWrapperView;

package/dist/npm/plugins/table-resize/utils.d.ts

@@ -1,17 +1,7 @@
-import { EditorState, PluginKey } from 'prosemirror-state';
-import { EditorView } from 'prosemirror-view';
-export declare const tableResizeKey: PluginKey<any>;
-export declare const tableColumnResizeKey: PluginKey<any>;
-export declare const tableRowResizeKey: PluginKey<any>;
-export declare function otherResizing(current: PluginKey, state: EditorState): boolean;
-export declare function otherResizeHandle(current: PluginKey, state: EditorState): boolean;
-export declare function getTable(dom: HTMLElement): HTMLTableElement;
-export declare function domCellAround(target: any): HTMLTableCellElement | null;
-export declare function cellIndexes(dataCell: HTMLTableCellElement): {
-    cellIndex: number;
-    rowIndex: number;
-};
-export declare function edgeCell(view: EditorView, event: MouseEvent, indexes: {
-    cellIndex: number;
-    rowIndex: number;
-}): number;
+import { PluginKey } from 'prosemirror-state';
+
+declare const tableResizeKey: PluginKey<any>;
+declare const tableColumnResizeKey: PluginKey<any>;
+declare const tableRowResizeKey: PluginKey<any>;
+
+export { tableColumnResizeKey, tableResizeKey, tableRowResizeKey };