@progress/kendo-editor-common 1.12.2-develop.4 → 1.12.2-develop.6

package/dist/npm/types/predicate.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/npm/utils.d.ts

@@ -1,21 +1,34 @@
 import { Node, NodeType, ResolvedPos } from 'prosemirror-model';
-import { EditorState } from 'prosemirror-state';
-import { Command } from './types/command.js';
-
+import { EditorState, Selection } from 'prosemirror-state';
+import { Command } from './types/command';
+interface NodeDepth {
+    depth: number;
+    node: Node;
+}
+export declare const changeStylesString: (styleText: string, newStyle: {
+    style: string;
+    value: RegExp;
+    newValue?: string;
+}) => {
+    changed: boolean;
+    style: string | null;
+};
+export declare function setNodeStyle(nodeAttrs: any, styleType: string, value: string): any;
 /**
  * Determines if a given node type can be inserted at the current cursor position.
  */
-declare const canInsert: (state: EditorState, nodeType: NodeType) => boolean;
-declare function parentNode(pos: ResolvedPos, predicate: (node: Node) => boolean): {
+export declare const canInsert: (state: EditorState, nodeType: NodeType) => boolean;
+export declare const findNthParentNodeOfType: (nodeType: NodeType, depth?: number) => (selection: Selection) => NodeDepth;
+export declare function parentNode(pos: ResolvedPos, predicate: (node: Node) => boolean): {
     node: Node;
     depth: number;
 } | null;
 /**
  * Inserts the given node at the place of current selection.
  */
-declare const insertNode: (node: Node, scrollIntoView?: boolean) => Command;
-declare const getSelectionText: (state: EditorState) => string;
-declare const getNodeFromSelection: (state: EditorState) => Node;
+export declare const insertNode: (node: Node, scrollIntoView?: boolean) => Command;
+export declare const getSelectionText: (state: EditorState) => string;
+export declare const getNodeFromSelection: (state: EditorState) => Node;
 /**
  * Returns the text from the selection if only text is selected on a single line.
  * If selection contains leaf nodes (br, image) between text elements or
@@ -24,16 +37,17 @@ declare const getNodeFromSelection: (state: EditorState) => Node;
  * 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.
  */
-declare const selectedLineTextOnly: (state: EditorState) => string;
+export declare const selectedLineTextOnly: (state: EditorState) => string;
 /**
  * Used by ViewHtml/ViewSource dialogs for making the HTML more readable.
  */
-declare const indentHtml: (content: string) => string;
+export declare const indentHtml: (content: string) => string;
+export declare const shallowEqual: (object1: any, object2: any) => boolean;
 /**
  * if options.applyToWord is set, expands the selection to the word where the cursor is and
  * returns modified state and dispatch.
  */
-declare const expandSelection: (state: any, dispatch: any, options: any) => {
+export declare const expandSelection: (state: any, dispatch: any, options: any) => {
     state: any;
     dispatch: any;
 };
@@ -49,6 +63,11 @@ declare const expandSelection: (state: any, dispatch: any, options: any) => {
  * const command = expandToWordWrap(toggleInlineFormat, {...bold, applyToWord );
  * command(view.state, view.dispatch);
  */
-declare const expandToWordWrap: (command: any, options: any) => (state: any, dispatch: any) => any;
-
-export { canInsert, expandSelection, expandToWordWrap, getNodeFromSelection, getSelectionText, indentHtml, insertNode, parentNode, selectedLineTextOnly };
+export declare const expandToWordWrap: (command: any, options: any) => (state: any, dispatch: any) => any;
+export declare const parseStyle: (styleText: string | null) => {
+    [key: string]: string;
+};
+export declare const applyStyle: (styleText: string | null, styleType: string, styleValue: string) => string;
+export declare const setStyleAttr: (element: HTMLElement, styleString: string) => void;
+export declare const setAttribute: (node: HTMLElement, attrName: string, value?: string) => void;
+export {};

package/dist/npm/utils.js

@@ -1,9 +1,11 @@
-'use strict';
-
-var prosemirrorModel = require('prosemirror-model');
-var prosemirrorState = require('prosemirror-state');
-var kendoCommon = require('@progress/kendo-common');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setAttribute = exports.setStyleAttr = exports.applyStyle = exports.parseStyle = exports.expandToWordWrap = exports.expandSelection = exports.shallowEqual = exports.indentHtml = exports.selectedLineTextOnly = exports.getNodeFromSelection = exports.getSelectionText = exports.insertNode = exports.findNthParentNodeOfType = exports.canInsert = exports.changeStylesString = void 0;
+exports.setNodeStyle = setNodeStyle;
+exports.parentNode = parentNode;
+const prosemirror_model_1 = require("prosemirror-model");
+const prosemirror_state_1 = require("prosemirror-state");
+const kendo_common_1 = require("@progress/kendo-common");
 const changeStylesString = (styleText, newStyle) => {
     const styleToChange = newStyle.style;
     const regExp = newStyle.value;
@@ -11,7 +13,7 @@ const changeStylesString = (styleText, newStyle) => {
     if (!styleText) {
         return { changed: false, style: null };
     }
-    const styles = parseStyle(styleText);
+    const styles = (0, exports.parseStyle)(styleText);
     const styleNames = Object.keys(styles);
     const filtered = [];
     for (let i = 0; i < styleNames.length; i++) {
@@ -28,11 +30,12 @@ const changeStylesString = (styleText, newStyle) => {
         changed: Boolean(newValue) || filtered.length !== styleNames.length
     };
 };
+exports.changeStylesString = changeStylesString;
 const reAnyValue = /^.+$/;
 function setNodeStyle(nodeAttrs, styleType, value) {
     let attrs;
     if (new RegExp('[^-]?' + styleType + ':').test(nodeAttrs.style || '')) {
-        const { style } = changeStylesString(nodeAttrs.style || '', { style: styleType, value: reAnyValue, newValue: value });
+        const { style } = (0, exports.changeStylesString)(nodeAttrs.style || '', { style: styleType, value: reAnyValue, newValue: value });
         attrs = { ...nodeAttrs, style };
     }
     else if (nodeAttrs.style) {
@@ -56,8 +59,9 @@ const canInsert = (state, nodeType) => {
     }
     return false;
 };
+exports.canInsert = canInsert;
 const getTypeName = (n) => {
-    return n instanceof prosemirrorModel.Node ? n.type.name : n.name;
+    return n instanceof prosemirror_model_1.Node ? n.type.name : n.name;
 };
 const findNthParentNode = (predicate, depth = 1) => {
     return (selection) => {
@@ -78,6 +82,7 @@ const findNthParentNodeOfType = (nodeType, depth = 1) => {
         return findNthParentNode((node) => getTypeName(node) === getTypeName(nodeType), depth)(selection);
     };
 };
+exports.findNthParentNodeOfType = findNthParentNodeOfType;
 function parentNode(pos, predicate) {
     for (let depth = pos.depth; depth > 0; depth--) {
         const node = pos.node(depth);
@@ -101,11 +106,11 @@ const filterEmptyAttrs = (attrs) => {
  */
 const insertNode = (node, scrollIntoView) => (state, dispatch) => {
     const { selection, tr } = state;
-    if (selection instanceof prosemirrorState.NodeSelection
+    if (selection instanceof prosemirror_state_1.NodeSelection
         && selection.node.type.name === node.type.name
         && node.isLeaf && !node.isText && node.nodeSize === 1) {
         tr.setNodeMarkup(selection.from, null, { ...filterEmptyAttrs(selection.node.attrs), ...filterEmptyAttrs(node.attrs) });
-        tr.setSelection(prosemirrorState.NodeSelection.create(tr.doc, selection.from));
+        tr.setSelection(prosemirror_state_1.NodeSelection.create(tr.doc, selection.from));
     }
     else {
         tr.replaceSelectionWith(node);
@@ -115,19 +120,22 @@ const insertNode = (node, scrollIntoView) => (state, dispatch) => {
     }
     dispatch(tr);
 };
+exports.insertNode = insertNode;
 const getSelectionText = (state) => {
     const sel = state.selection;
-    if (sel instanceof prosemirrorState.TextSelection || sel instanceof prosemirrorState.AllSelection) {
+    if (sel instanceof prosemirror_state_1.TextSelection || sel instanceof prosemirror_state_1.AllSelection) {
         const fragment = sel.content().content;
         return fragment.textBetween(0, fragment.size);
     }
     return '';
 };
+exports.getSelectionText = getSelectionText;
 const getNodeFromSelection = (state) => {
-    if (state.selection instanceof prosemirrorState.NodeSelection) {
+    if (state.selection instanceof prosemirror_state_1.NodeSelection) {
         return state.selection.node;
     }
 };
+exports.getNodeFromSelection = getNodeFromSelection;
 /**
  * Returns the text from the selection if only text is selected on a single line.
  * If selection contains leaf nodes (br, image) between text elements or
@@ -145,11 +153,12 @@ const selectedLineTextOnly = (state) => {
             hasLeafs = hasLeafs || (node.isLeaf && !node.isText);
         });
         if (!hasLeafs) {
-            result = getSelectionText(state);
+            result = (0, exports.getSelectionText)(state);
         }
     }
     return result;
 };
+exports.selectedLineTextOnly = selectedLineTextOnly;
 /**
  * Used by ViewHtml/ViewSource dialogs for making the HTML more readable.
  */
@@ -159,13 +168,15 @@ const indentHtml = (content) => {
         .replace(/<br \/>/ig, '<br />\n')
         .replace(/\n$/, '');
 };
+exports.indentHtml = indentHtml;
 const shallowEqual = (object1, object2) => {
     const keys1 = Object.keys(object1);
     const keys2 = Object.keys(object2);
     return keys1.length === keys2.length &&
         keys1.every(k => object1[k] === object2[k]);
 };
-const applyToWordDefault = { before: /[^ !,?.\[\]{}()]+$/i, after: /^[^ !,?.\[\]{}()]+/i };
+exports.shallowEqual = shallowEqual;
+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.
@@ -217,7 +228,7 @@ const expandSelection = (state, dispatch, options) => {
             const extendLeft = matchBefore[0].length;
             const extendRight = matchAfter[0].length;
             const pos = initialPosition = selection.from;
-            tr.setSelection(prosemirrorState.TextSelection.create(state.doc, pos - extendLeft, pos + extendRight));
+            tr.setSelection(prosemirror_state_1.TextSelection.create(state.doc, pos - extendLeft, pos + extendRight));
             const cmdState = {
                 tr,
                 selection: tr.selection,
@@ -226,7 +237,7 @@ const expandSelection = (state, dispatch, options) => {
                 schema: tr.doc.type.schema
             };
             const cmdDispatch = tran => {
-                tran.setSelection(prosemirrorState.TextSelection.create(tran.doc, initialPosition));
+                tran.setSelection(prosemirror_state_1.TextSelection.create(tran.doc, initialPosition));
                 dispatch(tran);
             };
             return { state: cmdState, dispatch: cmdDispatch };
@@ -234,6 +245,7 @@ const expandSelection = (state, dispatch, options) => {
     }
     return { state, dispatch };
 };
+exports.expandSelection = expandSelection;
 /**
  * if options.applyToWord is set, expands the selection to the word where the cursor is and
  * use the modified state for the passed command.
@@ -248,15 +260,17 @@ const expandSelection = (state, dispatch, options) => {
  */
 const expandToWordWrap = (command, options) => {
     return (state, dispatch) => {
-        const { state: cmdState, dispatch: cmdDispatch } = expandSelection(state, dispatch, options);
+        const { state: cmdState, dispatch: cmdDispatch } = (0, exports.expandSelection)(state, dispatch, options);
         return command(options)(cmdState, cmdDispatch);
     };
 };
+exports.expandToWordWrap = expandToWordWrap;
 const parseStyle = (styleText) => {
-    return kendoCommon.parseInlineStyles(styleText);
+    return (0, kendo_common_1.parseInlineStyles)(styleText);
 };
+exports.parseStyle = parseStyle;
 const applyStyle = (styleText, styleType, styleValue) => {
-    const styles = parseStyle(styleText);
+    const styles = (0, exports.parseStyle)(styleText);
     styles[styleType] = styleValue;
     const result = Object.keys(styles)
         .map(name => styles[name] ? `${name}: ${styles[name]}` : null)
@@ -264,20 +278,22 @@ const applyStyle = (styleText, styleType, styleValue) => {
         .join('; ');
     return result ? result + ';' : null;
 };
+exports.applyStyle = applyStyle;
 const setStyleAttr = (element, styleString) => {
-    const styles = parseStyle(styleString);
+    const styles = (0, exports.parseStyle)(styleString);
     for (const style in styles) {
         if (style && element.style[style] !== undefined) {
             element.style[style] = styles[style];
         }
     }
 };
+exports.setStyleAttr = setStyleAttr;
 const setAttribute = (node, attrName, value) => {
     const current = node.getAttribute(attrName);
     if (value !== undefined && value !== current) {
         if (attrName === 'style') {
             node.removeAttribute(attrName);
-            setStyleAttr(node, value);
+            (0, exports.setStyleAttr)(node, value);
         }
         else {
             node.setAttribute(attrName, value);
@@ -287,21 +303,4 @@ const setAttribute = (node, attrName, value) => {
         node.removeAttribute(attrName);
     }
 };
-
-exports.applyStyle = applyStyle;
-exports.canInsert = canInsert;
-exports.changeStylesString = changeStylesString;
-exports.expandSelection = expandSelection;
-exports.expandToWordWrap = expandToWordWrap;
-exports.findNthParentNodeOfType = findNthParentNodeOfType;
-exports.getNodeFromSelection = getNodeFromSelection;
-exports.getSelectionText = getSelectionText;
-exports.indentHtml = indentHtml;
-exports.insertNode = insertNode;
-exports.parentNode = parentNode;
-exports.parseStyle = parseStyle;
-exports.selectedLineTextOnly = selectedLineTextOnly;
 exports.setAttribute = setAttribute;
-exports.setNodeStyle = setNodeStyle;
-exports.setStyleAttr = setStyleAttr;
-exports.shallowEqual = shallowEqual;

package/package.json

@@ -1,28 +1,17 @@
 {
   "name": "@progress/kendo-editor-common",
   "description": "Kendo UI TypeScript package exporting functions for Editor component",
-  "version": "1.12.2-develop.4",
+  "version": "1.12.2-develop.6",
   "keywords": [
     "Kendo UI"
   ],
-  "type": "module",
   "author": "Progress",
   "license": "SEE LICENSE IN LICENSE.md",
   "main": "dist/npm/main.js",
   "module": "dist/es/main.js",
-  "jsnext:main": "dist/es/main.js",
-  "es2015": "dist/es2015/main.js",
   "typings": "dist/npm/main.d.ts",
   "jsdelivr": "dist/cdn/main.js",
   "unpkg": "dist/cdn/main.js",
-  "scripts": {
-    "start": "vite",
-    "test:ci": "jest",
-    "test": "jest",
-    "lint": "eslint .",
-    "build": "rollup -c",
-    "prepare": "husky"
-  },
   "dependencies": {
     "@progress/kendo-common": "^1.0.2",
     "prosemirror-commands": "1.7.0",
@@ -31,37 +20,14 @@
     "prosemirror-history": "1.4.1",
     "prosemirror-inputrules": "1.4.0",
     "prosemirror-keymap": "1.2.2",
-    "prosemirror-model": "1.24.1",
+    "prosemirror-model": "1.25.0",
     "prosemirror-schema-list": "1.5.0",
     "prosemirror-state": "1.4.3",
     "prosemirror-tables": "1.6.4",
     "prosemirror-transform": "1.10.2",
-    "prosemirror-view": "1.37.2",
+    "prosemirror-view": "1.39.1",
     "tslib": "^2.8.1"
   },
-  "devDependencies": {
-    "@rollup/plugin-commonjs": "^28.0.1",
-    "@rollup/plugin-node-resolve": "^15.3.0",
-    "@rollup/plugin-terser": "^0.4.4",
-    "@rollup/plugin-typescript": "^12.1.1",
-    "@types/jest": "^29.5.14",
-    "@typescript-eslint/eslint-plugin": "^7.0.1",
-    "eslint": "^8.56.0",
-    "eslint-plugin-jest": "^27.8.0",
-    "eslint-plugin-jsdoc": "^48.1.0",
-    "eslint-plugin-typescript": "^0.14.0",
-    "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "jest-preset-typescript": "^1.2.0",
-    "rollup": "^4.28.0",
-    "rollup-plugin-dts": "^6.1.1",
-    "semantic-release": "^24.2.0",
-    "ts-jest": "^29.2.5",
-    "typescript": "^5.7.2",
-    "typescript-eslint": "^7.0.1",
-    "vite": "^6.0.2"
-  },
   "jest": {
     "preset": "jest-preset-typescript",
     "testEnvironment": "jsdom"
@@ -73,19 +39,6 @@
   "bugs": {
     "url": "https://github.com/telerik/kendo-angular"
   },
-  "release": {
-    "branches": [
-      {
-        "name": "master",
-        "channel": "latest"
-      },
-      {
-        "name": "develop",
-        "prerelease": true,
-        "channel": "dev"
-      }
-    ]
-  },
   "publishConfig": {
     "access": "public"
   },

package/dist/es2015/DOMSerializer.js

@@ -1,184 +0,0 @@
-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.
-    static renderSpec(docum, structure, xmlNS = null) {
-        if (typeof structure === 'string') {
-            return { dom: docum.createTextNode(structure) };
-        }
-        if (structure.nodeType != null) {
-            return { dom: structure };
-        }
-        if (structure.dom && structure.dom.nodeType != null) {
-            return structure;
-        }
-        let tagName = structure[0], space = tagName.indexOf(' ');
-        if (space > 0) {
-            xmlNS = tagName.slice(0, space);
-            tagName = tagName.slice(space + 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 (const name in attrs) {
-                if (attrs[name] != null) {
-                    space = name.indexOf(' ');
-                    if (space > 0) {
-                        dom.setAttributeNS(name.slice(0, space), name.slice(space + 1), attrs[name]);
-                    }
-                    else {
-                        setAttribute(dom, name, attrs[name]);
-                    }
-                }
-            }
-        }
-        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, contentDOM: dom };
-            }
-            else {
-                const { dom: inner, contentDOM: innerContent } = DOMSerializer.renderSpec(docum, child, xmlNS);
-                dom.appendChild(inner);
-                if (innerContent) {
-                    if (contentDOM) {
-                        throw new RangeError('Multiple content holes');
-                    }
-                    contentDOM = innerContent;
-                }
-            }
-        }
-        return { dom, contentDOM };
-    }
-    /// Build a serializer using the [`toDOM`](#model.NodeSpec.toDOM)
-    /// properties in a schema's node and mark specs.
-    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.
-    static nodesFromSchema(schema) {
-        const result = gatherToDOM(schema.nodes);
-        if (!result.text) {
-            result.text = node => node.text;
-        }
-        return result;
-    }
-    /// Gather the serializers in a schema's mark specs into an object.
-    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.
-    serializeFragment(fragment, options = {}, target) {
-        if (!target) {
-            target = doc(options).createDocumentFragment();
-        }
-        let top = target, active = [];
-        fragment.forEach(node => {
-            if (active.length || node.marks.length) {
-                let keep = 0, rendered = 0;
-                while (keep < active.length && rendered < node.marks.length) {
-                    const next = node.marks[rendered];
-                    if (!this.marks[next.type.name]) {
-                        rendered++;
-                        continue;
-                    }
-                    if (!next.eq(active[keep][0]) || next.type.spec.spanning === false) {
-                        break;
-                    }
-                    keep++;
-                    rendered++;
-                }
-                while (keep < active.length) {
-                    top = active.pop()[1];
-                }
-                while (rendered < node.marks.length) {
-                    const add = node.marks[rendered++];
-                    const markDOM = this.serializeMark(add, node.isInline, options);
-                    if (markDOM) {
-                        active.push([add, top]);
-                        top.appendChild(markDOM.dom);
-                        top = markDOM.contentDOM || markDOM.dom;
-                    }
-                }
-            }
-            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).
-    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
-    serializeMark(mark, inline, options = {}) {
-        const toDOM = this.marks[mark.type.name];
-        return toDOM && DOMSerializer.renderSpec(doc(options), toDOM(mark, inline));
-    }
-    /// @internal
-    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');
-            }
-            this.serializeFragment(node.content, options, contentDOM);
-        }
-        return dom;
-    }
-}
-function gatherToDOM(obj) {
-    const result = {};
-    for (const name in obj) {
-        if (obj[name]) {
-            const toDOM = obj[name].spec.toDOM;
-            if (toDOM) {
-                result[name] = toDOM;
-            }
-        }
-    }
-    return result;
-}
-function doc(options) {
-    return options.document || window.document;
-}
-
-export { DOMSerializer };

package/dist/es2015/align.js

@@ -1,43 +0,0 @@
-import { blockNodes, addStyles, changeTextBlock } from './blockNode.js';
-
-/**
- * Aligning block elements in the selection.
- *
- * @returns {boolean} - Returns true if any alignment is applied.
- */
-const alignBlocks = (actions, commandName) => (state, dispatch) => {
-    const blocks = blockNodes(state);
-    const tr = state.tr;
-    tr.setMeta('commandName', commandName);
-    blocks.forEach(node => {
-        if (node.type.isTextblock) {
-            const action = actions.find(n => n.node === node.type.name);
-            if (action) {
-                const newAttrs = addStyles(node, action.style);
-                changeTextBlock(tr, node, node.type, newAttrs);
-            }
-        }
-    });
-    const result = tr.docChanged;
-    if (result) {
-        dispatch(tr.scrollIntoView());
-    }
-    return result;
-};
-const isAligned = (state, actions) => {
-    const blocks = blockNodes(state);
-    let result = false;
-    blocks.forEach(node => {
-        if (!result && node.type.isTextblock && node.attrs.style) {
-            const action = actions.find(a => a.node === node.type.name);
-            if (action) {
-                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 };