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

package/dist/es/utils.js

@@ -1,96 +1,93 @@
-import { __assign } from "tslib";
-import { Node, Fragment } from 'prosemirror-model';
-import { TextSelection, AllSelection, NodeSelection } from 'prosemirror-state';
+import { Node } from 'prosemirror-model';
+import { NodeSelection, TextSelection, AllSelection } from 'prosemirror-state';
 import { parseInlineStyles } from '@progress/kendo-common';
-import { parseContent } from './source';
-export var changeStylesString = function (styleText, newStyle) {
-    var styleToChange = newStyle.style;
-    var regExp = newStyle.value;
-    var newValue = newStyle.newValue;
+
+const changeStylesString = (styleText, newStyle) => {
+    const styleToChange = newStyle.style;
+    const regExp = newStyle.value;
+    const newValue = newStyle.newValue;
     if (!styleText) {
         return { changed: false, style: null };
     }
-    var styles = parseStyle(styleText);
-    var styleNames = Object.keys(styles);
-    var filtered = [];
-    for (var i = 0; i < styleNames.length; i++) {
-        var name_1 = styleNames[i];
-        if (name_1.toLowerCase() !== styleToChange || !regExp.test(styles[name_1])) {
-            filtered.push("".concat(name_1, ": ").concat(styles[name_1]));
+    const styles = parseStyle(styleText);
+    const styleNames = Object.keys(styles);
+    const filtered = [];
+    for (let i = 0; i < styleNames.length; i++) {
+        const name = styleNames[i];
+        if (name.toLowerCase() !== styleToChange || !regExp.test(styles[name])) {
+            filtered.push(`${name}: ${styles[name]}`);
         }
     }
     if (newValue) {
-        filtered.push("".concat(styleToChange, ": ").concat(newValue));
+        filtered.push(`${styleToChange}: ${newValue}`);
     }
     return {
         style: filtered.join('; ') + (filtered.length ? ';' : ''),
         changed: Boolean(newValue) || filtered.length !== styleNames.length
     };
 };
-var reAnyValue = /^.+$/;
-export function setNodeStyle(nodeAttrs, styleType, value) {
-    var attrs;
+const reAnyValue = /^.+$/;
+function setNodeStyle(nodeAttrs, styleType, value) {
+    let attrs;
     if (new RegExp('[^-]?' + styleType + ':').test(nodeAttrs.style || '')) {
-        var style = changeStylesString(nodeAttrs.style || '', { style: styleType, value: reAnyValue, newValue: value }).style;
-        attrs = __assign(__assign({}, nodeAttrs), { style: style });
+        const { style } = changeStylesString(nodeAttrs.style || '', { style: styleType, value: reAnyValue, newValue: value });
+        attrs = { ...nodeAttrs, style };
     }
     else if (nodeAttrs.style) {
-        attrs = __assign(__assign({}, nodeAttrs), { style: nodeAttrs.style.replace(/;$/, '') + '; ' + styleType + ': ' + value + ';' });
+        attrs = { ...nodeAttrs, style: nodeAttrs.style.replace(/;$/, '') + '; ' + styleType + ': ' + value + ';' };
     }
     else {
-        attrs = __assign(__assign({}, nodeAttrs), { style: styleType + ': ' + value + ';' });
+        attrs = { ...nodeAttrs, style: styleType + ': ' + value + ';' };
     }
     return attrs;
 }
 /**
  * Determines if a given node type can be inserted at the current cursor position.
  */
-export var canInsert = function (state, nodeType) {
-    var $from = state.selection.$from;
-    for (var d = $from.depth; d >= 0; d--) {
-        var index = $from.index(d);
+const canInsert = (state, nodeType) => {
+    const $from = state.selection.$from;
+    for (let d = $from.depth; d >= 0; d--) {
+        const index = $from.index(d);
         if ($from.node(d).canReplaceWith(index, index, nodeType)) {
             return true;
         }
     }
     return false;
 };
-var getTypeName = function (n) {
+const getTypeName = (n) => {
     return n instanceof Node ? n.type.name : n.name;
 };
-var findNthParentNode = function (predicate, depth) {
-    if (depth === void 0) { depth = 1; }
-    return function (selection) {
-        var $from = selection.$from;
-        for (var i = $from.depth; i > 0; i--) {
-            var node = $from.node(i);
+const findNthParentNode = (predicate, depth = 1) => {
+    return (selection) => {
+        const { $from } = selection;
+        for (let i = $from.depth; i > 0; i--) {
+            const node = $from.node(i);
             if (predicate(node)) {
                 depth = depth - 1;
                 if (depth === 0) {
-                    return { depth: i, node: node };
+                    return { depth: i, node };
                 }
             }
         }
     };
 };
-export var findNthParentNodeOfType = function (nodeType, depth) {
-    if (depth === void 0) { depth = 1; }
-    return function (selection) {
-        return findNthParentNode(function (node) { return getTypeName(node) === getTypeName(nodeType); }, depth)(selection);
+const findNthParentNodeOfType = (nodeType, depth = 1) => {
+    return (selection) => {
+        return findNthParentNode((node) => getTypeName(node) === getTypeName(nodeType), depth)(selection);
     };
 };
-export function parentNode(pos, predicate) {
-    for (var depth = pos.depth; depth > 0; depth--) {
-        var node = pos.node(depth);
+function parentNode(pos, predicate) {
+    for (let depth = pos.depth; depth > 0; depth--) {
+        const node = pos.node(depth);
         if (predicate(node)) {
-            return { node: node, depth: depth };
+            return { node, depth };
         }
     }
     return null;
 }
-var filterEmptyAttrs = function (attrs) {
-    var result = {};
-    for (var attr in attrs) {
+const filterEmptyAttrs = (attrs) => {
+    const result = {};
+    for (const attr in attrs) {
         if (attr && (attrs[attr] || attrs[attr] === 0)) {
             result[attr] = attrs[attr];
         }
@@ -100,12 +97,12 @@ var filterEmptyAttrs = function (attrs) {
 /**
  * Inserts the given node at the place of current selection.
  */
-export var insertNode = function (node, scrollIntoView) { return function (state, dispatch) {
-    var selection = state.selection, tr = state.tr;
+const insertNode = (node, scrollIntoView) => (state, dispatch) => {
+    const { selection, tr } = state;
     if (selection instanceof NodeSelection
         && selection.node.type.name === node.type.name
         && node.isLeaf && !node.isText && node.nodeSize === 1) {
-        tr.setNodeMarkup(selection.from, null, __assign(__assign({}, filterEmptyAttrs(selection.node.attrs)), filterEmptyAttrs(node.attrs)));
+        tr.setNodeMarkup(selection.from, null, { ...filterEmptyAttrs(selection.node.attrs), ...filterEmptyAttrs(node.attrs) });
         tr.setSelection(NodeSelection.create(tr.doc, selection.from));
     }
     else {
@@ -115,21 +112,16 @@ export var insertNode = function (node, scrollIntoView) { return function (state
         tr.scrollIntoView();
     }
     dispatch(tr);
-}; };
-export var hasSameMarkup = function (dom1, dom2, schema, parseOptions) {
-    var fragment1 = Fragment.from(parseContent(dom1, schema, parseOptions));
-    var fragment2 = Fragment.from(parseContent(dom2, schema, parseOptions));
-    return fragment1.eq(fragment2);
 };
-export var getSelectionText = function (state) {
-    var sel = state.selection;
+const getSelectionText = (state) => {
+    const sel = state.selection;
     if (sel instanceof TextSelection || sel instanceof AllSelection) {
-        var fragment = sel.content().content;
+        const fragment = sel.content().content;
         return fragment.textBetween(0, fragment.size);
     }
     return '';
 };
-export var getNodeFromSelection = function (state) {
+const getNodeFromSelection = (state) => {
     if (state.selection instanceof NodeSelection) {
         return state.selection.node;
     }
@@ -142,12 +134,12 @@ export var getNodeFromSelection = function (state) {
  * Useful for values of the inputs of Link and Find&Replace dialogs where the inputs value has been retrieved from the selection and
  * should be single line text only.
  */
-export var selectedLineTextOnly = function (state) {
-    var result = '', hasLeafs = false;
-    var selection = state.selection, doc = state.doc;
-    var $from = selection.$from, $to = selection.$to, from = selection.from, to = selection.to;
+const selectedLineTextOnly = (state) => {
+    let result = '', hasLeafs = false;
+    const { selection, doc } = state;
+    const { $from, $to, from, to } = selection;
     if ($from.sameParent($to)) {
-        doc.nodesBetween(from, to, function (node) {
+        doc.nodesBetween(from, to, (node) => {
             hasLeafs = hasLeafs || (node.isLeaf && !node.isText);
         });
         if (!hasLeafs) {
@@ -159,58 +151,55 @@ export var selectedLineTextOnly = function (state) {
 /**
  * Used by ViewHtml/ViewSource dialogs for making the HTML more readable.
  */
-export var indentHtml = function (content) {
+const indentHtml = (content) => {
     return content.replace(/<\/(p|li|ul|ol|h[1-6]|table|tr|td|th)>/ig, '</$1>\n')
         .replace(/<(ul|ol)([^>]*)><li/ig, '<$1$2>\n<li')
         .replace(/<br \/>/ig, '<br />\n')
         .replace(/\n$/, '');
 };
-export var shallowEqual = function (object1, object2) {
-    var keys1 = Object.keys(object1);
-    var keys2 = Object.keys(object2);
+const shallowEqual = (object1, object2) => {
+    const keys1 = Object.keys(object1);
+    const keys2 = Object.keys(object2);
     return keys1.length === keys2.length &&
-        keys1.every(function (k) { return object1[k] === object2[k]; });
+        keys1.every(k => object1[k] === object2[k]);
 };
-var applyToWordDefault = { before: /[^ !,?.\[\]{}()]+$/i, after: /^[^ !,?.\[\]{}()]+/i };
+const applyToWordDefault = { before: /[^ !,?.\[\]{}()]+$/i, after: /^[^ !,?.\[\]{}()]+/i };
 /**
  * if options.applyToWord is set, expands the selection to the word where the cursor is and
  * returns modified state and dispatch.
  */
-export var expandSelection = function (state, dispatch, options) {
+const expandSelection = (state, dispatch, options) => {
     if (!options.applyToWord || !state.selection.empty) {
-        return { state: state, dispatch: dispatch };
+        return { state, dispatch };
     }
-    var applyToWordOptions = options.applyToWord === true ? applyToWordDefault : options.applyToWord;
-    var initialPosition = null;
-    var tr = state.tr;
-    var selection = state.selection;
-    var before = selection.$head.nodeBefore;
-    var after = selection.$head.nodeAfter;
+    const applyToWordOptions = options.applyToWord === true ? applyToWordDefault : options.applyToWord;
+    let initialPosition = null;
+    const tr = state.tr;
+    const selection = state.selection;
+    const before = selection.$head.nodeBefore;
+    const after = selection.$head.nodeAfter;
     if (before && before.type.name === 'text' && before.text && after && after.type.name === 'text' && after.text) {
-        var children_1 = [];
-        selection.$head.parent.descendants(function (node, pos) {
-            children_1.push({ node: node, pos: pos });
+        const children = [];
+        selection.$head.parent.descendants((node, pos) => {
+            children.push({ node, pos });
             return false;
         });
-        var cursor_1 = selection.$head.parentOffset;
-        var nodeIndex = children_1.findIndex(function (_a) {
-            var node = _a.node, pos = _a.pos;
-            return pos <= cursor_1 && pos + node.nodeSize >= cursor_1;
-        });
-        var text = children_1[nodeIndex].node.text;
-        var skip = false;
-        for (var i = nodeIndex - 1; i >= 0; i--) {
-            var element = children_1[i];
+        let cursor = selection.$head.parentOffset;
+        const nodeIndex = children.findIndex(({ node, pos }) => pos <= cursor && pos + node.nodeSize >= cursor);
+        let text = children[nodeIndex].node.text;
+        let skip = false;
+        for (let i = nodeIndex - 1; i >= 0; i--) {
+            const element = children[i];
             if (!skip && element && element.node.type.name === 'text') {
                 text = element.node.text + text;
             }
             else {
                 skip = true;
-                cursor_1 -= element.node.nodeSize;
+                cursor -= element.node.nodeSize;
             }
         }
-        for (var i = nodeIndex + 1; i < children_1.length; i++) {
-            var element = children_1[i];
+        for (let i = nodeIndex + 1; i < children.length; i++) {
+            const element = children[i];
             if (element && element.node.type.name === 'text') {
                 text = text + element.node.text;
             }
@@ -218,30 +207,30 @@ export var expandSelection = function (state, dispatch, options) {
                 break;
             }
         }
-        var textBefore = text.substring(0, cursor_1);
-        var textAfter = text.substring(cursor_1);
-        var matchBefore = applyToWordOptions.before.exec(textBefore);
-        var matchAfter = applyToWordOptions.after.exec(textAfter);
+        const textBefore = text.substring(0, cursor);
+        const textAfter = text.substring(cursor);
+        const matchBefore = applyToWordOptions.before.exec(textBefore);
+        const matchAfter = applyToWordOptions.after.exec(textAfter);
         if (matchBefore && matchAfter) {
-            var extendLeft = matchBefore[0].length;
-            var extendRight = matchAfter[0].length;
-            var pos = initialPosition = selection.from;
+            const extendLeft = matchBefore[0].length;
+            const extendRight = matchAfter[0].length;
+            const pos = initialPosition = selection.from;
             tr.setSelection(TextSelection.create(state.doc, pos - extendLeft, pos + extendRight));
-            var cmdState = {
-                tr: tr,
+            const cmdState = {
+                tr,
                 selection: tr.selection,
                 doc: tr.doc,
                 storedMarks: null,
                 schema: tr.doc.type.schema
             };
-            var cmdDispatch = function (tran) {
+            const cmdDispatch = tran => {
                 tran.setSelection(TextSelection.create(tran.doc, initialPosition));
                 dispatch(tran);
             };
             return { state: cmdState, dispatch: cmdDispatch };
         }
     }
-    return { state: state, dispatch: dispatch };
+    return { state, dispatch };
 };
 /**
  * if options.applyToWord is set, expands the selection to the word where the cursor is and
@@ -255,34 +244,34 @@ export var expandSelection = function (state, dispatch, options) {
  * const command = expandToWordWrap(toggleInlineFormat, {...bold, applyToWord );
  * command(view.state, view.dispatch);
  */
-export var expandToWordWrap = function (command, options) {
-    return function (state, dispatch) {
-        var _a = expandSelection(state, dispatch, options), cmdState = _a.state, cmdDispatch = _a.dispatch;
+const expandToWordWrap = (command, options) => {
+    return (state, dispatch) => {
+        const { state: cmdState, dispatch: cmdDispatch } = expandSelection(state, dispatch, options);
         return command(options)(cmdState, cmdDispatch);
     };
 };
-export var parseStyle = function (styleText) {
+const parseStyle = (styleText) => {
     return parseInlineStyles(styleText);
 };
-export var applyStyle = function (styleText, styleType, styleValue) {
-    var styles = parseStyle(styleText);
+const applyStyle = (styleText, styleType, styleValue) => {
+    const styles = parseStyle(styleText);
     styles[styleType] = styleValue;
-    var result = Object.keys(styles)
-        .map(function (name) { return styles[name] ? "".concat(name, ": ").concat(styles[name]) : null; })
+    const result = Object.keys(styles)
+        .map(name => styles[name] ? `${name}: ${styles[name]}` : null)
         .filter(Boolean)
         .join('; ');
     return result ? result + ';' : null;
 };
-export var setStyleAttr = function (element, styleString) {
-    var styles = parseStyle(styleString);
-    for (var style in styles) {
+const setStyleAttr = (element, styleString) => {
+    const styles = parseStyle(styleString);
+    for (const style in styles) {
         if (style && typeof element.style[style] !== 'undefined') {
             element.style[style] = styles[style];
         }
     }
 };
-export var setAttribute = function (node, attrName, value) {
-    var current = node.getAttribute(attrName);
+const setAttribute = (node, attrName, value) => {
+    const current = node.getAttribute(attrName);
     if (value !== undefined && value !== current) {
         if (attrName === 'style') {
             node.removeAttribute(attrName);
@@ -296,3 +285,5 @@ export var setAttribute = function (node, attrName, value) {
         node.removeAttribute(attrName);
     }
 };
+
+export { applyStyle, canInsert, changeStylesString, expandSelection, expandToWordWrap, findNthParentNodeOfType, getNodeFromSelection, getSelectionText, indentHtml, insertNode, parentNode, parseStyle, selectedLineTextOnly, setAttribute, setNodeStyle, setStyleAttr, shallowEqual };

package/dist/es2015/DOMSerializer.js

@@ -1,20 +1,6 @@
-import { setAttribute } from './utils';
-export class DOMSerializer {
-    /// 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;
-    }
+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.
@@ -90,6 +76,21 @@ export class DOMSerializer {
     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
@@ -179,3 +180,5 @@ function gatherToDOM(obj) {
 function doc(options) {
     return options.document || window.document;
 }
+
+export { DOMSerializer };

package/dist/es2015/align.js

@@ -1,10 +1,11 @@
-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 const alignBlocks = (actions, commandName) => (state, dispatch) => {
+const alignBlocks = (actions, commandName) => (state, dispatch) => {
     const blocks = blockNodes(state);
     const tr = state.tr;
     tr.setMeta('commandName', commandName);
@@ -23,7 +24,7 @@ export const alignBlocks = (actions, commandName) => (state, dispatch) => {
     }
     return result;
 };
-export const isAligned = (state, actions) => {
+const isAligned = (state, actions) => {
     const blocks = blockNodes(state);
     let result = false;
     blocks.forEach(node => {
@@ -38,3 +39,5 @@ export const isAligned = (state, actions) => {
     });
     return result;
 };
+
+export { alignBlocks, isAligned };

package/dist/es2015/blockNode.js

@@ -1,8 +1,9 @@
-import { __rest } from "tslib";
-import { changeStylesString } from './utils';
+import { __rest } from './node_modules/tslib/tslib.es6.js';
+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
  */
@@ -16,7 +17,7 @@ const canChangeType = (stateDoc, pos, type) => {
  * @example
  * See `cleanTextBlockFormatting` or `formatBlockElements` function.
  */
-export const changeTextBlock = (tr, node, nodeType, attrs) => {
+const changeTextBlock = (tr, node, nodeType, attrs) => {
     if (!nodeType.isTextblock) {
         return false;
     }
@@ -47,7 +48,7 @@ export const changeTextBlock = (tr, node, nodeType, attrs) => {
  * @example
  * See `cleanTextBlockFormatting` function.
  */
-export const blockNodes = (state, options = { blocksInSelection: false }) => {
+const blockNodes = (state, options = { blocksInSelection: false }) => {
     const { doc, selection } = state;
     const { $from, ranges } = selection;
     const { blocksInSelection } = options;
@@ -79,7 +80,7 @@ export const blockNodes = (state, options = { blocksInSelection: false }) => {
     }
     return result;
 };
-export const formatBlockElements = (value, commandName) => (state, dispatch) => {
+const formatBlockElements = (value, commandName) => (state, dispatch) => {
     const blocks = blockNodes(state);
     const nodes = state.schema.nodes;
     const tr = state.tr;
@@ -112,7 +113,7 @@ export const formatBlockElements = (value, commandName) => (state, dispatch) =>
  * @example
  * See `cleanFormatting` function.
  */
-export const cleanTextBlockFormatting = (tr, options = { blocksInSelection: true }) => {
+const cleanTextBlockFormatting = (tr, options = { blocksInSelection: true }) => {
     const { doc, selection } = tr;
     const { blocksInSelection, blockNodeType } = options;
     const nodes = blockNodes({ doc, selection }, { blocksInSelection });
@@ -125,7 +126,7 @@ export const cleanTextBlockFormatting = (tr, options = { blocksInSelection: true
         }
     });
 };
-export const getBlockFormats = (state) => {
+const getBlockFormats = (state) => {
     const blocks = blockNodes(state);
     const nodes = state.schema.nodes;
     const result = [];
@@ -143,7 +144,7 @@ export const getBlockFormats = (state) => {
     });
     return result;
 };
-export const addStyles = (node, stylesToApply) => {
+const addStyles = (node, stylesToApply) => {
     let currentStyles = node.attrs.style, changedStyleResult, toChange;
     if (currentStyles) {
         stylesToApply.forEach(style => {
@@ -156,7 +157,7 @@ export const addStyles = (node, stylesToApply) => {
     currentStyles = currentStyles || stylesToApply.reduce(reducer, '');
     return Object.assign({}, node.attrs, { style: currentStyles || null });
 };
-export const hasNode = (state, nodeType) => {
+const hasNode = (state, nodeType) => {
     const { from, to } = state.selection;
     let result = false;
     state.doc.nodesBetween(from, to, node => {
@@ -165,13 +166,15 @@ export const hasNode = (state, nodeType) => {
     });
     return result;
 };
-export const parentBlockFormat = (state) => {
+const parentBlockFormat = (state) => {
     const formats = getBlockFormats(state);
     return new Set(formats).size === 1 ? formats[0] : null;
 };
 /**
  * **Deprecated.** Use `parentBlockFormat` function instead.
  */
-export const activeNode = (state) => {
+const activeNode = (state) => {
     return { tag: parentBlockFormat(state) || '' };
 };
+
+export { activeNode, addStyles, blockNodes, changeTextBlock, cleanTextBlockFormatting, formatBlockElements, getBlockFormats, hasNode, parentBlockFormat };

package/dist/es2015/blockquote.js

@@ -1,8 +1,9 @@
 import { wrapIn } from 'prosemirror-commands';
-export const blockquote = (state, dispatch) => {
+
+const blockquote = (state, dispatch) => {
     return wrapIn(state.schema.nodes.blockquote)(state, dispatch);
 };
-export const liftBlockquote = (state, dispatch) => {
+const liftBlockquote = (state, dispatch) => {
     const { $from, $to } = state.selection;
     const nodeType = state.schema.nodes.blockquote;
     const doc = state.doc;
@@ -21,3 +22,5 @@ export const liftBlockquote = (state, dispatch) => {
     }
     return result;
 };
+
+export { blockquote, liftBlockquote };

package/dist/es2015/cleanFormatting.js

@@ -1,9 +1,10 @@
-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 const cleanFormatting = (options = { blocksInSelection: true }) => (state, dispatch) => {
+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);
@@ -15,3 +16,5 @@ export const cleanFormatting = (options = { blocksInSelection: true }) => (state
     }
     return result;
 };
+
+export { cleanFormatting };

package/dist/es2015/config/align-rules.js

@@ -1,28 +1,30 @@
 const style = (name, value) => {
     return { name: name, value: value };
 };
-export const alignLeftRules = [
+const alignLeftRules = [
     { node: 'paragraph', style: [style('text-align', 'left')] },
     { node: 'heading', style: [style('text-align', 'left')] },
     { node: 'table_caption_external', style: [style('text-align', 'left')] }
 ];
-export const alignRightRules = [
+const alignRightRules = [
     { node: 'paragraph', style: [style('text-align', 'right')] },
     { node: 'heading', style: [style('text-align', 'right')] },
     { node: 'table_caption_external', style: [style('text-align', 'right')] }
 ];
-export const alignCenterRules = [
+const alignCenterRules = [
     { node: 'paragraph', style: [style('text-align', 'center')] },
     { node: 'heading', style: [style('text-align', 'center')] },
     { node: 'table_caption_external', style: [style('text-align', 'center')] }
 ];
-export const alignJustifyRules = [
+const alignJustifyRules = [
     { node: 'paragraph', style: [style('text-align', 'justify')] },
     { node: 'heading', style: [style('text-align', 'justify')] },
     { node: 'table_caption_external', style: [style('text-align', 'justify')] }
 ];
-export const alignRemoveRules = [
+const alignRemoveRules = [
     { node: 'paragraph', style: [style('text-align', '')] },
     { node: 'heading', style: [style('text-align', '')] },
     { node: 'table_caption_external', style: [style('text-align', '')] }
 ];
+
+export { alignCenterRules, alignJustifyRules, alignLeftRules, alignRemoveRules, alignRightRules };