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

package/dist/npm/inline-style.js

@@ -1,99 +1,97 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyInlineStyle = exports.toggleInlineFormat = exports.getInlineStyles = void 0;
-var tslib_1 = require("tslib");
-var prosemirror_transform_1 = require("prosemirror-transform");
-var prosemirror_state_1 = require("prosemirror-state");
-var utils_1 = require("./utils");
-var mark_1 = require("./mark");
-var changeStyleFromMark = function (marks, toChange) {
-    var styleMark = marks.find(function (m) { return m.type.name === 'style'; });
-    var elementStyle = styleMark && styleMark.attrs.style;
-    return (0, utils_1.changeStylesString)(elementStyle, toChange);
+'use strict';
+
+var prosemirrorTransform = require('prosemirror-transform');
+var prosemirrorState = require('prosemirror-state');
+var utils = require('./utils.js');
+var mark = require('./mark.js');
+
+const changeStyleFromMark = (marks, toChange) => {
+    const styleMark = marks.find(m => m.type.name === 'style');
+    const elementStyle = styleMark && styleMark.attrs.style;
+    return utils.changeStylesString(elementStyle, toChange);
 };
-var changeStyleMark = function (tr, from, to, attrs, markType) {
-    var mark = markType.create({ style: attrs.style });
-    var removed = [], added = [], removing = null, adding = null;
-    tr.doc.nodesBetween(from, to, function (node, pos, parent) {
+const changeStyleMark = (tr, from, to, attrs, markType) => {
+    const mark = markType.create({ style: attrs.style });
+    let removed = [], added = [], removing = null, adding = null;
+    tr.doc.nodesBetween(from, to, (node, pos, parent) => {
         if (!node.isInline) {
             return;
         }
-        var marks = node.marks;
+        const marks = node.marks;
         if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
-            var start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
-            var newStyle = changeStyleFromMark(marks, attrs);
+            const start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
+            const newStyle = changeStyleFromMark(marks, attrs);
             if (newStyle.changed || attrs.newValue) {
-                var style = newStyle.changed ?
-                    { style: newStyle.style || null } : { style: "".concat([attrs.style], ": ").concat(attrs.newValue, ";") };
-                var currentMark = markType.isInSet(marks) ? marks.find(function (m) { return m.type.name === 'style'; }) : null;
-                var newMarkAttrs_1 = currentMark ? tslib_1.__assign(tslib_1.__assign({}, currentMark.attrs), style) : style;
-                var newStyleMark = markType.create(newMarkAttrs_1);
-                var newSet = newStyleMark.addToSet(marks);
-                for (var i = 0; i < marks.length; i++) {
+                const style = newStyle.changed ?
+                    { style: newStyle.style || null } : { style: `${[attrs.style]}: ${attrs.newValue};` };
+                const currentMark = markType.isInSet(marks) ? marks.find(m => m.type.name === 'style') : null;
+                const newMarkAttrs = currentMark ? { ...currentMark.attrs, ...style } : style;
+                const newStyleMark = markType.create(newMarkAttrs);
+                const newSet = newStyleMark.addToSet(marks);
+                for (let i = 0; i < marks.length; i++) {
                     if (!marks[i].isInSet(newSet)) {
                         if (removing && removing.to === start && removing.mark.eq(marks[i])) {
                             removing.to = end;
                         }
                         else {
-                            removing = new prosemirror_transform_1.RemoveMarkStep(start, end, marks[i]);
+                            removing = new prosemirrorTransform.RemoveMarkStep(start, end, marks[i]);
                             removed.push(removing);
                         }
                     }
                 }
-                var previousAdded = adding && adding.to === start;
-                var sameAdding = previousAdded && newStyleMark.attrs.style === adding.mark.attrs.style;
+                const previousAdded = adding && adding.to === start;
+                const sameAdding = previousAdded && newStyleMark.attrs.style === adding.mark.attrs.style;
                 if (previousAdded && sameAdding) {
                     adding.to = end;
                 }
-                else if (Object.keys(newMarkAttrs_1).some(function (attrName) { return newMarkAttrs_1[attrName] !== null; })) {
-                    adding = new prosemirror_transform_1.AddMarkStep(start, end, newStyleMark);
+                else if (Object.keys(newMarkAttrs).some(attrName => newMarkAttrs[attrName] !== null)) {
+                    adding = new prosemirrorTransform.AddMarkStep(start, end, newStyleMark);
                     added.push(adding);
                 }
             }
         }
     });
-    removed.forEach(function (s) { return tr.step(s); });
-    added.forEach(function (s) { return tr.step(s); });
+    removed.forEach(s => tr.step(s));
+    added.forEach(s => tr.step(s));
     return removed.length + added.length > 0;
 };
 /**
  * Used by FontSize and FontName tools for getting their state.
  */
-var getInlineStyles = function (state, style) {
-    var styleMark = state.schema.marks.style;
-    var marks = styleMark ? (0, mark_1.selectionMarks)(state, styleMark) : [];
-    return marks.map(function (mark) { return (0, mark_1.styleValue)(mark, style); }).filter(function (m) { return m !== null; });
+const getInlineStyles = (state, style) => {
+    const styleMark = state.schema.marks.style;
+    const marks = styleMark ? mark.selectionMarks(state, styleMark) : [];
+    return marks.map(mark$1 => mark.styleValue(mark$1, style)).filter(m => m !== null);
 };
-exports.getInlineStyles = getInlineStyles;
-var changeStyle = function (markType, attrs) {
+const changeStyle = (markType, attrs) => {
     return function (state, dispatch, tr) {
-        var _a = state.selection, empty = _a.empty, ranges = _a.ranges;
-        var $cursor = state.selection instanceof prosemirror_state_1.TextSelection && state.selection.$cursor;
-        if ((empty && !$cursor) || !(0, mark_1.markApplies)(state.doc, ranges, markType)) {
+        const { empty, ranges } = state.selection;
+        const $cursor = state.selection instanceof prosemirrorState.TextSelection && state.selection.$cursor;
+        if ((empty && !$cursor) || !mark.markApplies(state.doc, ranges, markType)) {
             return false;
         }
-        var result = false;
+        let result = false;
         if (dispatch) {
-            var transaction = tr || state.tr;
+            const transaction = tr || state.tr;
             if ($cursor) {
-                var currentMarks = state.storedMarks || $cursor.marks();
+                const currentMarks = state.storedMarks || $cursor.marks();
                 if (markType.isInSet(currentMarks)) {
-                    var newStyle = changeStyleFromMark(currentMarks, attrs);
-                    var styleMark = currentMarks.find(function (m) { return m.type.name === 'style'; });
-                    var newAttrs_1 = tslib_1.__assign(tslib_1.__assign({}, (styleMark ? styleMark.attrs : {})), { style: newStyle.style || null });
-                    if ((0, utils_1.shallowEqual)(styleMark.attrs, newAttrs_1)) {
+                    const newStyle = changeStyleFromMark(currentMarks, attrs);
+                    const styleMark = currentMarks.find(m => m.type.name === 'style');
+                    const newAttrs = { ...(styleMark ? styleMark.attrs : {}), style: newStyle.style || null };
+                    if (utils.shallowEqual(styleMark.attrs, newAttrs)) {
                         return false;
                     }
                     dispatch(transaction.removeStoredMark(markType));
-                    if (Object.keys(newAttrs_1).some(function (attrName) { return newAttrs_1[attrName] !== null; })) {
-                        dispatch(transaction.addStoredMark(markType.create(newAttrs_1)));
+                    if (Object.keys(newAttrs).some(attrName => newAttrs[attrName] !== null)) {
+                        dispatch(transaction.addStoredMark(markType.create(newAttrs)));
                     }
                     result = true;
                 }
             }
             else {
-                for (var i = 0; i < ranges.length; i++) {
-                    var _b = ranges[i], $from = _b.$from, $to = _b.$to;
+                for (let i = 0; i < ranges.length; i++) {
+                    const { $from, $to } = ranges[i];
                     result = changeStyleMark(transaction, $from.pos, $to.pos, attrs, markType) || result;
                 }
                 if (result) {
@@ -108,68 +106,67 @@ var changeStyle = function (markType, attrs) {
 /**
  * Used by bold, italic, ... and link commands.
  */
-var toggleInlineFormat = function (options, tr, markAttrs) { return function (state, dispatch) {
-    var marks = state.schema.marks;
-    var altStyle = options.altStyle, _a = options.altMarks, altMarks = _a === void 0 ? [] : _a, mark = options.mark;
-    var transaction = tr || state.tr;
-    var styleRemoved = false;
-    var dispatched = false;
-    var markDispatched = function () { return dispatched = true; };
+const toggleInlineFormat = (options, tr, markAttrs) => (state, dispatch) => {
+    const marks = state.schema.marks;
+    const { altStyle, altMarks = [], mark: mark$1 } = options;
+    const transaction = tr || state.tr;
+    let styleRemoved = false;
+    let dispatched = false;
+    const markDispatched = () => dispatched = true;
     if (altStyle && marks.style) {
-        var cmd = changeStyle(marks.style, { style: altStyle.name, value: altStyle.value });
+        const cmd = changeStyle(marks.style, { style: altStyle.name, value: altStyle.value });
         styleRemoved = cmd(state, markDispatched, transaction);
     }
-    var allMarks = tslib_1.__spreadArray([mark], altMarks, true).filter(function (m) { return marks[m]; });
-    var toRemove = allMarks.map(function (m) { return (0, mark_1.hasMark)(state, { mark: m }) && marks[m]; }).filter(function (m) { return m; });
+    const allMarks = [mark$1, ...altMarks].filter(m => marks[m]);
+    const toRemove = allMarks.map(m => mark.hasMark(state, { mark: m }) && marks[m]).filter(m => m);
     if (toRemove.length) {
-        (0, mark_1.removeMarks)(toRemove, state, markDispatched, transaction);
+        mark.removeMarks(toRemove, state, markDispatched, transaction);
     }
     else {
         if (!styleRemoved) {
-            (0, mark_1.toggleMark)(marks[mark], markAttrs, transaction)(state, markDispatched);
+            mark.toggleMark(marks[mark$1], markAttrs, transaction)(state, markDispatched);
         }
     }
     if (dispatched) {
         dispatch(transaction);
     }
     return dispatched;
-}; };
-exports.toggleInlineFormat = toggleInlineFormat;
+};
 /**
  * Used by FontSize, FontName, Color and BackColor commands.
  */
-var applyInlineStyle = function (options, command) { return function (state, dispatch) {
-    var marks = state.schema.marks;
-    var markType = marks.style;
-    var attrs = {
+const applyInlineStyle = (options, command) => (state, dispatch) => {
+    const marks = state.schema.marks;
+    const markType = marks.style;
+    const attrs = {
         style: options.style, value: /^.+$/, newValue: options.value
     };
-    var tr = state.tr;
+    const tr = state.tr;
     if (command) {
         tr.setMeta('commandName', command);
     }
     tr.setMeta('args', options);
-    var _a = state.selection, empty = _a.empty, $cursor = _a.$cursor, ranges = _a.ranges;
-    if ((empty && !$cursor) || !markType || !(0, mark_1.markApplies)(state.doc, ranges, markType)) {
+    const { empty, $cursor, ranges } = state.selection;
+    if ((empty && !$cursor) || !markType || !mark.markApplies(state.doc, ranges, markType)) {
         return false;
     }
     // Empty selection
     if ($cursor) {
-        var marksFromSelection = state.storedMarks || $cursor.marks();
-        var currentMark = markType.isInSet(marksFromSelection) ? marksFromSelection.find(function (m) { return m.type.name === 'style'; }) : null;
-        var newStyles = { style: null };
+        const marksFromSelection = state.storedMarks || $cursor.marks();
+        const currentMark = markType.isInSet(marksFromSelection) ? marksFromSelection.find(m => m.type.name === 'style') : null;
+        const newStyles = { style: null };
         if (currentMark && currentMark.attrs.style) {
-            var resultStyles = (0, utils_1.changeStylesString)(currentMark.attrs.style, attrs);
+            const resultStyles = utils.changeStylesString(currentMark.attrs.style, attrs);
             if (resultStyles.changed && resultStyles.style) {
                 newStyles.style = resultStyles.style;
             }
         }
         else if (attrs.newValue) {
-            newStyles.style = "".concat([attrs.style], ": ").concat(attrs.newValue, ";");
+            newStyles.style = `${[attrs.style]}: ${attrs.newValue};`;
         }
-        var newMarkAttrs_2 = currentMark ? tslib_1.__assign(tslib_1.__assign({}, currentMark.attrs), newStyles) : newStyles;
-        if (Object.keys(newMarkAttrs_2).some(function (attrName) { return newMarkAttrs_2[attrName] !== null; })) {
-            dispatch(tr.addStoredMark(markType.create(newMarkAttrs_2)));
+        const newMarkAttrs = currentMark ? { ...currentMark.attrs, ...newStyles } : newStyles;
+        if (Object.keys(newMarkAttrs).some(attrName => newMarkAttrs[attrName] !== null)) {
+            dispatch(tr.addStoredMark(markType.create(newMarkAttrs)));
         }
         else {
             dispatch(tr.removeStoredMark(markType));
@@ -177,5 +174,8 @@ var applyInlineStyle = function (options, command) { return function (state, dis
         return true;
     }
     return changeStyle(markType, attrs)(state, dispatch, tr);
-}; };
+};
+
 exports.applyInlineStyle = applyInlineStyle;
+exports.getInlineStyles = getInlineStyles;
+exports.toggleInlineFormat = toggleInlineFormat;

package/dist/npm/link.d.ts

@@ -1,5 +1,7 @@
-export declare const removeLink: (options: any, tr?: any) => (state: any, dispatch: any) => void;
-export declare const applyLink: ({ mark, attrs }: {
+declare const removeLink: (options: any, tr?: any) => (state: any, dispatch: any) => void;
+declare const applyLink: ({ mark, attrs }: {
     mark: any;
     attrs: any;
 }, commandName?: string) => (state: any, dispatch: any) => boolean;
+
+export { applyLink, removeLink };

package/dist/npm/link.js

@@ -1,14 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyLink = exports.removeLink = void 0;
-var inline_style_1 = require("./inline-style");
-var mark_1 = require("./mark");
-var prosemirror_state_1 = require("prosemirror-state");
-var modifyLink = function (options, tr) { return function (state, dispatch) {
-    var _a = state.selection, $cursor = _a.$cursor, from = _a.from, to = _a.to;
-    var markType = state.schema.marks[options.mark];
+'use strict';
+
+var inlineStyle = require('./inline-style.js');
+var mark = require('./mark.js');
+var prosemirrorState = require('prosemirror-state');
+
+const modifyLink = (options, tr) => (state, dispatch) => {
+    const { $cursor, from, to } = state.selection;
+    const markType = state.schema.marks[options.mark];
     if (!$cursor) {
-        tr.doc.nodesBetween(from, to, function (node, pos) {
+        tr.doc.nodesBetween(from, to, (node, pos) => {
             if (node.isInline && markType.isInSet(node.marks)) {
                 tr.removeMark(pos, pos + node.nodeSize, markType);
                 tr.addMark(pos, pos + node.nodeSize, markType.create(options.attrs));
@@ -17,11 +17,11 @@ var modifyLink = function (options, tr) { return function (state, dispatch) {
         });
     }
     else {
-        var parentNode = $cursor.parent;
-        var cursorNodeIndex = $cursor.index();
-        var mark = parentNode.child(cursorNodeIndex).marks.find(function (m) { return m.type === markType; });
-        var childCount = parentNode.childCount;
-        var linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index = void 0, nodeSize = void 0;
+        const parentNode = $cursor.parent;
+        const cursorNodeIndex = $cursor.index();
+        const mark = parentNode.child(cursorNodeIndex).marks.find(m => m.type === markType);
+        const childCount = parentNode.childCount;
+        let linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index, nodeSize;
         index = cursorNodeIndex - 1;
         while (index >= 0 && mark.isInSet(parentNode.child(index).marks)) {
             nodeSize = parentNode.child(index).nodeSize;
@@ -38,74 +38,71 @@ var modifyLink = function (options, tr) { return function (state, dispatch) {
         tr.addMark(linkStart, linkStart + linkSize, markType.create(options.attrs));
         dispatch(tr);
     }
-}; };
-var removeLink = function (options, tr) { return function (state, dispatch) {
-    var $cursor = state.selection.$cursor;
+};
+const removeLink = (options, tr) => (state, dispatch) => {
+    const { $cursor } = state.selection;
     if (!$cursor) {
-        (0, inline_style_1.toggleInlineFormat)(options, tr)(state, dispatch);
+        inlineStyle.toggleInlineFormat(options, tr)(state, dispatch);
     }
     else {
-        var parentNode = $cursor.parent;
-        var cursorNodeIndex = $cursor.index();
-        var toolMark_1 = state.schema.marks[options.mark];
-        var mark = parentNode.child(cursorNodeIndex).marks.find(function (m) { return m.type === toolMark_1; });
-        var childCount = parentNode.childCount;
-        var linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index = void 0, nodeSize = void 0;
+        const parentNode = $cursor.parent;
+        const cursorNodeIndex = $cursor.index();
+        const toolMark = state.schema.marks[options.mark];
+        const mark$1 = parentNode.child(cursorNodeIndex).marks.find(m => m.type === toolMark);
+        const childCount = parentNode.childCount;
+        let linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index, nodeSize;
         index = cursorNodeIndex - 1;
-        while (index >= 0 && mark.isInSet(parentNode.child(index).marks)) {
+        while (index >= 0 && mark$1.isInSet(parentNode.child(index).marks)) {
             nodeSize = parentNode.child(index).nodeSize;
             linkSize += nodeSize;
             linkStart -= nodeSize;
             index -= 1;
         }
         index = cursorNodeIndex + 1;
-        while (index < childCount && mark.isInSet(parentNode.child(index).marks)) {
+        while (index < childCount && mark$1.isInSet(parentNode.child(index).marks)) {
             linkSize += parentNode.child(index).nodeSize;
             index += 1;
         }
-        dispatch((0, mark_1.removeMark)(tr || state.tr, linkStart, linkStart + linkSize, mark));
+        dispatch(mark.removeMark(tr || state.tr, linkStart, linkStart + linkSize, mark$1));
     }
-}; };
-exports.removeLink = removeLink;
+};
 /**
  * Returns a mark which wraps the selection.
  */
-var getParentMark = function (state, markType) {
-    var marks = (0, mark_1.selectionMarks)(state, markType);
+const getParentMark = (state, markType) => {
+    const marks = mark.selectionMarks(state, markType);
     return marks.length === 1 && marks[0] ? marks[0] : null;
 };
-var applyLink = function (_a, commandName) {
-    var mark = _a.mark, attrs = _a.attrs;
-    if (commandName === void 0) { commandName = 'link'; }
-    return function (state, dispatch) {
-        var marks = state.schema.marks;
-        var tr = state.tr;
-        if (commandName) {
-            tr.setMeta('commandName', commandName);
-            tr.setMeta('args', attrs);
+const applyLink = ({ mark: mark$1, attrs }, commandName = 'link') => (state, dispatch) => {
+    const marks = state.schema.marks;
+    const tr = state.tr;
+    if (commandName) {
+        tr.setMeta('commandName', commandName);
+        tr.setMeta('args', attrs);
+    }
+    let dispatched = false;
+    const markDispatched = () => dispatched = true;
+    if (getParentMark(state, marks[mark$1])) {
+        modifyLink({ mark: mark$1, attrs }, tr)(state, markDispatched);
+    }
+    else {
+        let nextState = state;
+        if (mark.hasMark(state, { mark: mark$1 })) {
+            removeLink({ mark: mark$1, attrs }, tr)(state, markDispatched);
+            nextState = prosemirrorState.EditorState.create({ doc: tr.doc, selection: tr.selection });
         }
-        var dispatched = false;
-        var markDispatched = function () { return dispatched = true; };
-        if (getParentMark(state, marks[mark])) {
-            modifyLink({ mark: mark, attrs: attrs }, tr)(state, markDispatched);
+        if (dispatched) {
+            mark.toggleMark(marks[mark$1], attrs, tr)(nextState, markDispatched);
         }
         else {
-            var nextState = state;
-            if ((0, mark_1.hasMark)(state, { mark: mark })) {
-                (0, exports.removeLink)({ mark: mark, attrs: attrs }, tr)(state, markDispatched);
-                nextState = prosemirror_state_1.EditorState.create({ doc: tr.doc, selection: tr.selection });
-            }
-            if (dispatched) {
-                (0, mark_1.toggleMark)(marks[mark], attrs, tr)(nextState, markDispatched);
-            }
-            else {
-                (0, inline_style_1.toggleInlineFormat)({ mark: mark }, tr, attrs)(nextState, markDispatched);
-            }
-        }
-        if (dispatched) {
-            dispatch(tr);
+            inlineStyle.toggleInlineFormat({ mark: mark$1 }, tr, attrs)(nextState, markDispatched);
         }
-        return dispatched;
-    };
+    }
+    if (dispatched) {
+        dispatch(tr);
+    }
+    return dispatched;
 };
+
 exports.applyLink = applyLink;
+exports.removeLink = removeLink;

package/dist/npm/listConvert.d.ts

@@ -1 +1,3 @@
-export declare const convertMsLists: (html: string) => string;
+declare const convertMsLists: (html: string) => string;
+
+export { convertMsLists };

package/dist/npm/listConvert.js

@@ -1,29 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertMsLists = void 0;
-var source_1 = require("./source");
-var msoListRegExp = /style=['"]?[^'"]*?mso-list:\s*[a-zA-Z]+(\d+)\s[a-zA-Z]+(\d+)\s(\w+)/gi;
-var extractListLevels = function (html) {
-    html = html.replace(msoListRegExp, function (match, list, level) {
-        return "datalist=\"".concat(list, "\" datalevel=\"").concat(level, "\" ").concat(match);
+'use strict';
+
+var source = require('./source.js');
+
+const msoListRegExp = /style=['"]?[^'"]*?mso-list:\s*[a-zA-Z]+(\d+)\s[a-zA-Z]+(\d+)\s(\w+)/gi;
+const extractListLevels = (html) => {
+    html = html.replace(msoListRegExp, (match, list, level) => {
+        return `datalist="${list}" datalevel="${level}" ${match}`;
     });
     return html;
 };
-var isPartOfListItem = function (element) {
+const isPartOfListItem = (element) => {
     return /^MsoListParagraph/.test(element.className);
 };
-var innerText = function (node) {
-    var text = node.innerHTML;
+const innerText = (node) => {
+    let text = node.innerHTML;
     text = text.replace(/<!--(.|\s)*?-->/gi, '');
     text = text.replace(/<\/?[^>]+?\/?>/gm, '');
     return text;
 };
-var createList = function (type, styleType) {
-    var list = document.createElement(type);
+const createList = (type, styleType) => {
+    const list = document.createElement(type);
     list.style.listStyleType = styleType;
     return list;
 };
-var guessUnorderedListStyle = function (symbol) {
+const guessUnorderedListStyle = (symbol) => {
     if (/^[\u2022\u00b7\u00FC\u00D8\u002dv-]/.test(symbol)) {
         return null; // return "disc"; //default CSS value
     }
@@ -34,21 +34,21 @@ var guessUnorderedListStyle = function (symbol) {
         return 'square';
     }
 };
-var guessOrderedListStyle = function (symbol) {
-    var type = null;
+const guessOrderedListStyle = (symbol) => {
+    let type = null;
     if (!/^\d/.test(symbol)) {
         type = (/^[a-z]/.test(symbol) ? 'lower-' : 'upper-') +
             (/^[ivxlcdm]/i.test(symbol) ? 'roman' : 'alpha');
     }
     return type;
 };
-var mapListsCandidates = function (nodes, groups) {
-    var group = [];
-    Array.from(nodes).forEach(function (node) {
+const mapListsCandidates = (nodes, groups) => {
+    let group = [];
+    Array.from(nodes).forEach(node => {
         if (node.nodeType !== Node.ELEMENT_NODE) {
             return;
         }
-        var element = node;
+        const element = node;
         if (element.getAttribute('datalist')) {
             group.push(node);
             groups.add(group);
@@ -62,16 +62,16 @@ var mapListsCandidates = function (nodes, groups) {
                 mapListsCandidates(element.children, groups);
             }
             else if (element.nodeName === 'TABLE') {
-                Array.from(element.querySelectorAll('td,th')).forEach(function (cell) {
+                Array.from(element.querySelectorAll('td,th')).forEach(cell => {
                     mapListsCandidates(cell.children, groups);
                 });
             }
         }
     });
 };
-var listTypes = function (p) {
-    var html = p.innerHTML;
-    var trimStartText = function (t) {
+const listTypes = (p) => {
+    let html = p.innerHTML;
+    const trimStartText = (t) => {
         return t.replace(/^(?:&nbsp;|[\u00a0\n\r\s])+/, '');
     };
     html = html.replace(/<\/?\w+[^>]*>/g, '').replace(/&nbsp;/g, '\u00a0');
@@ -88,8 +88,8 @@ var listTypes = function (p) {
         };
     }
 };
-var convertToLi = function (p) {
-    var content, name = p.nodeName.toLowerCase();
+const convertToLi = (p) => {
+    let content, name = p.nodeName.toLowerCase();
     if (p.firstChild && p.firstChild.nodeType === Node.COMMENT_NODE) {
         p.removeChild(p.firstChild);
     }
@@ -116,20 +116,20 @@ var convertToLi = function (p) {
         }
     }
     p.parentNode.removeChild(p);
-    var li = document.createElement('li');
-    li.appendChild((0, source_1.htmlToFragment)(content));
+    const li = document.createElement('li');
+    li.appendChild(source.htmlToFragment(content));
     return li;
 };
-var toList = function (blockNodes) {
-    var lastMargin = -1, levels = {}, li, rootMargin, rootIndex, lastRootLi, isLastRootLi, rootList, items, i, p, type, margin, list, listData;
+const toList = (blockNodes) => {
+    let lastMargin = -1, levels = {}, li, rootMargin, rootIndex, lastRootLi, isLastRootLi, rootList, items, i, p, type, margin, list, listData;
     for (i = 0; i < blockNodes.length; i++) {
         p = blockNodes[i];
         listData = {
             datalist: p.getAttribute('datalist'),
             datalevel: p.getAttribute('datalevel')
         };
-        var listIndex = listData.datalist;
-        var listType = listTypes(p);
+        const listIndex = listData.datalist;
+        const listType = listTypes(p);
         type = listType && listType.tag;
         if (!type) {
             if (li && (!isLastRootLi || isPartOfListItem(p))) {
@@ -148,14 +148,14 @@ var toList = function (blockNodes) {
         if (!listData.datalevel && !p.style.marginLeft) {
             continue;
         }
-        var levelType = type + listIndex;
+        const levelType = type + listIndex;
         if (!levels[margin]) {
             levels[margin] = {};
         }
         if (!rootMargin || rootMargin < 0) {
             rootMargin = margin;
             rootIndex = listIndex;
-            items = blockNodes.filter(function (e) { return e.getAttribute('datalist') === String(rootIndex); });
+            items = blockNodes.filter(e => e.getAttribute('datalist') === String(rootIndex));
             lastRootLi = items[items.length - 1];
             rootList = createList(type, listType && listType.style);
             p.parentNode.insertBefore(rootList, p);
@@ -179,11 +179,12 @@ var toList = function (blockNodes) {
         }
     }
 };
-var convertMsLists = function (html) {
-    var container = (0, source_1.htmlToFragment)(extractListLevels(html));
-    var groups = new Set();
+const convertMsLists = (html) => {
+    const container = source.htmlToFragment(extractListLevels(html));
+    const groups = new Set();
     mapListsCandidates(container.children, groups);
-    groups.forEach(function (listsCandidates) { return toList(listsCandidates); });
-    return (0, source_1.fragmentToHtml)(container);
+    groups.forEach(listsCandidates => toList(listsCandidates));
+    return source.fragmentToHtml(container);
 };
+
 exports.convertMsLists = convertMsLists;

package/dist/npm/lists.d.ts

@@ -1,8 +1,8 @@
-import { NodeType, Node } from 'prosemirror-model';
+import { Node } from 'prosemirror-model';
 import { EditorState, Transaction } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
-import { Command } from './types/command';
-declare type ListOptions = {
+
+type ListOptions = {
     listType: string;
     orderedList: string;
     bulletList: string;
@@ -15,9 +15,9 @@ declare type ListOptions = {
  * @param attrs - The attributes of the list node
  * @returns The extracted list-style-type.
  */
-export declare const listStyle: (attrs: Node['attrs']) => string;
-export declare const toggleList: (state: EditorState, dispatch: (tr: Transaction) => void, view: EditorView, options: ListOptions, command?: string) => boolean;
-export declare function toggleUnorderedList(state: EditorState, dispatch: (tr: Transaction) => void, view: EditorView): any;
-export declare function toggleOrderedList(state: EditorState, dispatch: (tr: Transaction) => void, view: EditorView): any;
-export declare const splitListItemKeepMarks: (itemType: NodeType) => Command;
-export {};
+declare const listStyle: (attrs: Node["attrs"]) => string;
+declare const toggleList: (state: EditorState, dispatch: (tr: Transaction) => void, view: EditorView, options: ListOptions, command?: string) => boolean;
+declare function toggleUnorderedList(state: EditorState, dispatch: (tr: Transaction) => void, view: EditorView): any;
+declare function toggleOrderedList(state: EditorState, dispatch: (tr: Transaction) => void, view: EditorView): any;
+
+export { listStyle, toggleList, toggleOrderedList, toggleUnorderedList };