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

package/dist/es2015/config/schema.js

@@ -1,314 +0,0 @@
-import { Schema } from 'prosemirror-model';
-import { tableNodes } from 'prosemirror-tables';
-import { domToPmDoc, htmlToFragment, pmDocToFragment } from '../source.js';
-import { colgroupAttr, resizableAttr, rowTypeAttr } from './constants.js';
-
-const hole = 0;
-const blockquoteDOM = ['blockquote', hole], hrDOM = ['hr'], preDOM = ['pre', ['code', hole]];
-const olDOM = ['ol', 0], ulDOM = ['ul', 0], liDOM = ['li', 0];
-const domAttributes = (dom) => {
-    const result = {};
-    const attributes = dom.attributes;
-    let attr;
-    for (let i = 0; i < attributes.length; i++) {
-        attr = attributes[i];
-        result[attr.name] = attr.value;
-    }
-    return result;
-};
-const defaultAttrs = (attrs) => {
-    const nodeAttrs = {};
-    attrs.forEach(attr => {
-        nodeAttrs[attr] = { default: null };
-    });
-    return nodeAttrs;
-};
-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;
-};
-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];
-        }
-    }
-    return result;
-};
-const tagMark = tag => {
-    return {
-        [tag]: {
-            name: tag,
-            inclusive: true, // https://prosemirror.net/docs/ref/#model.MarkSpec.inclusive
-            parseDOM: [{ tag: tag }],
-            toDOM: () => [tag, hole]
-        }
-    };
-};
-const marks = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ 
-    // :: MarkSpec A link. Has `href` and `title` attributes. `title`
-    // defaults to the empty string. Rendered and parsed as an `<a>`
-    // element.
-    link: {
-        attrs: Object.assign(Object.assign({}, commonAttributes()), { href: { default: null }, target: { default: null }, title: { default: null } }),
-        inclusive: false,
-        parseDOM: [{ tag: 'a', getAttrs: domAttributes }],
-        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: Object.assign({}, commonAttributes()),
-        parseDOM: [{
-                tag: 'span',
-                getAttrs: domAttributes
-            }],
-        toDOM: node => hasAttrs(node.attrs) ?
-            ['span', pmAttributes(node.attrs), hole] : ['span', hole]
-    } }), tagMark('u'));
-const cellAttribute = (name) => {
-    return {
-        [name]: {
-            default: null,
-            getFromDOM: (cell) => cell.getAttribute(name),
-            setDOMAttr: (value, attrs) => { attrs[name] = value; }
-        }
-    };
-};
-const cellAttributes = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, cellAttribute('style')), cellAttribute('class')), cellAttribute('id')), cellAttribute('headers')), cellAttribute('scope'));
-const colgroupNodes = {
-    doc: { content: 'colgroup*' },
-    col: {
-        attrs: defaultAttrs(['id', 'class', 'style', 'span']),
-        parseDOM: [{ getAttrs: domAttributes, tag: 'col' }],
-        toDOM: node => ['col', node.attrs]
-    },
-    colgroup: {
-        attrs: defaultAttrs(['id', 'class', 'style', 'span']),
-        content: 'col*',
-        parseDOM: [{ getAttrs: domAttributes, tag: 'colgroup' }],
-        toDOM: node => ['colgroup', node.attrs, 0]
-    },
-    text: { inline: true, group: 'inline' }
-};
-const colgroupSchema = new Schema({ nodes: colgroupNodes, marks: {} });
-// will be removed when we implement our own columnResizing
-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;
-        }
-    }
-    return shouldSkip;
-};
-const parseStrColgroup = (colgroup) => {
-    const doc = domToPmDoc(htmlToFragment(colgroup), colgroupSchema, { preserveWhitespace: false });
-    const fragment = pmDocToFragment(doc);
-    const colgroupEl = fragment.firstChild;
-    return colgroupEl;
-};
-const tNodes = tableNodes({ tableGroup: 'block', cellContent: 'block+', cellAttributes });
-tNodes.table_row.attrs = Object.assign(Object.assign({}, tNodes.table_row.attrs), defaultAttrs([rowTypeAttr, 'style', 'class', 'id']));
-tNodes.table_row.toDOM = node => ['tr', pmAttributes(node.attrs), 0];
-tNodes.table_row.parseDOM = [{ tag: 'tr', getAttrs: domAttributes }];
-tNodes.table.attrs = Object.assign(Object.assign({}, tNodes.table.attrs), defaultAttrs(['style', 'class', 'id', colgroupAttr, resizableAttr]));
-tNodes.table.toDOM = (node) => {
-    const tableAttrs = hasAttrs(node.attrs) ? pmAttributes(node.attrs, [colgroupAttr, resizableAttr]) : {};
-    let colgroup = null;
-    if (node.attrs[colgroupAttr] && !shouldSkipColgroup(node)) {
-        const colgroupEl = parseStrColgroup(node.attrs[colgroupAttr]);
-        if (colgroupEl) {
-            const cols = Array.from(colgroupEl.children).map((c) => ['col', domAttributes(c)]);
-            colgroup = [
-                'colgroup',
-                domAttributes(colgroupEl)
-            ].concat(cols);
-        }
-    }
-    return colgroup ? ['table', tableAttrs, colgroup, ['tbody', 0]] :
-        ['table', tableAttrs, ['tbody', 0]];
-};
-tNodes.table.parseDOM = [{
-        tag: 'table',
-        getAttrs: (node) => {
-            const attrs = domAttributes(node);
-            const colgroup = Array.from(node.childNodes).find(c => c.nodeName === 'COLGROUP');
-            if (colgroup) {
-                attrs[colgroupAttr] = colgroup.outerHTML;
-            }
-            return attrs;
-        }
-    }];
-const nodes = Object.assign({ 
-    // :: 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: Object.assign({}, commonAttributes()),
-        parseDOM: [{
-                tag: 'p',
-                getAttrs: domAttributes
-            }],
-        toDOM: node => hasAttrs(node.attrs) ? ['p', pmAttributes(node.attrs), hole] : ['p', hole]
-    }, table_wrapper: {
-        content: '(table_caption_external | table)+',
-        group: 'block',
-        defining: true,
-        attrs: {
-            table: { default: null },
-            style: { default: null }
-        },
-        parseDOM: [{
-                tag: 'div[table]',
-                getAttrs: domAttributes
-            }],
-        toDOM: node => hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]
-    }, table_caption_external: {
-        content: 'inline+',
-        group: 'block',
-        attrs: Object.assign({ caption: { default: null } }, commonAttributes()),
-        parseDOM: [{
-                tag: 'div[caption]',
-                getAttrs: domAttributes
-            }],
-        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: Object.assign({}, commonAttributes()),
-        parseDOM: [{
-                tag: 'div',
-                getAttrs: domAttributes
-            }],
-        toDOM: node => hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]
-    }, 
-    // :: NodeSpec A blockquote (`<blockquote>`) wrapping one or more blocks.
-    blockquote: {
-        attrs: Object.assign({}, commonAttributes()),
-        content: 'block+',
-        group: 'block',
-        defining: true, // https://prosemirror.net/docs/ref/#model.NodeSpec.defining
-        parseDOM: [{
-                tag: 'blockquote',
-                getAttrs: domAttributes
-            }],
-        toDOM: node => hasAttrs(node.attrs) ? ['blockquote', pmAttributes(node.attrs), hole] : blockquoteDOM
-    }, 
-    // :: NodeSpec A horizontal rule (`<hr>`).
-    horizontal_rule: {
-        group: 'block',
-        parseDOM: [{ tag: 'hr' }],
-        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: Object.assign(Object.assign({}, commonAttributes()), { level: { default: 1 } }),
-        content: 'inline*',
-        group: 'block',
-        defining: true,
-        parseDOM: [
-            { tag: 'h1', getAttrs: node => (Object.assign(Object.assign({}, domAttributes(node)), { level: 1 })) },
-            { tag: 'h2', getAttrs: node => (Object.assign(Object.assign({}, domAttributes(node)), { level: 2 })) },
-            { tag: 'h3', getAttrs: node => (Object.assign(Object.assign({}, domAttributes(node)), { level: 3 })) },
-            { tag: 'h4', getAttrs: node => (Object.assign(Object.assign({}, domAttributes(node)), { level: 4 })) },
-            { tag: 'h5', getAttrs: node => (Object.assign(Object.assign({}, domAttributes(node)), { level: 5 })) },
-            { tag: 'h6', getAttrs: node => (Object.assign(Object.assign({}, domAttributes(node)), { level: 6 })) }
-        ],
-        toDOM: node => hasAttrs(node.attrs, 'level') ?
-            ['h' + node.attrs.level, pmAttributes(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.
-    code_block: {
-        content: 'text*',
-        marks: '',
-        group: 'block',
-        code: true,
-        defining: true,
-        parseDOM: [{ tag: 'pre', preserveWhitespace: 'full' }],
-        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: Object.assign({ 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: 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: Object.assign({}, commonAttributes()),
-        group: 'inline',
-        selectable: false,
-        parseDOM: [{
-                tag: 'br',
-                getAttrs: domAttributes
-            }],
-        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
-    // starts counting, and defaults to 1. Represented as an `<ol>`
-    // element.
-    ordered_list: {
-        content: 'list_item+',
-        group: 'block',
-        attrs: Object.assign(Object.assign({}, commonAttributes()), { type: { default: null }, order: { default: 1 } }),
-        parseDOM: [{ tag: 'ol', getAttrs: (dom) => {
-                    return Object.assign(Object.assign({}, domAttributes(dom)), { order: dom.hasAttribute('start') ? parseInt(dom.getAttribute('start') || '1', 10) : 1 });
-                } }],
-        toDOM: node => {
-            return node.attrs.order === 1 ?
-                (hasAttrs(node.attrs, 'order') ? ['ol', pmAttributes(node.attrs, ['order']), hole] : olDOM) :
-                ['ol', Object.assign(Object.assign({}, 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: Object.assign({}, commonAttributes()),
-        parseDOM: [{ tag: 'ul', getAttrs: domAttributes }],
-        toDOM: node => hasAttrs(node.attrs) ? ['ul', pmAttributes(node.attrs), hole] : ulDOM
-    }, 
-    // :: NodeSpec
-    // A list item (`<li>`) specification.
-    list_item: {
-        content: '(paragraph | heading) block*',
-        attrs: Object.assign({}, commonAttributes()),
-        parseDOM: [{ tag: 'li', getAttrs: domAttributes }],
-        toDOM: node => hasAttrs(node.attrs) ? ['li', pmAttributes(node.attrs), hole] : liDOM,
-        defining: true
-    } }, tNodes);
-
-export { marks, nodes, parseStrColgroup };

package/dist/es2015/find-replace.js

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

package/dist/es2015/flatten-spans.js

@@ -1,112 +0,0 @@
-import { htmlToFragment, fragmentToHtml } from './source.js';
-
-class DomTreeExtractor {
-    constructor(top) {
-        this.extractBefore = (edgeNode) => {
-            return this._traverseSide({
-                edge: edgeNode,
-                next: function (node) {
-                    return node.previousSibling;
-                },
-                insert: function (fragment, node) {
-                    fragment.insertBefore(node, fragment.firstChild);
-                }
-            });
-        };
-        this.extractAfter = (edgeNode) => {
-            return this._traverseSide({
-                edge: edgeNode,
-                next: function (node) {
-                    return node.nextSibling;
-                },
-                insert: function (fragment, node) {
-                    fragment.appendChild(node);
-                }
-            });
-        };
-        this._traverseSide = (options) => {
-            const top = this.top, doc = top.ownerDocument, fragment = doc.createDocumentFragment();
-            let current = options.edge;
-            do {
-                const parentNode = current.parentNode;
-                current = options.next(current);
-                while (current) {
-                    const next = options.next(current);
-                    options.insert(fragment, current);
-                    current = next;
-                }
-                if (top === parentNode || top.contains(parentNode)) {
-                    const container = parentNode.cloneNode(false);
-                    container.innerHTML = '';
-                    container.appendChild(fragment);
-                    options.insert(fragment, container);
-                }
-                current = parentNode;
-            } while (current && current !== top);
-            return fragment;
-        };
-        this.top = top;
-    }
-}
-const getInnerSpan = (dom) => {
-    return dom.querySelector('span span');
-};
-const isEmptySpan = (fragment) => {
-    return fragment.childNodes.length === 1 && fragment.firstChild.nodeName === 'SPAN' && fragment.firstChild.childNodes.length === 0;
-};
-/**
- * Flattens nested <span> elements in the given HTML string while preserving
- * the original styling and formatting.
- *
- * @param content - The HTML content to normalize.
- * @returns The normalized HTML content with flattened <span> elements.
- */
-const flattenNestedSpans = (content) => {
-    const dom = htmlToFragment(content);
-    let innerSpan = getInnerSpan(dom);
-    while (innerSpan) {
-        const parentSpan = innerSpan.parentNode.closest('span');
-        if (parentSpan) {
-            const extractor = new DomTreeExtractor(parentSpan);
-            const right = extractor.extractAfter(innerSpan);
-            const left = extractor.extractBefore(innerSpan);
-            for (let i = 0; i < innerSpan.style.length; i++) {
-                const prop = innerSpan.style.item(i);
-                parentSpan.style[prop] = innerSpan.style.getPropertyValue(prop);
-            }
-            innerSpan.removeAttribute('style');
-            if (innerSpan.classList.length) {
-                Array.from(innerSpan.classList).forEach((classValue) => {
-                    if (!parentSpan.classList.contains(classValue)) {
-                        parentSpan.classList.add(classValue);
-                    }
-                });
-            }
-            innerSpan.removeAttribute('class');
-            for (let index = 0; index < innerSpan.attributes.length; index++) {
-                const attr = innerSpan.attributes.item(index);
-                if (attr && attr.nodeValue !== null) {
-                    parentSpan.setAttribute(attr.nodeName, attr.nodeValue);
-                }
-            }
-            while (innerSpan.firstChild && innerSpan.parentNode) {
-                innerSpan.parentNode.insertBefore(innerSpan.firstChild, innerSpan);
-            }
-            if (innerSpan.parentNode) {
-                innerSpan.parentNode.removeChild(innerSpan);
-            }
-            if (parentSpan.parentNode) {
-                if (!isEmptySpan(left)) {
-                    parentSpan.parentNode.insertBefore(left, parentSpan);
-                }
-                if (!isEmptySpan(right)) {
-                    parentSpan.parentNode.insertBefore(right, parentSpan.nextSibling);
-                }
-            }
-        }
-        innerSpan = getInnerSpan(dom);
-    }
-    return fragmentToHtml(dom);
-};
-
-export { flattenNestedSpans };

package/dist/es2015/image.js

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

package/dist/es2015/indent.js

@@ -1,105 +0,0 @@
-import { sinkListItem, liftListItem } from 'prosemirror-schema-list';
-import { indentRules, outdentRules } from './config/indent-rules.js';
-import { hasNode, blockNodes, addStyles, changeTextBlock } from './blockNode.js';
-import { findNthParentNodeOfType } from './utils.js';
-import { liftBlockquote } from './blockquote.js';
-
-/**
- * Indenting block elements in the selection.
- *
- * @returns {boolean} - Returns true if any indentation is applied.
- */
-const indentBlocks = (actions, command, dir) => (state, dispatch) => {
-    const blocks = blockNodes(state);
-    const tr = state.tr;
-    tr.setMeta('commandName', command);
-    blocks.forEach(node => {
-        if (node.type.isTextblock) {
-            let newAttrs;
-            const action = actions.find(a => a.node === node.type.name);
-            if (action) {
-                const style = dir === 'rtl' ? action.rtlStyle : action.style;
-                const newStyle = {
-                    name: style,
-                    value: action.step > 0 ? `${action.step}${action.unit}` : ''
-                };
-                if (node.attrs.style) {
-                    const re = new RegExp(`${style}:\\s?(\\d+)${action.unit}`, 'i');
-                    const match = node.attrs.style.match(re);
-                    if (match) {
-                        let newMargin = parseFloat(match[1]) + action.step;
-                        newMargin = newMargin <= 0 ? '' : newMargin;
-                        newStyle.value = `${newMargin}${newMargin ? action.unit : ''}`;
-                    }
-                }
-                newAttrs = addStyles(node, [newStyle]);
-            }
-            if (newAttrs) {
-                changeTextBlock(tr, node, node.type, newAttrs);
-            }
-        }
-    });
-    const result = tr.docChanged;
-    if (result) {
-        dispatch(tr.scrollIntoView());
-    }
-    return result;
-};
-const isIndented = (state, rules, dir) => {
-    const blocks = blockNodes(state);
-    let result = false;
-    blocks.forEach(node => {
-        if (!result && node.type.isTextblock && node.attrs.style) {
-            const action = rules.find(a => a.node === node.type.name);
-            if (action) {
-                const style = dir === 'rtl' ? action.rtlStyle : action.style;
-                const reIndent = new RegExp(`${style}:\\s?\\d+${action.unit}`, 'i');
-                result = reIndent.test(node.attrs.style);
-            }
-        }
-    });
-    return result;
-};
-const canIndentAsListItem = (state, nodeType) => {
-    return sinkListItem(nodeType)(state);
-};
-const canOutdentAsListItem = (state, rules) => {
-    const listItem = state.schema.nodes[rules.listsTypes.listItem];
-    const orderedList = state.schema.nodes[rules.listsTypes.orderedList];
-    const bulletList = state.schema.nodes[rules.listsTypes.bulletList];
-    const isNestedInOL = !!findNthParentNodeOfType(orderedList, 2)(state.selection);
-    const isNestedInUL = !!findNthParentNodeOfType(bulletList, 2)(state.selection);
-    return (isNestedInOL || isNestedInUL) && liftListItem(listItem)(state);
-};
-const canBeIndented = (state, rules) => {
-    const nodes = state.schema.nodes;
-    const listItem = nodes[indentRules.listsTypes.listItem];
-    return ((isIndented(state, rules.nodes) || indentRules.nodes.some(rule => nodes[rule.node] && hasNode(state, nodes[rule.node]))) &&
-        !hasNode(state, listItem));
-};
-const indent = (state, dispatch) => {
-    const listItem = state.schema.nodes[indentRules.listsTypes.listItem];
-    const isIndentableBlock = canBeIndented(state, indentRules);
-    if (canIndentAsListItem(state, listItem)) {
-        sinkListItem(listItem)(state, dispatch);
-    }
-    else if (isIndentableBlock) {
-        indentBlocks(indentRules.nodes)(state, dispatch);
-    }
-};
-const outdent = (state, dispatch) => {
-    const nodes = state.schema.nodes;
-    const listItem = nodes[outdentRules.listsTypes.listItem];
-    const isIndentableBlock = canBeIndented(state, outdentRules);
-    if (hasNode(state, nodes.blockquote)) {
-        liftBlockquote(state, dispatch);
-    }
-    else if (canOutdentAsListItem(state, outdentRules)) {
-        liftListItem(listItem)(state, dispatch);
-    }
-    else if (isIndentableBlock) {
-        indentBlocks(outdentRules.nodes)(state, dispatch);
-    }
-};
-
-export { canBeIndented, canIndentAsListItem, canOutdentAsListItem, indent, indentBlocks, isIndented, outdent };