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

package/dist/es/DOMSerializer.js

@@ -1,25 +1,10 @@
-import { setAttribute } from './utils';
-var DOMSerializer = /** @class */ (function () {
-    /// Create a serializer. `nodes` should map node names to functions
-    /// that take a node and return a description of the corresponding
-    /// DOM. `marks` does the same for mark names, but also gets an
-    /// argument that tells it whether the mark's content is block or
-    /// inline content (for typical use, it'll always be inline). A mark
-    /// serializer may be `null` to indicate that marks of that type
-    /// should not be serialized.
-    function DOMSerializer(
-    /// The node serialization functions.
-    nodes, 
-    /// The mark serialization functions.
-    marks) {
-        this.nodes = nodes;
-        this.marks = marks;
-    }
+import { setAttribute } from './utils.js';
+
+class DOMSerializer {
     /// Render an [output spec](#model.DOMOutputSpec) to a DOM node. If
     /// the spec has a hole (zero) in it, `contentDOM` will point at the
     /// node with the hole.
-    DOMSerializer.renderSpec = function (docum, structure, xmlNS) {
-        if (xmlNS === void 0) { xmlNS = null; }
+    static renderSpec(docum, structure, xmlNS = null) {
         if (typeof structure === 'string') {
             return { dom: docum.createTextNode(structure) };
         }
@@ -29,38 +14,38 @@ var DOMSerializer = /** @class */ (function () {
         if (structure.dom && structure.dom.nodeType != null) {
             return structure;
         }
-        var tagName = structure[0], space = tagName.indexOf(' ');
+        let tagName = structure[0], space = tagName.indexOf(' ');
         if (space > 0) {
             xmlNS = tagName.slice(0, space);
             tagName = tagName.slice(space + 1);
         }
-        var contentDOM;
-        var dom = (xmlNS ? docum.createElementNS(xmlNS, tagName) : docum.createElement(tagName));
-        var attrs = structure[1], start = 1;
+        let contentDOM;
+        const dom = (xmlNS ? docum.createElementNS(xmlNS, tagName) : docum.createElement(tagName));
+        let attrs = structure[1], start = 1;
         if (attrs && typeof attrs === 'object' && attrs.nodeType == null && !Array.isArray(attrs)) {
             start = 2;
-            for (var name_1 in attrs) {
-                if (attrs[name_1] != null) {
-                    space = name_1.indexOf(' ');
+            for (const name in attrs) {
+                if (attrs[name] != null) {
+                    space = name.indexOf(' ');
                     if (space > 0) {
-                        dom.setAttributeNS(name_1.slice(0, space), name_1.slice(space + 1), attrs[name_1]);
+                        dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
                     }
                     else {
-                        setAttribute(dom, name_1, attrs[name_1]);
+                        setAttribute(dom, name, attrs[name]);
                     }
                 }
             }
         }
-        for (var i = start; i < structure.length; i++) {
-            var child = structure[i];
+        for (let i = start; i < structure.length; i++) {
+            const child = structure[i];
             if (child === 0) {
                 if (i < structure.length - 1 || i > start) {
                     throw new RangeError('Content hole must be the only child of its parent node');
                 }
-                return { dom: dom, contentDOM: dom };
+                return { dom, contentDOM: dom };
             }
             else {
-                var _a = DOMSerializer.renderSpec(docum, child, xmlNS), inner = _a.dom, innerContent = _a.contentDOM;
+                const { dom: inner, contentDOM: innerContent } = DOMSerializer.renderSpec(docum, child, xmlNS);
                 dom.appendChild(inner);
                 if (innerContent) {
                     if (contentDOM) {
@@ -70,44 +55,57 @@ var DOMSerializer = /** @class */ (function () {
                 }
             }
         }
-        return { dom: dom, contentDOM: contentDOM };
-    };
+        return { dom, contentDOM };
+    }
     /// Build a serializer using the [`toDOM`](#model.NodeSpec.toDOM)
     /// properties in a schema's node and mark specs.
-    DOMSerializer.fromSchema = function (schema) {
+    static fromSchema(schema) {
         return schema.cached.domSerializer ||
             (schema.cached.domSerializer = new DOMSerializer(this.nodesFromSchema(schema), this.marksFromSchema(schema)));
-    };
+    }
     /// Gather the serializers in a schema's node specs into an object.
     /// This can be useful as a base to build a custom serializer from.
-    DOMSerializer.nodesFromSchema = function (schema) {
-        var result = gatherToDOM(schema.nodes);
+    static nodesFromSchema(schema) {
+        const result = gatherToDOM(schema.nodes);
         if (!result.text) {
-            result.text = function (node) { return node.text; };
+            result.text = node => node.text;
         }
         return result;
-    };
+    }
     /// Gather the serializers in a schema's mark specs into an object.
-    DOMSerializer.marksFromSchema = function (schema) {
+    static marksFromSchema(schema) {
         return gatherToDOM(schema.marks);
-    };
+    }
+    /// Create a serializer. `nodes` should map node names to functions
+    /// that take a node and return a description of the corresponding
+    /// DOM. `marks` does the same for mark names, but also gets an
+    /// argument that tells it whether the mark's content is block or
+    /// inline content (for typical use, it'll always be inline). A mark
+    /// serializer may be `null` to indicate that marks of that type
+    /// should not be serialized.
+    constructor(
+    /// The node serialization functions.
+    nodes, 
+    /// The mark serialization functions.
+    marks) {
+        this.nodes = nodes;
+        this.marks = marks;
+    }
     /// Serialize the content of this fragment to a DOM fragment. When
     /// not in the browser, the `document` option, containing a DOM
     /// document, should be passed so that the serializer can create
     /// nodes.
-    DOMSerializer.prototype.serializeFragment = function (fragment, options, target) {
-        var _this = this;
-        if (options === void 0) { options = {}; }
+    serializeFragment(fragment, options = {}, target) {
         if (!target) {
             target = doc(options).createDocumentFragment();
         }
-        var top = target, active = [];
-        fragment.forEach(function (node) {
+        let top = target, active = [];
+        fragment.forEach(node => {
             if (active.length || node.marks.length) {
-                var keep = 0, rendered = 0;
+                let keep = 0, rendered = 0;
                 while (keep < active.length && rendered < node.marks.length) {
-                    var next = node.marks[rendered];
-                    if (!_this.marks[next.type.name]) {
+                    const next = node.marks[rendered];
+                    if (!this.marks[next.type.name]) {
                         rendered++;
                         continue;
                     }
@@ -121,8 +119,8 @@ var DOMSerializer = /** @class */ (function () {
                     top = active.pop()[1];
                 }
                 while (rendered < node.marks.length) {
-                    var add = node.marks[rendered++];
-                    var markDOM = _this.serializeMark(add, node.isInline, options);
+                    const add = node.marks[rendered++];
+                    const markDOM = this.serializeMark(add, node.isInline, options);
                     if (markDOM) {
                         active.push([add, top]);
                         top.appendChild(markDOM.dom);
@@ -130,36 +128,34 @@ var DOMSerializer = /** @class */ (function () {
                     }
                 }
             }
-            top.appendChild(_this.serializeNodeInner(node, options));
+            top.appendChild(this.serializeNodeInner(node, options));
         });
         return target;
-    };
+    }
     /// Serialize this node to a DOM node. This can be useful when you
     /// need to serialize a part of a document, as opposed to the whole
     /// document. To serialize a whole document, use
     /// [`serializeFragment`](#model.DOMSerializer.serializeFragment) on
     /// its [content](#model.Node.content).
-    DOMSerializer.prototype.serializeNode = function (node, options) {
-        if (options === void 0) { options = {}; }
-        var dom = this.serializeNodeInner(node, options);
-        for (var i = node.marks.length - 1; i >= 0; i--) {
-            var wrap = this.serializeMark(node.marks[i], node.isInline, options);
+    serializeNode(node, options = {}) {
+        let dom = this.serializeNodeInner(node, options);
+        for (let i = node.marks.length - 1; i >= 0; i--) {
+            const wrap = this.serializeMark(node.marks[i], node.isInline, options);
             if (wrap) {
                 (wrap.contentDOM || wrap.dom).appendChild(dom);
                 dom = wrap.dom;
             }
         }
         return dom;
-    };
+    }
     /// @internal
-    DOMSerializer.prototype.serializeMark = function (mark, inline, options) {
-        if (options === void 0) { options = {}; }
-        var toDOM = this.marks[mark.type.name];
+    serializeMark(mark, inline, options = {}) {
+        const toDOM = this.marks[mark.type.name];
         return toDOM && DOMSerializer.renderSpec(doc(options), toDOM(mark, inline));
-    };
+    }
     /// @internal
-    DOMSerializer.prototype.serializeNodeInner = function (node, options) {
-        var _a = DOMSerializer.renderSpec(doc(options), this.nodes[node.type.name](node)), dom = _a.dom, contentDOM = _a.contentDOM;
+    serializeNodeInner(node, options) {
+        const { dom, contentDOM } = DOMSerializer.renderSpec(doc(options), this.nodes[node.type.name](node));
         if (contentDOM) {
             if (node.isLeaf) {
                 throw new RangeError('Content hole not allowed in a leaf node spec');
@@ -167,17 +163,15 @@ var DOMSerializer = /** @class */ (function () {
             this.serializeFragment(node.content, options, contentDOM);
         }
         return dom;
-    };
-    return DOMSerializer;
-}());
-export { DOMSerializer };
+    }
+}
 function gatherToDOM(obj) {
-    var result = {};
-    for (var name_2 in obj) {
-        if (obj[name_2]) {
-            var toDOM = obj[name_2].spec.toDOM;
+    const result = {};
+    for (const name in obj) {
+        if (obj[name]) {
+            const toDOM = obj[name].spec.toDOM;
             if (toDOM) {
-                result[name_2] = toDOM;
+                result[name] = toDOM;
             }
         }
     }
@@ -186,3 +180,5 @@ function gatherToDOM(obj) {
 function doc(options) {
     return options.document || window.document;
 }
+
+export { DOMSerializer };

package/dist/es/align.js

@@ -1,40 +1,43 @@
-import { blockNodes, addStyles, changeTextBlock } from './blockNode';
+import { blockNodes, addStyles, changeTextBlock } from './blockNode.js';
+
 /**
  * Aligning block elements in the selection.
  *
  * @returns {boolean} - Returns true if any alignment is applied.
  */
-export var alignBlocks = function (actions, commandName) { return function (state, dispatch) {
-    var blocks = blockNodes(state);
-    var tr = state.tr;
+const alignBlocks = (actions, commandName) => (state, dispatch) => {
+    const blocks = blockNodes(state);
+    const tr = state.tr;
     tr.setMeta('commandName', commandName);
-    blocks.forEach(function (node) {
+    blocks.forEach(node => {
         if (node.type.isTextblock) {
-            var action = actions.find(function (n) { return n.node === node.type.name; });
+            const action = actions.find(n => n.node === node.type.name);
             if (action) {
-                var newAttrs = addStyles(node, action.style);
+                const newAttrs = addStyles(node, action.style);
                 changeTextBlock(tr, node, node.type, newAttrs);
             }
         }
     });
-    var result = tr.docChanged;
+    const result = tr.docChanged;
     if (result) {
         dispatch(tr.scrollIntoView());
     }
     return result;
-}; };
-export var isAligned = function (state, actions) {
-    var blocks = blockNodes(state);
-    var result = false;
-    blocks.forEach(function (node) {
+};
+const isAligned = (state, actions) => {
+    const blocks = blockNodes(state);
+    let result = false;
+    blocks.forEach(node => {
         if (!result && node.type.isTextblock && node.attrs.style) {
-            var action = actions.find(function (a) { return a.node === node.type.name; });
+            const action = actions.find(a => a.node === node.type.name);
             if (action) {
-                result = action.style.every(function (style) {
-                    return !!style.value && new RegExp("".concat(style.name, ":\\s?").concat(style.value), 'i').test(node.attrs.style);
+                result = action.style.every(style => {
+                    return !!style.value && new RegExp(`${style.name}:\\s?${style.value}`, 'i').test(node.attrs.style);
                 });
             }
         }
     });
     return result;
 };
+
+export { alignBlocks, isAligned };

package/dist/es/blockNode.js

@@ -1,13 +1,13 @@
-import { __assign, __rest } from "tslib";
-import { changeStylesString } from './utils';
+import { changeStylesString } from './utils.js';
 import { ReplaceAroundStep } from 'prosemirror-transform';
-import { Fragment, Slice } from 'prosemirror-model';
+import { Slice, Fragment } from 'prosemirror-model';
 import { NodeSelection } from 'prosemirror-state';
+
 /**
  * @hidden
  */
-var canChangeType = function (stateDoc, pos, type) {
-    var $pos = stateDoc.resolve(pos), index = $pos.index();
+const canChangeType = (stateDoc, pos, type) => {
+    const $pos = stateDoc.resolve(pos), index = $pos.index();
     return $pos.parent.canReplaceWith(index, index + 1, type);
 };
 /**
@@ -16,25 +16,25 @@ var canChangeType = function (stateDoc, pos, type) {
  * @example
  * See `cleanTextBlockFormatting` or `formatBlockElements` function.
  */
-export var changeTextBlock = function (tr, node, nodeType, attrs) {
+const changeTextBlock = (tr, node, nodeType, attrs) => {
     if (!nodeType.isTextblock) {
         return false;
     }
-    var ranges = tr.selection.ranges;
-    ranges.forEach(function (range) {
-        var mapFrom = tr.steps.length;
-        var from = range.$from.pos;
-        var to = range.$to.pos;
-        tr.doc.nodesBetween(from, to, function (currNode, pos) {
+    const { ranges } = tr.selection;
+    ranges.forEach(range => {
+        const mapFrom = tr.steps.length;
+        const from = range.$from.pos;
+        const to = range.$to.pos;
+        tr.doc.nodesBetween(from, to, (currNode, pos) => {
             if (currNode.eq(node) &&
                 currNode.isTextblock &&
                 !currNode.hasMarkup(nodeType, attrs) &&
                 canChangeType(tr.doc, tr.mapping.slice(mapFrom).map(pos), nodeType)) {
                 // Ensure all markup that isn't allowed in the new node type is cleared
                 tr.clearIncompatible(tr.mapping.slice(mapFrom).map(pos, 1), nodeType);
-                var mapping = tr.mapping.slice(mapFrom);
-                var startM = mapping.map(pos, 1), endM = mapping.map(pos + currNode.nodeSize, 1);
-                var slice = new Slice(Fragment.from(nodeType.create(attrs, null, currNode.marks)), 0, 0);
+                const mapping = tr.mapping.slice(mapFrom);
+                const startM = mapping.map(pos, 1), endM = mapping.map(pos + currNode.nodeSize, 1);
+                const slice = new Slice(Fragment.from(nodeType.create(attrs, null, currNode.marks)), 0, 0);
                 tr.step(new ReplaceAroundStep(startM, endM, startM + 1, endM - 1, slice, 1, true));
                 return false; // this will skip the node children
             }
@@ -47,17 +47,16 @@ export var changeTextBlock = function (tr, node, nodeType, attrs) {
  * @example
  * See `cleanTextBlockFormatting` function.
  */
-export var blockNodes = function (state, options) {
-    if (options === void 0) { options = { blocksInSelection: false }; }
-    var doc = state.doc, selection = state.selection;
-    var $from = selection.$from, ranges = selection.ranges;
-    var blocksInSelection = options.blocksInSelection;
-    var result = [];
-    var selNode = selection instanceof NodeSelection ? selection.node : undefined;
+const blockNodes = (state, options = { blocksInSelection: false }) => {
+    const { doc, selection } = state;
+    const { $from, ranges } = selection;
+    const { blocksInSelection } = options;
+    const result = [];
+    const selNode = selection instanceof NodeSelection ? selection.node : undefined;
     if (selNode) {
         if (selNode.isBlock) {
             result.push(selNode);
-            selNode.nodesBetween(0, selNode.content.size, function (node) {
+            selNode.nodesBetween(0, selNode.content.size, node => {
                 if (node.isBlock) {
                     result.push(node);
                 }
@@ -68,10 +67,10 @@ export var blockNodes = function (state, options) {
         }
     }
     else {
-        ranges.forEach(function (range) {
-            var from = range.$from.pos;
-            var to = range.$to.pos;
-            doc.nodesBetween(from, to, function (node, pos) {
+        ranges.forEach(range => {
+            const from = range.$from.pos;
+            const to = range.$to.pos;
+            doc.nodesBetween(from, to, (node, pos) => {
                 if (node.isBlock && (!blocksInSelection || (pos >= from && pos + node.content.size + 2 <= to))) {
                     result.push(node);
                 }
@@ -80,33 +79,31 @@ export var blockNodes = function (state, options) {
     }
     return result;
 };
-export var formatBlockElements = function (value, commandName) {
-    return function (state, dispatch) {
-        var blocks = blockNodes(state);
-        var nodes = state.schema.nodes;
-        var tr = state.tr;
-        tr.setMeta('commandName', commandName);
-        tr.setMeta('args', { value: value });
-        blocks.forEach(function (node) {
-            if (node.type.isTextblock) {
-                if (value === 'p') {
-                    changeTextBlock(tr, node, nodes.paragraph, node.attrs);
-                }
-                else if (/^h[1-6]$/i.test(value)) {
-                    var level = parseInt(value.substr(1), 10);
-                    changeTextBlock(tr, node, nodes.heading, __assign(__assign({}, node.attrs), { level: level }));
-                }
-                else if (value === 'blockquote') {
-                    changeTextBlock(tr, node, nodes.blockquote, node.attrs);
-                }
+const formatBlockElements = (value, commandName) => (state, dispatch) => {
+    const blocks = blockNodes(state);
+    const nodes = state.schema.nodes;
+    const tr = state.tr;
+    tr.setMeta('commandName', commandName);
+    tr.setMeta('args', { value });
+    blocks.forEach(node => {
+        if (node.type.isTextblock) {
+            if (value === 'p') {
+                changeTextBlock(tr, node, nodes.paragraph, node.attrs);
+            }
+            else if (/^h[1-6]$/i.test(value)) {
+                const level = parseInt(value.substr(1), 10);
+                changeTextBlock(tr, node, nodes.heading, { ...node.attrs, level });
+            }
+            else if (value === 'blockquote') {
+                changeTextBlock(tr, node, nodes.blockquote, node.attrs);
             }
-        });
-        var result = tr.docChanged;
-        if (result) {
-            dispatch(tr.scrollIntoView());
         }
-        return result;
-    };
+    });
+    const result = tr.docChanged;
+    if (result) {
+        dispatch(tr.scrollIntoView());
+    }
+    return result;
 };
 /**
  * Removes the style and class attributes of text block elements.
@@ -115,30 +112,29 @@ export var formatBlockElements = function (value, commandName) {
  * @example
  * See `cleanFormatting` function.
  */
-export var cleanTextBlockFormatting = function (tr, options) {
-    if (options === void 0) { options = { blocksInSelection: true }; }
-    var doc = tr.doc, selection = tr.selection;
-    var blocksInSelection = options.blocksInSelection, blockNodeType = options.blockNodeType;
-    var nodes = blockNodes({ doc: doc, selection: selection }, { blocksInSelection: blocksInSelection });
-    var textBlocks = nodes.filter(function (node) { return node.isTextblock; });
-    textBlocks.forEach(function (node) {
-        var _a = node.attrs || {}, _b = _a.style, style = _b === void 0 ? '' : _b, _c = _a.class, className = _c === void 0 ? '' : _c, attrs = __rest(_a, ["style", "class"]);
-        var nodeType = blockNodeType || node.type;
+const cleanTextBlockFormatting = (tr, options = { blocksInSelection: true }) => {
+    const { doc, selection } = tr;
+    const { blocksInSelection, blockNodeType } = options;
+    const nodes = blockNodes({ doc, selection }, { blocksInSelection });
+    const textBlocks = nodes.filter(node => node.isTextblock);
+    textBlocks.forEach(node => {
+        const { style = '', class: className = '', ...attrs } = node.attrs || {};
+        const nodeType = blockNodeType || node.type;
         if (style || className || nodeType !== node.type) {
             changeTextBlock(tr, node, nodeType, attrs);
         }
     });
 };
-export var getBlockFormats = function (state) {
-    var blocks = blockNodes(state);
-    var nodes = state.schema.nodes;
-    var result = [];
-    blocks.forEach(function (node) {
+const getBlockFormats = (state) => {
+    const blocks = blockNodes(state);
+    const nodes = state.schema.nodes;
+    const result = [];
+    blocks.forEach((node) => {
         if (node.type === nodes.paragraph) {
             result.push('p');
         }
         else if (node.type === nodes.heading) {
-            result.push("h".concat(node.attrs.level));
+            result.push(`h${node.attrs.level}`);
         }
         else if (node.type === nodes.blockquote && nodes.blockquote.isTextblock) {
             // In case the blockquote can have inline content.
@@ -147,35 +143,37 @@ export var getBlockFormats = function (state) {
     });
     return result;
 };
-export var addStyles = function (node, stylesToApply) {
-    var currentStyles = node.attrs.style, changedStyleResult, toChange;
+const addStyles = (node, stylesToApply) => {
+    let currentStyles = node.attrs.style, changedStyleResult, toChange;
     if (currentStyles) {
-        stylesToApply.forEach(function (style) {
+        stylesToApply.forEach(style => {
             toChange = { style: style.name, value: /^.+$/, newValue: style.value };
             changedStyleResult = changeStylesString(currentStyles, toChange);
             currentStyles = changedStyleResult.changed ? changedStyleResult.style : currentStyles;
         });
     }
-    var reducer = function (acc, curr) { return ((acc && curr.value ? acc + ' ' : '') + curr.value ? "".concat(curr.name, ": ").concat(curr.value, ";") : ''); };
+    const reducer = (acc, curr) => ((acc && curr.value ? acc + ' ' : '') + curr.value ? `${curr.name}: ${curr.value};` : '');
     currentStyles = currentStyles || stylesToApply.reduce(reducer, '');
     return Object.assign({}, node.attrs, { style: currentStyles || null });
 };
-export var hasNode = function (state, nodeType) {
-    var _a = state.selection, from = _a.from, to = _a.to;
-    var result = false;
-    state.doc.nodesBetween(from, to, function (node) {
+const hasNode = (state, nodeType) => {
+    const { from, to } = state.selection;
+    let result = false;
+    state.doc.nodesBetween(from, to, node => {
         result = result || node.type === nodeType;
         return !result;
     });
     return result;
 };
-export var parentBlockFormat = function (state) {
-    var formats = getBlockFormats(state);
+const parentBlockFormat = (state) => {
+    const formats = getBlockFormats(state);
     return new Set(formats).size === 1 ? formats[0] : null;
 };
 /**
  * **Deprecated.** Use `parentBlockFormat` function instead.
  */
-export var activeNode = function (state) {
+const activeNode = (state) => {
     return { tag: parentBlockFormat(state) || '' };
 };
+
+export { activeNode, addStyles, blockNodes, changeTextBlock, cleanTextBlockFormatting, formatBlockElements, getBlockFormats, hasNode, parentBlockFormat };

package/dist/es/blockquote.js

@@ -1,23 +1,26 @@
 import { wrapIn } from 'prosemirror-commands';
-export var blockquote = function (state, dispatch) {
+
+const blockquote = (state, dispatch) => {
     return wrapIn(state.schema.nodes.blockquote)(state, dispatch);
 };
-export var liftBlockquote = function (state, dispatch) {
-    var _a = state.selection, $from = _a.$from, $to = _a.$to;
-    var nodeType = state.schema.nodes.blockquote;
-    var doc = state.doc;
-    var target = -1;
-    var range = $from.blockRange($to);
+const liftBlockquote = (state, dispatch) => {
+    const { $from, $to } = state.selection;
+    const nodeType = state.schema.nodes.blockquote;
+    const doc = state.doc;
+    let target = -1;
+    const range = $from.blockRange($to);
     if (range) {
-        doc.nodesBetween(range.start, range.end, function (node, pos) {
+        doc.nodesBetween(range.start, range.end, (node, pos) => {
             if (node.type === nodeType) {
                 target = pos;
             }
         });
     }
-    var result = target !== -1;
+    const result = target !== -1;
     if (dispatch && result) {
         dispatch(state.tr.lift(range, doc.resolve(target).depth));
     }
     return result;
 };
+
+export { blockquote, liftBlockquote };

package/dist/es/cleanFormatting.js

@@ -1,20 +1,20 @@
-import { cleanTextBlockFormatting } from './blockNode';
-import { cleanMarks } from './mark';
+import { cleanTextBlockFormatting } from './blockNode.js';
+import { cleanMarks } from './mark.js';
+
 /**
  * A command which removes the inline formatting, class and style attributes of paragraph and heading elements in the selection.
  */
-export var cleanFormatting = function (options) {
-    if (options === void 0) { options = { blocksInSelection: true }; }
-    return function (state, dispatch) {
-        var tr = state.tr;
-        var blocksInSelection = options.blocksInSelection, blockNodeType = options.blockNodeType, exceptMarks = options.exceptMarks;
-        var except = (exceptMarks || [state.schema.marks.link]).filter(Boolean);
-        cleanMarks(tr, { except: except });
-        cleanTextBlockFormatting(tr, { blocksInSelection: blocksInSelection, blockNodeType: blockNodeType });
-        var result = tr.docChanged;
-        if (result && dispatch) {
-            dispatch(tr);
-        }
-        return result;
-    };
+const cleanFormatting = (options = { blocksInSelection: true }) => (state, dispatch) => {
+    const tr = state.tr;
+    const { blocksInSelection, blockNodeType, exceptMarks } = options;
+    const except = (exceptMarks || [state.schema.marks.link]).filter(Boolean);
+    cleanMarks(tr, { except });
+    cleanTextBlockFormatting(tr, { blocksInSelection, blockNodeType });
+    const result = tr.docChanged;
+    if (result && dispatch) {
+        dispatch(tr);
+    }
+    return result;
 };
+
+export { cleanFormatting };