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

package/dist/npm/config/schema.js

@@ -1,116 +1,132 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.marks = exports.nodes = exports.parseStrColgroup = void 0;
-var tslib_1 = require("tslib");
-var prosemirror_model_1 = require("prosemirror-model");
-var prosemirror_tables_1 = require("prosemirror-tables");
-var source_1 = require("../source");
-var constants_1 = require("./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++) {
+'use strict';
+
+var prosemirrorModel = require('prosemirror-model');
+var prosemirrorTables = require('prosemirror-tables');
+var source = require('../source.js');
+var constants = require('./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 = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__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: tslib_1.__assign(tslib_1.__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: tslib_1.__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'));
-exports.marks = marks;
-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 = tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__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 prosemirror_model_1.Schema({ nodes: colgroupNodes, marks: {} });
+const colgroupSchema = new prosemirrorModel.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;
@@ -118,25 +134,30 @@ var shouldSkipColgroup = function (node) {
     }
     return shouldSkip;
 };
-var parseStrColgroup = function (colgroup) {
-    var doc = (0, source_1.domToPmDoc)((0, source_1.htmlToFragment)(colgroup), colgroupSchema, { preserveWhitespace: false });
-    var fragment = (0, source_1.pmDocToFragment)(doc);
-    var colgroupEl = fragment.firstChild;
+const parseStrColgroup = (colgroup) => {
+    const doc = source.domToPmDoc(source.htmlToFragment(colgroup), colgroupSchema, { preserveWhitespace: false });
+    const fragment = source.pmDocToFragment(doc);
+    const colgroupEl = fragment.firstChild;
     return colgroupEl;
 };
-exports.parseStrColgroup = parseStrColgroup;
-var tNodes = (0, prosemirror_tables_1.tableNodes)({ tableGroup: 'block', cellContent: 'block+', cellAttributes: cellAttributes });
-tNodes.table_row.attrs = tslib_1.__assign(tslib_1.__assign({}, tNodes.table_row.attrs), defaultAttrs([constants_1.rowTypeAttr, 'style', 'class', 'id']));
-tNodes.table_row.toDOM = function (node) { return ['tr', pmAttributes(node.attrs), 0]; };
+const tNodes = prosemirrorTables.tableNodes({ tableGroup: 'block', cellContent: 'block+', cellAttributes });
+tNodes.table_row.attrs = {
+    ...tNodes.table_row.attrs,
+    ...defaultAttrs([constants.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 = tslib_1.__assign(tslib_1.__assign({}, tNodes.table.attrs), defaultAttrs(['style', 'class', 'id', constants_1.colgroupAttr, constants_1.resizableAttr]));
-tNodes.table.toDOM = function (node) {
-    var tableAttrs = hasAttrs(node.attrs) ? pmAttributes(node.attrs, [constants_1.colgroupAttr, constants_1.resizableAttr]) : {};
-    var colgroup = null;
-    if (node.attrs[constants_1.colgroupAttr] && !shouldSkipColgroup(node)) {
-        var colgroupEl = (0, exports.parseStrColgroup)(node.attrs[constants_1.colgroupAttr]);
+tNodes.table.attrs = {
+    ...tNodes.table.attrs,
+    ...defaultAttrs(['style', 'class', 'id', constants.colgroupAttr, constants.resizableAttr])
+};
+tNodes.table.toDOM = (node) => {
+    const tableAttrs = hasAttrs(node.attrs) ? pmAttributes(node.attrs, [constants.colgroupAttr, constants.resizableAttr]) : {};
+    let colgroup = null;
+    if (node.attrs[constants.colgroupAttr] && !shouldSkipColgroup(node)) {
+        const colgroupEl = parseStrColgroup(node.attrs[constants.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)
@@ -148,32 +169,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[constants_1.colgroupAttr] = colgroup.outerHTML;
+                attrs[constants.colgroupAttr] = colgroup.outerHTML;
             }
             return attrs;
         }
     }];
-var nodes = tslib_1.__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: tslib_1.__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,
@@ -185,66 +209,78 @@ var nodes = tslib_1.__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: tslib_1.__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: tslib_1.__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: tslib_1.__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: tslib_1.__assign(tslib_1.__assign({}, commonAttributes()), { level: { default: 1 } }),
+        attrs: {
+            ...commonAttributes(),
+            level: { default: 1 }
+        },
         content: 'inline*',
         group: 'block',
         defining: true,
         parseDOM: [
-            { tag: 'h1', getAttrs: function (node) { return (tslib_1.__assign(tslib_1.__assign({}, domAttributes(node)), { level: 1 })); } },
-            { tag: 'h2', getAttrs: function (node) { return (tslib_1.__assign(tslib_1.__assign({}, domAttributes(node)), { level: 2 })); } },
-            { tag: 'h3', getAttrs: function (node) { return (tslib_1.__assign(tslib_1.__assign({}, domAttributes(node)), { level: 3 })); } },
-            { tag: 'h4', getAttrs: function (node) { return (tslib_1.__assign(tslib_1.__assign({}, domAttributes(node)), { level: 4 })); } },
-            { tag: 'h5', getAttrs: function (node) { return (tslib_1.__assign(tslib_1.__assign({}, domAttributes(node)), { level: 5 })); } },
-            { tag: 'h6', getAttrs: function (node) { return (tslib_1.__assign(tslib_1.__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.
@@ -255,36 +291,45 @@ var nodes = tslib_1.__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: tslib_1.__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: tslib_1.__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
@@ -293,32 +338,44 @@ var nodes = tslib_1.__assign({
     ordered_list: {
         content: 'list_item+',
         group: 'block',
-        attrs: tslib_1.__assign(tslib_1.__assign({}, commonAttributes()), { type: { default: null }, order: { default: 1 } }),
-        parseDOM: [{ tag: 'ol', getAttrs: function (dom) {
-                    return tslib_1.__assign(tslib_1.__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', tslib_1.__assign(tslib_1.__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: tslib_1.__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: tslib_1.__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);
+    },
+    ...tNodes
+};
+
+exports.marks = marks;
 exports.nodes = nodes;
+exports.parseStrColgroup = parseStrColgroup;

package/dist/npm/find-replace.d.ts

@@ -1,6 +1,7 @@
-import { TextSelection, Selection, Transaction, EditorState } from 'prosemirror-state';
+import { TextSelection, EditorState, Selection, Transaction } from 'prosemirror-state';
 import { Node } from 'prosemirror-model';
-export interface SearchOptions {
+
+interface SearchOptions {
     text: string;
     backward?: boolean;
     matchCyclic?: boolean;
@@ -8,14 +9,16 @@ export interface SearchOptions {
     matchWord?: boolean | ((exec: RegExpExecArray) => boolean);
     useRegExp?: boolean;
 }
-export declare const findAt: (doc: Node, searchOptions: SearchOptions, start: number, end: number, exit: (result: TextSelection[]) => boolean) => TextSelection[];
-export declare const find: (state: EditorState | {
+declare const findAt: (doc: Node, searchOptions: SearchOptions, start: number, end: number, exit: (result: TextSelection[]) => boolean) => TextSelection[];
+declare const find: (state: EditorState | {
     doc: Node;
     selection: Selection;
 }, searchOptions: SearchOptions) => TextSelection | null;
-export declare const findAll: (doc: Node, searchOptions: SearchOptions) => TextSelection[];
-export declare const replace: (selection: Selection | {
+declare const findAll: (doc: Node, searchOptions: SearchOptions) => TextSelection[];
+declare const replace: (selection: Selection | {
     from: number;
     to: number;
 }, text: string, transaction: Transaction) => Transaction;
-export declare const replaceAll: (state: EditorState, replaceText: string, searchOptions: SearchOptions) => Transaction | null;
+declare const replaceAll: (state: EditorState, replaceText: string, searchOptions: SearchOptions) => Transaction | null;
+
+export { type SearchOptions, find, findAll, findAt, replace, replaceAll };