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

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

@@ -1,11 +1,12 @@
 import { PluginKey } from 'prosemirror-state';
 import { TableMap } from 'prosemirror-tables';
-import { parentNode } from '../../utils';
-export var tableResizeKey = new PluginKey('table-resize');
-export var tableColumnResizeKey = new PluginKey('table-column-resizing');
-export var tableRowResizeKey = new PluginKey('table-row-resizing');
-export function otherResizing(current, state) {
-    var activeResize = false;
+import { parentNode } from '../../utils.js';
+
+const tableResizeKey = new PluginKey('table-resize');
+const tableColumnResizeKey = new PluginKey('table-column-resizing');
+const tableRowResizeKey = new PluginKey('table-row-resizing');
+function otherResizing(current, state) {
+    let activeResize = false;
     activeResize = activeResize ||
         (current !== tableResizeKey && Boolean(tableResizeKey.get(state)) && tableResizeKey.getState(state).dragging);
     activeResize = activeResize ||
@@ -14,8 +15,8 @@ export function otherResizing(current, state) {
         (current !== tableRowResizeKey && Boolean(tableRowResizeKey.get(state)) && tableRowResizeKey.getState(state).dragging);
     return activeResize;
 }
-export function otherResizeHandle(current, state) {
-    var activeResize = false;
+function otherResizeHandle(current, state) {
+    let activeResize = false;
     activeResize = activeResize ||
         (current !== tableColumnResizeKey &&
             Boolean(tableColumnResizeKey.get(state)) &&
@@ -24,30 +25,30 @@ export function otherResizeHandle(current, state) {
         (current !== tableRowResizeKey && Boolean(tableRowResizeKey.get(state)) && tableRowResizeKey.getState(state).activeHandle > -1);
     return activeResize;
 }
-export function getTable(dom) {
+function getTable(dom) {
     if (dom && dom.firstChild && dom.firstChild.nodeName === 'TABLE') {
         return dom.firstChild;
     }
     return dom;
 }
-export function domCellAround(target) {
+function domCellAround(target) {
     while (target && target.nodeName !== 'TD' && target.nodeName !== 'TH') {
         target = target.classList.contains('ProseMirror') ? null : target.parentNode;
     }
     return target;
 }
 function tableSpansMap(table) {
-    var rows = Array.from((table && table.rows) || []);
-    var colsCount = Array.from((rows && rows[0] && rows[0].cells) || [])
-        .map(function (c) { return c.colSpan; })
-        .reduce(function (prev, cur) { return prev + cur; }, 0);
-    var map = rows.map(function () { return new Array(colsCount); });
-    rows.forEach(function (row, r) {
-        var curColSpan = 0;
-        Array.from(row.cells).forEach(function (c) {
-            for (var colSp = 0; colSp < c.colSpan; colSp++) {
-                for (var rowSp = 0; rowSp < c.rowSpan; rowSp++) {
-                    var ind = map[r + rowSp].findIndex(function (val, curInd) { return curInd >= curColSpan && !val; });
+    const rows = Array.from((table && table.rows) || []);
+    const colsCount = Array.from((rows && rows[0] && rows[0].cells) || [])
+        .map(c => c.colSpan)
+        .reduce((prev, cur) => prev + cur, 0);
+    const map = rows.map(() => new Array(colsCount));
+    rows.forEach((row, r) => {
+        let curColSpan = 0;
+        Array.from(row.cells).forEach((c) => {
+            for (let colSp = 0; colSp < c.colSpan; colSp++) {
+                for (let rowSp = 0; rowSp < c.rowSpan; rowSp++) {
+                    const ind = map[r + rowSp].findIndex((val, curInd) => curInd >= curColSpan && !val);
                     map[r + rowSp][ind] = c;
                 }
                 curColSpan++;
@@ -56,40 +57,37 @@ function tableSpansMap(table) {
     });
     return map;
 }
-export function cellIndexes(dataCell) {
-    var map = tableSpansMap(dataCell.closest('table'));
-    var result = null;
-    var _loop_1 = function (r) {
-        var row = map[r];
-        row.forEach(function (cell, c) {
+function cellIndexes(dataCell) {
+    const map = tableSpansMap(dataCell.closest('table'));
+    let result = null;
+    for (let r = 0; r < map.length; r++) {
+        const row = map[r];
+        row.forEach((cell, c) => {
             if (dataCell === cell) {
                 result = { rowIndex: r, cellIndex: c };
             }
         });
         if (result) {
-            return "break";
-        }
-    };
-    for (var r = 0; r < map.length; r++) {
-        var state_1 = _loop_1(r);
-        if (state_1 === "break")
             break;
+        }
     }
     return result || { rowIndex: -1, cellIndex: -1 };
 }
-export function edgeCell(view, event, indexes) {
-    var found = view.posAtCoords({ left: event.clientX, top: event.clientY });
+function edgeCell(view, event, indexes) {
+    const found = view.posAtCoords({ left: event.clientX, top: event.clientY });
     if (!found) {
         return -1;
     }
-    var $pos = view.state.doc.resolve(found.pos);
-    var parentTable = parentNode($pos, function (n) { return n.type.spec.tableRole === 'table'; });
+    const $pos = view.state.doc.resolve(found.pos);
+    const parentTable = parentNode($pos, n => n.type.spec.tableRole === 'table');
     if (parentTable === null) {
         return -1;
     }
-    var tablePos = $pos.start(parentTable.depth);
-    var tableNode = parentTable.node;
-    var map = TableMap.get(tableNode);
-    var cell = tablePos + map.map[(map.width * indexes.rowIndex) + indexes.cellIndex];
+    const tablePos = $pos.start(parentTable.depth);
+    const tableNode = parentTable.node;
+    const map = TableMap.get(tableNode);
+    const cell = tablePos + map.map[(map.width * indexes.rowIndex) + indexes.cellIndex];
     return cell;
 }
+
+export { cellIndexes, domCellAround, edgeCell, getTable, otherResizeHandle, otherResizing, tableColumnResizeKey, tableResizeKey, tableRowResizeKey };

package/dist/es/source.js

@@ -1,15 +1,16 @@
-import { DOMParser as ProseMirrorDOMParser } from 'prosemirror-model';
+import { DOMParser, Fragment } from 'prosemirror-model';
 import { AllSelection } from 'prosemirror-state';
-import { rowTypeAttr, colgroupAttr } from './config/constants';
-import { DOMSerializer } from './DOMSerializer';
-import { setStyleAttr } from './utils';
-var blockWrappers = [
+import { colgroupAttr, rowTypeAttr } from './config/constants.js';
+import { DOMSerializer } from './DOMSerializer.js';
+import { setStyleAttr } from './utils.js';
+
+const blockWrappers = [
     'div', 'ol', 'ul', 'li', 'table', 'tbody', 'thead', 'tfoot', 'caption', 'td', 'th', 'p',
     'tr', 'col', 'colgroup', 'article', 'main', 'nav', 'header', 'footer', 'aside', 'section'
 ];
-var removeRowType = function (table, nodeName) {
-    var wrapper = (table.ownerDocument || document).createElement(nodeName);
-    Array.from(table.rows).filter(function (r) { return r.getAttribute(rowTypeAttr) === nodeName; }).forEach(function (row) {
+const removeRowType = (table, nodeName) => {
+    const wrapper = (table.ownerDocument || document).createElement(nodeName);
+    Array.from(table.rows).filter(r => r.getAttribute(rowTypeAttr) === nodeName).forEach(row => {
         row.removeAttribute(rowTypeAttr);
         wrapper.appendChild(row);
     });
@@ -17,33 +18,33 @@ var removeRowType = function (table, nodeName) {
         table.appendChild(wrapper);
     }
 };
-var restoreTables = function (fragment) {
-    Array.from(fragment.querySelectorAll('table')).forEach(function (table) {
+const restoreTables = (fragment) => {
+    Array.from(fragment.querySelectorAll('table')).forEach((table) => {
         removeRowType(table, 'thead');
         removeRowType(table, 'tbody');
         removeRowType(table, 'tfoot');
-        var emptyElement = Array.from(table.children).find(function (el) { return el.children.length === 0; });
+        const emptyElement = Array.from(table.children).find(el => el.children.length === 0);
         if (emptyElement) {
             emptyElement.remove();
         }
-        var wrapper = table.parentNode instanceof HTMLDivElement ? table.parentNode : null;
+        const wrapper = table.parentNode instanceof HTMLDivElement ? table.parentNode : null;
         if (wrapper && wrapper.matches('div[table]')) {
             table.style.marginLeft = wrapper.style.marginLeft;
             table.style.marginRight = wrapper.style.marginRight;
-            var captionDiv_1 = Array.from(wrapper.children).find(function (el) { return el.matches('div[caption]'); });
-            if (captionDiv_1 && captionDiv_1.innerHTML !== '<img>') {
-                var caption_1 = table.createCaption();
-                if (captionDiv_1.id) {
-                    caption_1.id = captionDiv_1.id;
+            const captionDiv = Array.from(wrapper.children).find(el => el.matches('div[caption]'));
+            if (captionDiv && captionDiv.innerHTML !== '<img>') {
+                const caption = table.createCaption();
+                if (captionDiv.id) {
+                    caption.id = captionDiv.id;
                 }
-                if (captionDiv_1.className) {
-                    caption_1.className = captionDiv_1.className;
+                if (captionDiv.className) {
+                    caption.className = captionDiv.className;
                 }
-                Array.from(captionDiv_1.style).forEach(function (styleName) {
-                    caption_1.style[styleName] = captionDiv_1.style[styleName];
+                Array.from(captionDiv.style).forEach((styleName) => {
+                    caption.style[styleName] = captionDiv.style[styleName];
                 });
-                while (captionDiv_1.firstChild) {
-                    caption_1.appendChild(captionDiv_1.firstChild);
+                while (captionDiv.firstChild) {
+                    caption.appendChild(captionDiv.firstChild);
                 }
             }
             if (wrapper.style.width && !table.style.width) {
@@ -54,10 +55,10 @@ var restoreTables = function (fragment) {
         }
     });
 };
-var setRowType = function (children, nodeName) {
-    var tag = nodeName.toUpperCase();
-    children.filter(function (c) { return c.nodeName === tag; }).forEach(function (rowsWrapper) {
-        Array.from(rowsWrapper.children).forEach(function (row) {
+const setRowType = (children, nodeName) => {
+    const tag = nodeName.toUpperCase();
+    children.filter(c => c.nodeName === tag).forEach(rowsWrapper => {
+        Array.from(rowsWrapper.children).forEach(row => {
             row.setAttribute(rowTypeAttr, nodeName);
             if (rowsWrapper.parentNode) {
                 rowsWrapper.parentNode.insertBefore(row, rowsWrapper);
@@ -66,42 +67,42 @@ var setRowType = function (children, nodeName) {
         rowsWrapper.remove();
     });
 };
-var validateTablesToPmSchema = function (fragment) {
-    Array.from(fragment.querySelectorAll('table')).forEach(function (table) {
-        var children = Array.from(table.children);
-        if (children.some(function (e) { return e.nodeName === 'THEAD' || e.nodeName === 'TFOOT'; })) {
+const validateTablesToPmSchema = (fragment) => {
+    Array.from(fragment.querySelectorAll('table')).forEach((table) => {
+        const children = Array.from(table.children);
+        if (children.some(e => e.nodeName === 'THEAD' || e.nodeName === 'TFOOT')) {
             setRowType(children, 'thead');
             setRowType(children, 'tbody');
             setRowType(children, 'tfoot');
         }
-        var colgroup = children.find(function (c) { return c.nodeName === 'COLGROUP'; });
+        const colgroup = children.find(c => c.nodeName === 'COLGROUP');
         if (colgroup) {
             table.setAttribute(colgroupAttr, colgroup.outerHTML);
             colgroup.remove();
         }
         if (table.caption || table.style.marginLeft || table.style.marginRight) {
-            var wrapper = document.createElement('div');
+            const wrapper = document.createElement('div');
             wrapper.setAttribute('table', '');
             wrapper.style.display = 'table';
             wrapper.style.marginLeft = table.style.marginLeft;
             wrapper.style.marginRight = table.style.marginRight;
             if (table.caption) {
-                var captionDiv_2 = document.createElement('div');
-                captionDiv_2.setAttribute('caption', '');
+                const captionDiv = document.createElement('div');
+                captionDiv.setAttribute('caption', '');
                 if (table.caption.id) {
-                    captionDiv_2.id = table.caption.id;
+                    captionDiv.id = table.caption.id;
                 }
                 if (table.caption.className) {
-                    captionDiv_2.className = table.caption.className;
+                    captionDiv.className = table.caption.className;
                 }
-                Array.from(table.caption.style).forEach(function (styleName) {
-                    captionDiv_2.style[styleName] = table.caption.style[styleName];
+                Array.from(table.caption.style).forEach((styleName) => {
+                    captionDiv.style[styleName] = table.caption.style[styleName];
                 });
                 while (table.caption.firstChild) {
-                    captionDiv_2.appendChild(table.caption.firstChild);
+                    captionDiv.appendChild(table.caption.firstChild);
                 }
                 table.removeChild(table.caption);
-                wrapper.appendChild(captionDiv_2);
+                wrapper.appendChild(captionDiv);
             }
             table.parentNode.insertBefore(wrapper, table);
             wrapper.appendChild(table);
@@ -124,25 +125,24 @@ var validateTablesToPmSchema = function (fragment) {
  *
  * @returns The trimmed HTML content
  */
-export var trimWhitespace = function (html, trimAroundTags) {
-    if (trimAroundTags === void 0) { trimAroundTags = blockWrappers; }
-    var tags = trimAroundTags.join('|');
+const trimWhitespace = (html, trimAroundTags = blockWrappers) => {
+    const tags = trimAroundTags.join('|');
     return html.replace(new RegExp('\\s*(<(?:' + tags + ')(?:\\s[^>]*?)?>)', 'g'), '$1')
         .replace(new RegExp('(<\\/(?:' + tags + ')(?:\\s[^>]*?)?>)\\s*', 'g'), '$1');
 };
-var styleAttr = 'data-style';
-var styleReplace = ' ' + styleAttr + '=';
-var reTag = /<[^>]+>/gm;
-var reStyle = /\sstyle=/gm;
-var replacer = function (match) {
+const styleAttr = 'data-style';
+const styleReplace = ' ' + styleAttr + '=';
+const reTag = /<[^>]+>/gm;
+const reStyle = /\sstyle=/gm;
+const replacer = (match) => {
     return match.replace(reStyle, styleReplace);
 };
-var replaceStyleAttr = function (html) {
+const replaceStyleAttr = (html) => {
     return html.replace(reTag, replacer);
 };
-var restoreStyleAttr = function (container) {
-    Array.from(container.querySelectorAll('[' + styleAttr + ']')).forEach(function (element) {
-        var styleString = element.getAttribute(styleAttr);
+const restoreStyleAttr = (container) => {
+    Array.from(container.querySelectorAll('[' + styleAttr + ']')).forEach((element) => {
+        const styleString = element.getAttribute(styleAttr);
         element.removeAttribute(styleAttr);
         setStyleAttr(element, styleString);
     });
@@ -153,8 +153,8 @@ var restoreStyleAttr = function (container) {
  * @param html
  * @returns DocumentFragment
  */
-export var htmlToFragment = function (html) {
-    var template = document.createElement('template');
+const htmlToFragment = (html) => {
+    const template = document.createElement('template');
     template.innerHTML = replaceStyleAttr(html);
     restoreStyleAttr(template.content);
     return template.content;
@@ -162,8 +162,8 @@ export var htmlToFragment = function (html) {
 /**
  * @hidden
  */
-export var fragmentToHtml = function (fragment) {
-    return Array.from(fragment.childNodes).reduce(function (acc, cur) { return acc + (cur.outerHTML || cur.textContent || ''); }, '');
+const fragmentToHtml = (fragment) => {
+    return Array.from(fragment.childNodes).reduce((acc, cur) => acc + (cur.outerHTML || cur.textContent || ''), '');
 };
 /**
  * Creates a DocumentFragment from the given ProseMirrorNode.
@@ -171,8 +171,8 @@ export var fragmentToHtml = function (fragment) {
  * @param doc ProseMirrorNode
  * @returns DocumentFragment
  */
-export var pmDocToFragment = function (doc) {
-    var fragment = DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
+const pmDocToFragment = (doc) => {
+    const fragment = DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
     restoreTables(fragment);
     return fragment;
 };
@@ -184,8 +184,8 @@ export var pmDocToFragment = function (doc) {
  * @param parseOptions
  * @returns ProseMirrorNode
  */
-export var domToPmDoc = function (dom, schema, parseOptions) {
-    return ProseMirrorDOMParser.fromSchema(schema).parse(dom, parseOptions);
+const domToPmDoc = (dom, schema, parseOptions) => {
+    return DOMParser.fromSchema(schema).parse(dom, parseOptions);
 };
 /**
  * Creates a ProseMirrorNode from the given HTML content.
@@ -195,8 +195,8 @@ export var domToPmDoc = function (dom, schema, parseOptions) {
  * @param parseOptions - ProseMirror parse options recognized by the `parse` and `parseSlice` methods.
  * @returns - New ProseMirrorNode instance.
  */
-export var parseContent = function (content, schema, parseOptions) {
-    var dom = htmlToFragment(content);
+const parseContent = (content, schema, parseOptions) => {
+    const dom = htmlToFragment(content);
     validateTablesToPmSchema(dom);
     return domToPmDoc(dom, schema, parseOptions);
 };
@@ -206,8 +206,8 @@ export var parseContent = function (content, schema, parseOptions) {
  * @param state - The Editor State
  * @returns - The serialized content
  */
-export var getHtml = function (state) {
-    var fragment = pmDocToFragment(state.doc);
+const getHtml = (state) => {
+    const fragment = pmDocToFragment(state.doc);
     return fragmentToHtml(fragment);
 };
 /**
@@ -218,13 +218,17 @@ export var getHtml = function (state) {
  * @param parseOptions - ProseMirror parse options recognized by the `parse` and `parseSlice` methods.
  * @returns - Command function that takes an editor `state` and `dispatch` function.
  */
-export var setHtml = function (content, command, parseOptions) {
-    if (command === void 0) { command = 'setHTML'; }
-    if (parseOptions === void 0) { parseOptions = { preserveWhitespace: 'full' }; }
-    return function (state, dispatch) {
-        return dispatch(state.tr
-            .setSelection(new AllSelection(state.doc))
-            .replaceSelectionWith(parseContent(content, state.schema, parseOptions))
-            .setMeta('commandName', command));
-    };
+const setHtml = (content, command = 'setHTML', parseOptions = { preserveWhitespace: 'full' }) => (state, dispatch) => dispatch(state.tr
+    .setSelection(new AllSelection(state.doc))
+    .replaceSelectionWith(parseContent(content, state.schema, parseOptions))
+    .setMeta('commandName', command));
+/**
+ * @hidden
+ */
+const hasSameMarkup = (dom1, dom2, schema, parseOptions) => {
+    const fragment1 = Fragment.from(parseContent(dom1, schema, parseOptions));
+    const fragment2 = Fragment.from(parseContent(dom2, schema, parseOptions));
+    return fragment1.eq(fragment2);
 };
+
+export { domToPmDoc, fragmentToHtml, getHtml, hasSameMarkup, htmlToFragment, parseContent, pmDocToFragment, setHtml, trimWhitespace };

package/dist/es/table.js

@@ -1,134 +1,132 @@
-import { __assign } from "tslib";
-import { addRowAfter as pmAddRowAfter, addRowBefore as pmAddRowBefore, addColumnBefore as pmAddColumnBefore, addColumnAfter as pmAddColumnAfter, deleteColumn as pmDeleteColumn, TableMap } from 'prosemirror-tables';
-import { colgroupAttr, rowTypeAttr } from './config/constants';
-import { parseStrColgroup } from './config/schema';
+import { addRowBefore as addRowBefore$1, addRowAfter as addRowAfter$1, addColumnBefore as addColumnBefore$1, addColumnAfter as addColumnAfter$1, deleteColumn as deleteColumn$1, TableMap } from 'prosemirror-tables';
+export { addColumnAfter as pmAddColumnAfter, addColumnBefore as pmAddColumnBefore, addRowAfter as pmAddRowAfter, addRowBefore as pmAddRowBefore, deleteColumn as pmDeleteColumn } from 'prosemirror-tables';
+import { colgroupAttr, rowTypeAttr } from './config/constants.js';
+import { parseStrColgroup } from './config/schema.js';
+
 /**
  * Creates a table.
  *
  * @returns Node
  */
-export var createTable = function (nodes, rows, columns) {
-    var table = nodes.table, table_row = nodes.table_row, table_cell = nodes.table_cell;
-    var tableRows = [];
-    var cells;
-    for (var r = 0; r < rows + 1; r++) {
+const createTable = (nodes, rows, columns) => {
+    const { table, table_row, table_cell } = nodes;
+    const tableRows = [];
+    let cells;
+    for (let r = 0; r < rows + 1; r++) {
         cells = [];
-        for (var c = 0; c < columns + 1; c++) {
+        for (let c = 0; c < columns + 1; c++) {
             cells.push(table_cell.createAndFill());
         }
         tableRows.push(table_row.createAndFill(undefined, cells));
     }
     return table.createAndFill(undefined, tableRows);
 };
-var reTable = /^table$/;
-var reRow = /^table_row$/;
-var reCell = /^table_cell|table_header$/;
-var closest = function (selection, name) {
-    var pos = selection.$head;
-    for (var i = pos.depth; i > 0; i--) {
-        var node = pos.node(i);
+const reTable = /^table$/;
+const reRow = /^table_row$/;
+const reCell = /^table_cell|table_header$/;
+const closest = (selection, name) => {
+    const pos = selection.$head;
+    for (let i = pos.depth; i > 0; i--) {
+        const node = pos.node(i);
         if (name.test(node.type.name)) {
             return {
                 pos: pos.before(i),
-                node: node
+                node
             };
         }
     }
     return null;
 };
-export var addRowBefore = function (state, dispatch) {
-    var cmdDispatch = dispatch && (function (tr) {
-        var _a;
-        var row = closest(tr.selection, reRow);
-        var table = closest(tr.selection, reTable);
+const addRowBefore = (state, dispatch) => {
+    const cmdDispatch = dispatch && (tr => {
+        const row = closest(tr.selection, reRow);
+        const table = closest(tr.selection, reTable);
         if (row && table && row.node.attrs[rowTypeAttr]) {
-            var index = 0;
-            for (var i = 0; i < table.node.nodeSize; i++) {
+            let index = 0;
+            for (let i = 0; i < table.node.nodeSize; i++) {
                 if (table.node.child(i).eq(row.node)) {
                     index = i;
                     break;
                 }
             }
-            var next = table.node.child(index - 1);
-            var from = row.pos - next.nodeSize;
-            tr.setNodeMarkup(from, undefined, (_a = {}, _a[rowTypeAttr] = row.node.attrs[rowTypeAttr], _a));
+            const next = table.node.child(index - 1);
+            const from = row.pos - next.nodeSize;
+            tr.setNodeMarkup(from, undefined, { [rowTypeAttr]: row.node.attrs[rowTypeAttr] });
         }
         return dispatch(tr);
     });
-    return pmAddRowBefore(state, cmdDispatch);
+    return addRowBefore$1(state, cmdDispatch);
 };
-export var addRowAfter = function (state, dispatch) {
-    var cmdDispatch = dispatch && (function (tr) {
-        var _a;
-        var row = closest(tr.selection, reRow);
+const addRowAfter = (state, dispatch) => {
+    const cmdDispatch = dispatch && (tr => {
+        const row = closest(tr.selection, reRow);
         if (row && row.node.attrs[rowTypeAttr]) {
-            var from = row.pos + row.node.nodeSize;
-            tr.setNodeMarkup(from, undefined, (_a = {}, _a[rowTypeAttr] = row.node.attrs[rowTypeAttr], _a));
+            const from = row.pos + row.node.nodeSize;
+            tr.setNodeMarkup(from, undefined, { [rowTypeAttr]: row.node.attrs[rowTypeAttr] });
         }
         return dispatch(tr);
     });
-    return pmAddRowAfter(state, cmdDispatch);
+    return addRowAfter$1(state, cmdDispatch);
 };
-var columnIndex = function (table, selection) {
+const columnIndex = (table, selection) => {
     if (!table) {
         return -1;
     }
-    var map = TableMap.get(table.node);
-    var tableCell = closest(selection, reCell);
-    var idx = map.map.indexOf(tableCell.pos - table.pos - 1);
-    var colIndex = -1;
+    const map = TableMap.get(table.node);
+    const tableCell = closest(selection, reCell);
+    const idx = map.map.indexOf(tableCell.pos - table.pos - 1);
+    let colIndex = -1;
     if (idx !== -1) {
         colIndex = idx % map.width;
     }
     return colIndex;
 };
-var addCol = function (tr, table, to) {
-    var _a;
-    var colIndex = columnIndex(table, tr.selection);
-    var colgroup = parseStrColgroup(table.node.attrs[colgroupAttr]);
+const addCol = (tr, table, to) => {
+    const colIndex = columnIndex(table, tr.selection);
+    const colgroup = parseStrColgroup(table.node.attrs[colgroupAttr]);
     colgroup.insertBefore(colgroup.ownerDocument.createElement('col'), colgroup.children[colIndex + to]);
-    tr.setNodeMarkup(table.pos, null, __assign(__assign({}, table.node.attrs), (_a = {}, _a[colgroupAttr] = colgroup.outerHTML, _a)));
+    tr.setNodeMarkup(table.pos, null, { ...table.node.attrs, [colgroupAttr]: colgroup.outerHTML });
 };
-var deleteCol = function (tr, table, colIndex) {
-    var _a;
-    var colgroup = parseStrColgroup(table.node.attrs[colgroupAttr]);
+const deleteCol = (tr, table, colIndex) => {
+    const colgroup = parseStrColgroup(table.node.attrs[colgroupAttr]);
     colgroup.removeChild(colgroup.children[colIndex]);
-    tr.setNodeMarkup(table.pos, null, __assign(__assign({}, table.node.attrs), (_a = {}, _a[colgroupAttr] = colgroup.outerHTML, _a)));
+    tr.setNodeMarkup(table.pos, null, { ...table.node.attrs, [colgroupAttr]: colgroup.outerHTML });
 };
-export var addColumnBefore = function (state, dispatch) {
-    var cmdDispatch = dispatch && (function (tr) {
-        var table = closest(tr.selection, reTable);
+const addColumnBefore = (state, dispatch) => {
+    const cmdDispatch = dispatch && (tr => {
+        const table = closest(tr.selection, reTable);
         if (!table.node.attrs[colgroupAttr]) {
             return dispatch(tr);
         }
         addCol(tr, table, -1);
         return dispatch(tr);
     });
-    return pmAddColumnBefore(state, cmdDispatch);
+    return addColumnBefore$1(state, cmdDispatch);
 };
-export var addColumnAfter = function (state, dispatch) {
-    var cmdDispatch = dispatch && (function (tr) {
-        var table = closest(tr.selection, reTable);
+const addColumnAfter = (state, dispatch) => {
+    const cmdDispatch = dispatch && (tr => {
+        const table = closest(tr.selection, reTable);
         if (!table.node.attrs[colgroupAttr]) {
             return dispatch(tr);
         }
         addCol(tr, table, 1);
         return dispatch(tr);
     });
-    return pmAddColumnAfter(state, cmdDispatch);
+    return addColumnAfter$1(state, cmdDispatch);
 };
-export var deleteColumn = function (state, dispatch) {
-    var parentTable = closest(state.selection, reTable);
-    var colgroup = parentTable && parentTable.node.attrs[colgroupAttr];
-    var colIndex = columnIndex(parentTable, state.selection);
-    var cmdDispatch = dispatch && (function (tr) {
+const deleteColumn = (state, dispatch) => {
+    const parentTable = closest(state.selection, reTable);
+    const colgroup = parentTable && parentTable.node.attrs[colgroupAttr];
+    const colIndex = columnIndex(parentTable, state.selection);
+    const cmdDispatch = dispatch && ((tr) => {
         if (!colgroup) {
             return dispatch(tr);
         }
-        var table = tr.doc.nodeAt(parentTable.pos);
+        const table = tr.doc.nodeAt(parentTable.pos);
         deleteCol(tr, { node: table, pos: parentTable.pos }, colIndex);
         return dispatch(tr);
     });
-    return pmDeleteColumn(state, cmdDispatch);
+    return deleteColumn$1(state, cmdDispatch);
 };
-export { pmAddRowBefore, pmAddRowAfter, pmAddColumnBefore, pmAddColumnAfter, pmDeleteColumn };
+
+export { addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, createTable, deleteColumn };

package/dist/es/text.js

@@ -1,3 +1,5 @@
-export var insertText = function (attrs) { return function (state, dispatch) {
+const insertText = (attrs) => (state, dispatch) => {
     dispatch(state.tr.insertText(attrs.text, attrs.from, attrs.to));
-}; };
+};
+
+export { insertText };