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

package/dist/es/config/schema.js

@@ -1,112 +1,130 @@
-import { __assign } from "tslib";
 import { Schema } from 'prosemirror-model';
 import { tableNodes } from 'prosemirror-tables';
-import { domToPmDoc, htmlToFragment, pmDocToFragment } from '../source';
-import { rowTypeAttr, colgroupAttr, resizableAttr } from './constants';
-var hole = 0;
-var blockquoteDOM = ['blockquote', hole], hrDOM = ['hr'], preDOM = ['pre', ['code', hole]];
-var olDOM = ['ol', 0], ulDOM = ['ul', 0], liDOM = ['li', 0];
-var domAttributes = function (dom) {
-    var result = {};
-    var attributes = dom.attributes;
-    var attr;
-    for (var i = 0; i < attributes.length; i++) {
+import { domToPmDoc, htmlToFragment, pmDocToFragment } from '../source.js';
+import { colgroupAttr, rowTypeAttr, resizableAttr } from './constants.js';
+
+const hole = 0;
+const blockquoteDOM = ['blockquote', hole], hrDOM = ['hr'], preDOM = ['pre', ['code', hole]];
+const olDOM = ['ol', 0], ulDOM = ['ul', 0], liDOM = ['li', 0];
+const domAttributes = (dom) => {
+    const result = {};
+    const attributes = dom.attributes;
+    let attr;
+    for (let i = 0; i < attributes.length; i++) {
         attr = attributes[i];
         result[attr.name] = attr.value;
     }
     return result;
 };
-var defaultAttrs = function (attrs) {
-    var nodeAttrs = {};
-    attrs.forEach(function (attr) {
+const defaultAttrs = (attrs) => {
+    const nodeAttrs = {};
+    attrs.forEach(attr => {
         nodeAttrs[attr] = { default: null };
     });
     return nodeAttrs;
 };
-var commonAttributes = function () { return defaultAttrs(['style', 'class', 'id']); };
-var hasAttrs = function (attrs, exclude) {
-    for (var attr in attrs) {
+const commonAttributes = () => defaultAttrs(['style', 'class', 'id']);
+const hasAttrs = (attrs, exclude) => {
+    for (const attr in attrs) {
         if (attr && attrs[attr] !== null && attr !== exclude) {
             return true;
         }
     }
     return false;
 };
-var pmAttributes = function (attrs, exclude) {
-    if (exclude === void 0) { exclude = []; }
-    var result = {};
-    var _loop_1 = function (attr) {
-        if (attr && attrs[attr] !== null && !exclude.find(function (e) { return e === attr; })) {
+const pmAttributes = (attrs, exclude = []) => {
+    const result = {};
+    for (const attr in attrs) {
+        if (attr && attrs[attr] !== null && !exclude.find(e => e === attr)) {
             result[attr] = attrs[attr];
         }
-    };
-    for (var attr in attrs) {
-        _loop_1(attr);
     }
     return result;
 };
-var tagMark = function (tag) {
-    var _a;
-    return _a = {},
-        _a[tag] = {
+const tagMark = tag => {
+    return {
+        [tag]: {
             name: tag,
-            inclusive: true,
+            inclusive: true, // https://prosemirror.net/docs/ref/#model.MarkSpec.inclusive
             parseDOM: [{ tag: tag }],
-            toDOM: function () { return [tag, hole]; }
-        },
-        _a;
+            toDOM: () => [tag, hole]
+        }
+    };
 };
-var marks = __assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign(__assign({ 
+const marks = {
     // :: MarkSpec A link. Has `href` and `title` attributes. `title`
     // defaults to the empty string. Rendered and parsed as an `<a>`
     // element.
     link: {
-        attrs: __assign(__assign({}, commonAttributes()), { href: { default: null }, target: { default: null }, title: { default: null } }),
+        attrs: {
+            ...commonAttributes(),
+            href: { default: null },
+            target: { default: null },
+            title: { default: null }
+        },
         inclusive: false,
         parseDOM: [{ tag: 'a', getAttrs: domAttributes }],
-        toDOM: function (node) { return ['a', pmAttributes(node.attrs), hole]; }
-    } }, tagMark('strong')), tagMark('b')), tagMark('em')), tagMark('i')), tagMark('del')), tagMark('sub')), tagMark('sup')), tagMark('code')), { style: {
-        attrs: __assign({}, commonAttributes()),
+        toDOM: (node) => ['a', pmAttributes(node.attrs), hole]
+    },
+    ...tagMark('strong'),
+    ...tagMark('b'),
+    ...tagMark('em'),
+    ...tagMark('i'),
+    ...tagMark('del'),
+    ...tagMark('sub'),
+    ...tagMark('sup'),
+    ...tagMark('code'),
+    style: {
+        attrs: {
+            ...commonAttributes()
+        },
         parseDOM: [{
                 tag: 'span',
                 getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ?
-            ['span', pmAttributes(node.attrs), hole] : ['span', hole]; }
-    } }), tagMark('u'));
-var cellAttribute = function (name) {
-    var _a;
-    return _a = {},
-        _a[name] = {
+        toDOM: node => hasAttrs(node.attrs) ?
+            ['span', pmAttributes(node.attrs), hole] : ['span', hole]
+    },
+    ...tagMark('u')
+};
+const cellAttribute = (name) => {
+    return {
+        [name]: {
             default: null,
-            getFromDOM: function (cell) { return cell.getAttribute(name); },
-            setDOMAttr: function (value, attrs) { attrs[name] = value; }
-        },
-        _a;
+            getFromDOM: (cell) => cell.getAttribute(name),
+            setDOMAttr: (value, attrs) => { attrs[name] = value; }
+        }
+    };
+};
+const cellAttributes = {
+    ...cellAttribute('style'),
+    ...cellAttribute('class'),
+    ...cellAttribute('id'),
+    ...cellAttribute('headers'),
+    ...cellAttribute('scope')
 };
-var cellAttributes = __assign(__assign(__assign(__assign(__assign({}, cellAttribute('style')), cellAttribute('class')), cellAttribute('id')), cellAttribute('headers')), cellAttribute('scope'));
-var colgroupNodes = {
+const colgroupNodes = {
     doc: { content: 'colgroup*' },
     col: {
         attrs: defaultAttrs(['id', 'class', 'style', 'span']),
         parseDOM: [{ getAttrs: domAttributes, tag: 'col' }],
-        toDOM: function (node) { return ['col', node.attrs]; }
+        toDOM: node => ['col', node.attrs]
     },
     colgroup: {
         attrs: defaultAttrs(['id', 'class', 'style', 'span']),
         content: 'col*',
         parseDOM: [{ getAttrs: domAttributes, tag: 'colgroup' }],
-        toDOM: function (node) { return ['colgroup', node.attrs, 0]; }
+        toDOM: node => ['colgroup', node.attrs, 0]
     },
     text: { inline: true, group: 'inline' }
 };
-var colgroupSchema = new Schema({ nodes: colgroupNodes, marks: {} });
+const colgroupSchema = new Schema({ nodes: colgroupNodes, marks: {} });
 // will be removed when we implement our own columnResizing
-var shouldSkipColgroup = function (node) {
-    var shouldSkip = false;
-    var row = node.child(0);
-    for (var r = 0; r < row.childCount; r++) {
-        var cell = row.child(r);
+const shouldSkipColgroup = (node) => {
+    let shouldSkip = false;
+    const row = node.child(0);
+    for (let r = 0; r < row.childCount; r++) {
+        const cell = row.child(r);
         if (cell.attrs.colwidth) {
             shouldSkip = true;
             break;
@@ -114,24 +132,30 @@ var shouldSkipColgroup = function (node) {
     }
     return shouldSkip;
 };
-export var parseStrColgroup = function (colgroup) {
-    var doc = domToPmDoc(htmlToFragment(colgroup), colgroupSchema, { preserveWhitespace: false });
-    var fragment = pmDocToFragment(doc);
-    var colgroupEl = fragment.firstChild;
+const parseStrColgroup = (colgroup) => {
+    const doc = domToPmDoc(htmlToFragment(colgroup), colgroupSchema, { preserveWhitespace: false });
+    const fragment = pmDocToFragment(doc);
+    const colgroupEl = fragment.firstChild;
     return colgroupEl;
 };
-var tNodes = tableNodes({ tableGroup: 'block', cellContent: 'block+', cellAttributes: cellAttributes });
-tNodes.table_row.attrs = __assign(__assign({}, tNodes.table_row.attrs), defaultAttrs([rowTypeAttr, 'style', 'class', 'id']));
-tNodes.table_row.toDOM = function (node) { return ['tr', pmAttributes(node.attrs), 0]; };
+const tNodes = tableNodes({ tableGroup: 'block', cellContent: 'block+', cellAttributes });
+tNodes.table_row.attrs = {
+    ...tNodes.table_row.attrs,
+    ...defaultAttrs([rowTypeAttr, 'style', 'class', 'id'])
+};
+tNodes.table_row.toDOM = node => ['tr', pmAttributes(node.attrs), 0];
 tNodes.table_row.parseDOM = [{ tag: 'tr', getAttrs: domAttributes }];
-tNodes.table.attrs = __assign(__assign({}, tNodes.table.attrs), defaultAttrs(['style', 'class', 'id', colgroupAttr, resizableAttr]));
-tNodes.table.toDOM = function (node) {
-    var tableAttrs = hasAttrs(node.attrs) ? pmAttributes(node.attrs, [colgroupAttr, resizableAttr]) : {};
-    var colgroup = null;
+tNodes.table.attrs = {
+    ...tNodes.table.attrs,
+    ...defaultAttrs(['style', 'class', 'id', colgroupAttr, resizableAttr])
+};
+tNodes.table.toDOM = (node) => {
+    const tableAttrs = hasAttrs(node.attrs) ? pmAttributes(node.attrs, [colgroupAttr, resizableAttr]) : {};
+    let colgroup = null;
     if (node.attrs[colgroupAttr] && !shouldSkipColgroup(node)) {
-        var colgroupEl = parseStrColgroup(node.attrs[colgroupAttr]);
+        const colgroupEl = parseStrColgroup(node.attrs[colgroupAttr]);
         if (colgroupEl) {
-            var cols = Array.from(colgroupEl.children).map(function (c) { return ['col', domAttributes(c)]; });
+            const cols = Array.from(colgroupEl.children).map((c) => ['col', domAttributes(c)]);
             colgroup = [
                 'colgroup',
                 domAttributes(colgroupEl)
@@ -143,32 +167,35 @@ tNodes.table.toDOM = function (node) {
 };
 tNodes.table.parseDOM = [{
         tag: 'table',
-        getAttrs: function (node) {
-            var attrs = domAttributes(node);
-            var colgroup = Array.from(node.childNodes).find(function (c) { return c.nodeName === 'COLGROUP'; });
+        getAttrs: (node) => {
+            const attrs = domAttributes(node);
+            const colgroup = Array.from(node.childNodes).find(c => c.nodeName === 'COLGROUP');
             if (colgroup) {
                 attrs[colgroupAttr] = colgroup.outerHTML;
             }
             return attrs;
         }
     }];
-var nodes = __assign({ 
+const nodes = {
     // :: NodeSpec The top level document node.
     doc: {
         content: 'block+'
-    }, 
+    },
     // :: NodeSpec A plain paragraph textblock. Represented in the DOM
     // as a `<p>` element.
     paragraph: {
         content: 'inline*',
         group: 'block',
-        attrs: __assign({}, commonAttributes()),
+        attrs: {
+            ...commonAttributes()
+        },
         parseDOM: [{
                 tag: 'p',
                 getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['p', pmAttributes(node.attrs), hole] : ['p', hole]; }
-    }, table_wrapper: {
+        toDOM: node => hasAttrs(node.attrs) ? ['p', pmAttributes(node.attrs), hole] : ['p', hole]
+    },
+    table_wrapper: {
         content: '(table_caption_external | table)+',
         group: 'block',
         defining: true,
@@ -180,66 +207,78 @@ var nodes = __assign({
                 tag: 'div[table]',
                 getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]; }
-    }, table_caption_external: {
+        toDOM: node => hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]
+    },
+    table_caption_external: {
         content: 'inline+',
         group: 'block',
-        attrs: __assign({ caption: { default: null } }, commonAttributes()),
+        attrs: {
+            caption: { default: null },
+            ...commonAttributes()
+        },
         parseDOM: [{
                 tag: 'div[caption]',
                 getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]; }
-    }, div: {
+        toDOM: node => hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]
+    },
+    div: {
         // Uncaught SyntaxError: Mixing inline and block content (in content expression '(block | inline)*')
         // content: '(block | inline)*',
         content: 'block*',
         group: 'block',
-        attrs: __assign({}, commonAttributes()),
+        attrs: {
+            ...commonAttributes()
+        },
         parseDOM: [{
                 tag: 'div',
                 getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]; }
-    }, 
+        toDOM: node => hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]
+    },
     // :: NodeSpec A blockquote (`<blockquote>`) wrapping one or more blocks.
     blockquote: {
-        attrs: __assign({}, commonAttributes()),
+        attrs: {
+            ...commonAttributes()
+        },
         content: 'block+',
         group: 'block',
-        defining: true,
+        defining: true, // https://prosemirror.net/docs/ref/#model.NodeSpec.defining
         parseDOM: [{
                 tag: 'blockquote',
                 getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['blockquote', pmAttributes(node.attrs), hole] : blockquoteDOM; }
-    }, 
+        toDOM: node => hasAttrs(node.attrs) ? ['blockquote', pmAttributes(node.attrs), hole] : blockquoteDOM
+    },
     // :: NodeSpec A horizontal rule (`<hr>`).
     horizontal_rule: {
         group: 'block',
         parseDOM: [{ tag: 'hr' }],
-        toDOM: function () { return hrDOM; }
-    }, 
+        toDOM: () => hrDOM
+    },
     // :: NodeSpec A heading textblock, with a `level` attribute that
     // has to hold the numbers from 1 to 6. Parsed and serialized as `<h1>` to
     // `<h6>` elements.
     heading: {
-        attrs: __assign(__assign({}, commonAttributes()), { level: { default: 1 } }),
+        attrs: {
+            ...commonAttributes(),
+            level: { default: 1 }
+        },
         content: 'inline*',
         group: 'block',
         defining: true,
         parseDOM: [
-            { tag: 'h1', getAttrs: function (node) { return (__assign(__assign({}, domAttributes(node)), { level: 1 })); } },
-            { tag: 'h2', getAttrs: function (node) { return (__assign(__assign({}, domAttributes(node)), { level: 2 })); } },
-            { tag: 'h3', getAttrs: function (node) { return (__assign(__assign({}, domAttributes(node)), { level: 3 })); } },
-            { tag: 'h4', getAttrs: function (node) { return (__assign(__assign({}, domAttributes(node)), { level: 4 })); } },
-            { tag: 'h5', getAttrs: function (node) { return (__assign(__assign({}, domAttributes(node)), { level: 5 })); } },
-            { tag: 'h6', getAttrs: function (node) { return (__assign(__assign({}, domAttributes(node)), { level: 6 })); } }
+            { tag: 'h1', getAttrs: node => ({ ...domAttributes(node), level: 1 }) },
+            { tag: 'h2', getAttrs: node => ({ ...domAttributes(node), level: 2 }) },
+            { tag: 'h3', getAttrs: node => ({ ...domAttributes(node), level: 3 }) },
+            { tag: 'h4', getAttrs: node => ({ ...domAttributes(node), level: 4 }) },
+            { tag: 'h5', getAttrs: node => ({ ...domAttributes(node), level: 5 }) },
+            { tag: 'h6', getAttrs: node => ({ ...domAttributes(node), level: 6 }) }
         ],
-        toDOM: function (node) { return hasAttrs(node.attrs, 'level') ?
+        toDOM: node => hasAttrs(node.attrs, 'level') ?
             ['h' + node.attrs.level, pmAttributes(node.attrs, ['level']), hole] :
-            ['h' + node.attrs.level, hole]; }
-    }, 
+            ['h' + node.attrs.level, hole]
+    },
     // :: NodeSpec A code listing. Disallows marks or non-text inline
     // nodes by default. Represented as a `<pre>` element with a
     // `<code>` element inside it.
@@ -250,36 +289,45 @@ var nodes = __assign({
         code: true,
         defining: true,
         parseDOM: [{ tag: 'pre', preserveWhitespace: 'full' }],
-        toDOM: function () { return preDOM; }
-    }, 
+        toDOM: () => preDOM
+    },
     // :: NodeSpec The text node.
     text: {
         inline: true,
         group: 'inline'
-    }, 
+    },
     // :: NodeSpec An inline image (`<img>`) node. Supports `src`,
     // `alt`, and `href` attributes. The latter two default to an empty
     // string.
     image: {
         inline: true,
-        attrs: __assign({ src: { default: null }, alt: { default: null }, title: { default: null }, width: { default: null }, height: { default: null } }, commonAttributes()),
+        attrs: {
+            src: { default: null },
+            alt: { default: null },
+            title: { default: null },
+            width: { default: null },
+            height: { default: null },
+            ...commonAttributes()
+        },
         group: 'inline',
         draggable: true,
         parseDOM: [{ tag: 'img', getAttrs: domAttributes }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['img', pmAttributes(node.attrs)] : ['img']; }
-    }, 
+        toDOM: node => hasAttrs(node.attrs) ? ['img', pmAttributes(node.attrs)] : ['img']
+    },
     // :: NodeSpec A hard line break represented in the DOM as a `<br>` element.
     hard_break: {
         inline: true,
-        attrs: __assign({}, commonAttributes()),
+        attrs: {
+            ...commonAttributes()
+        },
         group: 'inline',
         selectable: false,
         parseDOM: [{
                 tag: 'br',
                 getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['br', pmAttributes(node.attrs)] : ['br']; }
-    }, 
+        toDOM: node => hasAttrs(node.attrs) ? ['br', pmAttributes(node.attrs)] : ['br']
+    },
     // :: NodeSpec
     // An ordered list [node spec](#model.NodeSpec). Has a single
     // attribute, `order`, which determines the number at which the list
@@ -288,32 +336,42 @@ var nodes = __assign({
     ordered_list: {
         content: 'list_item+',
         group: 'block',
-        attrs: __assign(__assign({}, commonAttributes()), { type: { default: null }, order: { default: 1 } }),
-        parseDOM: [{ tag: 'ol', getAttrs: function (dom) {
-                    return __assign(__assign({}, domAttributes(dom)), { order: dom.hasAttribute('start') ? parseInt(dom.getAttribute('start') || '1', 10) : 1 });
+        attrs: {
+            ...commonAttributes(),
+            type: { default: null },
+            order: { default: 1 }
+        },
+        parseDOM: [{ tag: 'ol', getAttrs: (dom) => {
+                    return {
+                        ...domAttributes(dom),
+                        order: dom.hasAttribute('start') ? parseInt(dom.getAttribute('start') || '1', 10) : 1
+                    };
                 } }],
-        toDOM: function (node) {
+        toDOM: node => {
             return node.attrs.order === 1 ?
                 (hasAttrs(node.attrs, 'order') ? ['ol', pmAttributes(node.attrs, ['order']), hole] : olDOM) :
-                ['ol', __assign(__assign({}, pmAttributes(node.attrs, ['order'])), { start: node.attrs.order }), hole];
+                ['ol', { ...pmAttributes(node.attrs, ['order']), start: node.attrs.order }, hole];
         }
-    }, 
+    },
     // :: NodeSpec
     // A bullet list node specification represented in the DOM as a `<ul>` element.
     bullet_list: {
         content: 'list_item+',
         group: 'block',
-        attrs: __assign({}, commonAttributes()),
+        attrs: { ...commonAttributes() },
         parseDOM: [{ tag: 'ul', getAttrs: domAttributes }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['ul', pmAttributes(node.attrs), hole] : ulDOM; }
-    }, 
+        toDOM: node => hasAttrs(node.attrs) ? ['ul', pmAttributes(node.attrs), hole] : ulDOM
+    },
     // :: NodeSpec
     // A list item (`<li>`) specification.
     list_item: {
         content: '(paragraph | heading) block*',
-        attrs: __assign({}, commonAttributes()),
+        attrs: { ...commonAttributes() },
         parseDOM: [{ tag: 'li', getAttrs: domAttributes }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['li', pmAttributes(node.attrs), hole] : liDOM; },
+        toDOM: node => hasAttrs(node.attrs) ? ['li', pmAttributes(node.attrs), hole] : liDOM,
         defining: true
-    } }, tNodes);
-export { nodes, marks };
+    },
+    ...tNodes
+};
+
+export { marks, nodes, parseStrColgroup };

package/dist/es/find-replace.js

@@ -1,10 +1,10 @@
-import { __rest } from "tslib";
 import { TextSelection } from 'prosemirror-state';
-export var findAt = function (doc, searchOptions, start, end, exit) {
-    var result = [], exec, text, from, to, childText, nextSibling;
-    var nodes = [];
-    var matchCase = searchOptions.matchCase, matchWord = searchOptions.matchWord, useRegExp = searchOptions.useRegExp;
-    var searchText = searchOptions.text;
+
+const findAt = (doc, searchOptions, start, end, exit) => {
+    let result = [], exec, text, from, to, childText, nextSibling;
+    const nodes = [];
+    const { matchCase, matchWord, useRegExp } = searchOptions;
+    let searchText = searchOptions.text;
     if (useRegExp && (/^\\$/.test(searchText) || /[^\\]\\$/.test(searchText))) {
         // lookbehind doesn't work in Edge -> /((?<!\\)\\)$/.test(searchText)
         searchText = searchText.substring(0, searchText.length - 1);
@@ -12,19 +12,19 @@ export var findAt = function (doc, searchOptions, start, end, exit) {
     if (!searchText) {
         return result;
     }
-    var flags = matchCase ? 'g' : 'gi';
-    var regExp = useRegExp ? new RegExp(searchText, flags) : createRegExp(searchText, flags);
-    doc.nodesBetween(start, end, function (node, pos) {
+    const flags = matchCase ? 'g' : 'gi';
+    const regExp = useRegExp ? new RegExp(searchText, flags) : createRegExp(searchText, flags);
+    doc.nodesBetween(start, end, (node, pos) => {
         if (exit(result)) {
             return false;
         }
         if (node.inlineContent && pos + node.content.size >= start) {
             nodes.length = 0;
-            node.nodesBetween(0, node.content.size, function (child, childPos, parent, i) {
+            node.nodesBetween(0, node.content.size, (child, childPos, parent, i) => {
                 if (exit(result)) {
                     return false;
                 }
-                var posToDoc = 1 + pos + childPos;
+                const posToDoc = 1 + pos + childPos;
                 if (child.isText && posToDoc + child.nodeSize >= start) {
                     childText = child.text || '';
                     nextSibling = parent.childCount - 1 >= i + 1 && parent.child(i + 1);
@@ -34,7 +34,7 @@ export var findAt = function (doc, searchOptions, start, end, exit) {
                     if (nextSibling && nextSibling.isText) {
                         return;
                     }
-                    text = nodes.map(function (t) { return t.text; }).join('');
+                    text = nodes.map(t => t.text).join('');
                     exec = regExp.exec(text);
                     while (exec !== null) {
                         from = nodes[0].start + exec.index;
@@ -56,11 +56,11 @@ export var findAt = function (doc, searchOptions, start, end, exit) {
     });
     return result;
 };
-export var find = function (state, searchOptions) {
-    var backward = searchOptions.backward, matchCyclic = searchOptions.matchCyclic, options = __rest(searchOptions, ["backward", "matchCyclic"]);
-    var exit = backward ? function () { return false; } : function (r) { return r.length > 0; };
-    var doc = state.doc, selection = state.selection;
-    var result = [];
+const find = (state, searchOptions) => {
+    const { backward, matchCyclic, ...options } = searchOptions;
+    const exit = backward ? () => false : r => r.length > 0;
+    const { doc, selection } = state;
+    let result = [];
     if (backward) {
         result = findAt(doc, options, 0, selection.from, exit);
         if (!result.length && matchCyclic) {
@@ -75,45 +75,47 @@ export var find = function (state, searchOptions) {
     }
     return result.length ? result[result.length - 1] : null;
 };
-export var findAll = function (doc, searchOptions) {
-    return findAt(doc, searchOptions, 0, doc.content.size, function () { return false; });
+const findAll = (doc, searchOptions) => {
+    return findAt(doc, searchOptions, 0, doc.content.size, () => false);
 };
-export var replace = function (selection, text, transaction) {
-    var from = selection.from, to = selection.to;
+const replace = (selection, text, transaction) => {
+    const { from, to } = selection;
     transaction.insertText(text, from, to)
         .setSelection(TextSelection.create(transaction.doc, from, from + text.length));
     return transaction;
 };
-export var replaceAll = function (state, replaceText, searchOptions) {
-    var result = findAll(state.doc, searchOptions);
+const replaceAll = (state, replaceText, searchOptions) => {
+    const result = findAll(state.doc, searchOptions);
     if (result.length === 0) {
         return null;
     }
-    var transaction = state.tr;
-    for (var i = result.length - 1; i >= 0; i--) {
+    const transaction = state.tr;
+    for (let i = result.length - 1; i >= 0; i--) {
         transaction.insertText(replaceText, result[i].from, result[i].to);
     }
     return transaction;
 };
-var notLetter = /^[\s0-9~`!@#$%\^&*\(\)_\-=+\\|\[\]{};:'"\?/.,<>]?$/;
-var shouldMatchWord = function (exec, matchWord) {
+const notLetter = /^[\s0-9~`!@#$%\^&*\(\)_\-=+\\|\[\]{};:'"\?/.,<>]?$/;
+const shouldMatchWord = (exec, matchWord) => {
     if (!matchWord) {
         return true;
     }
     else if (matchWord === true) {
-        var text = exec.input;
-        var charBefore = text.charAt(exec.index - 1);
-        var charAfter = text.charAt(exec.index + exec[0].length);
+        const text = exec.input;
+        const charBefore = text.charAt(exec.index - 1);
+        const charAfter = text.charAt(exec.index + exec[0].length);
         return notLetter.test(charBefore) && notLetter.test(charAfter);
     }
     else {
         return matchWord(exec);
     }
 };
-var createRegExp = function (inputString, flags) {
-    var escaped = inputString
+const createRegExp = (inputString, flags) => {
+    const escaped = inputString
         .replace(/[|\\{}()[\]^$+*?.]/g, '\\$&')
         .replace(/-/g, '\\x2d')
         .replace(/\s/g, '\\s');
     return new RegExp(escaped, flags);
 };
+
+export { find, findAll, findAt, replace, replaceAll };

package/dist/es/image.js

@@ -1,7 +1,10 @@
-import { insertNode } from './utils';
-export var insertImage = function (attrs) { return function (state, dispatch) {
-    var image = state.schema.nodes.image;
-    var commandName = 'insertImage';
-    var newImage = image.createAndFill(attrs);
-    insertNode(newImage)(state, function (tr) { return dispatch(tr.setMeta('commandName', commandName).setMeta('args', attrs)); });
-}; };
+import { insertNode } from './utils.js';
+
+const insertImage = (attrs) => (state, dispatch) => {
+    const { image } = state.schema.nodes;
+    const commandName = 'insertImage';
+    const newImage = image.createAndFill(attrs);
+    insertNode(newImage)(state, tr => dispatch(tr.setMeta('commandName', commandName).setMeta('args', attrs)));
+};
+
+export { insertImage };