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

package/dist/es2015/source.js

@@ -1,251 +0,0 @@
-import { DOMParser, Fragment } from 'prosemirror-model';
-import { AllSelection } from 'prosemirror-state';
-import { rowTypeAttr, colgroupAttr } from './config/constants.js';
-import { DOMSerializer } from './DOMSerializer.js';
-import { setStyleAttr } from './utils.js';
-
-const blockWrappers = [
-    'div', 'ol', 'ul', 'li', 'table', 'tbody', 'thead', 'tfoot', 'caption', 'td', 'th', 'p',
-    'tr', 'col', 'colgroup', 'article', 'main', 'nav', 'header', 'footer', 'aside', 'section'
-];
-const removeRowType = (table, nodeName) => {
-    const wrapper = (table.ownerDocument || document).createElement(nodeName);
-    Array.from(table.rows).filter(r => r.getAttribute(rowTypeAttr) === nodeName).forEach(row => {
-        row.removeAttribute(rowTypeAttr);
-        wrapper.appendChild(row);
-    });
-    if (wrapper.children.length) {
-        table.appendChild(wrapper);
-    }
-};
-const restoreTables = (fragment) => {
-    Array.from(fragment.querySelectorAll('table')).forEach((table) => {
-        removeRowType(table, 'thead');
-        removeRowType(table, 'tbody');
-        removeRowType(table, 'tfoot');
-        const emptyElement = Array.from(table.children).find(el => el.children.length === 0);
-        if (emptyElement) {
-            emptyElement.remove();
-        }
-        const wrapper = table.parentNode instanceof HTMLDivElement ? table.parentNode : null;
-        if (wrapper && wrapper.matches('div[table]')) {
-            table.style.marginLeft = wrapper.style.marginLeft;
-            table.style.marginRight = wrapper.style.marginRight;
-            const captionDiv = Array.from(wrapper.children).find(el => el.matches('div[caption]'));
-            if (captionDiv && captionDiv.innerHTML !== '<img>') {
-                const caption = table.createCaption();
-                if (captionDiv.id) {
-                    caption.id = captionDiv.id;
-                }
-                if (captionDiv.className) {
-                    caption.className = captionDiv.className;
-                }
-                Array.from(captionDiv.style).forEach((styleName) => {
-                    caption.style[styleName] = captionDiv.style[styleName];
-                });
-                while (captionDiv.firstChild) {
-                    caption.appendChild(captionDiv.firstChild);
-                }
-            }
-            if (wrapper.style.width && !table.style.width) {
-                table.style.width = wrapper.style.width;
-            }
-            wrapper.parentNode.insertBefore(table, wrapper);
-            wrapper.parentNode.removeChild(wrapper);
-        }
-    });
-};
-const setRowType = (children, nodeName) => {
-    const tag = nodeName.toUpperCase();
-    children.filter(c => c.nodeName === tag).forEach(rowsWrapper => {
-        Array.from(rowsWrapper.children).forEach(row => {
-            row.setAttribute(rowTypeAttr, nodeName);
-            if (rowsWrapper.parentNode) {
-                rowsWrapper.parentNode.insertBefore(row, rowsWrapper);
-            }
-        });
-        rowsWrapper.remove();
-    });
-};
-const validateTablesToPmSchema = (fragment) => {
-    Array.from(fragment.querySelectorAll('table')).forEach((table) => {
-        const children = Array.from(table.children);
-        if (children.some(e => e.nodeName === 'THEAD' || e.nodeName === 'TFOOT')) {
-            setRowType(children, 'thead');
-            setRowType(children, 'tbody');
-            setRowType(children, 'tfoot');
-        }
-        const colgroup = children.find(c => c.nodeName === 'COLGROUP');
-        if (colgroup) {
-            table.setAttribute(colgroupAttr, colgroup.outerHTML);
-            colgroup.remove();
-        }
-        if (table.caption || table.style.marginLeft || table.style.marginRight) {
-            const wrapper = document.createElement('div');
-            wrapper.setAttribute('table', '');
-            wrapper.style.display = 'table';
-            wrapper.style.marginLeft = table.style.marginLeft;
-            wrapper.style.marginRight = table.style.marginRight;
-            if (table.caption) {
-                const captionDiv = document.createElement('div');
-                captionDiv.setAttribute('caption', '');
-                if (table.caption.id) {
-                    captionDiv.id = table.caption.id;
-                }
-                if (table.caption.className) {
-                    captionDiv.className = table.caption.className;
-                }
-                Array.from(table.caption.style).forEach((styleName) => {
-                    captionDiv.style[styleName] = table.caption.style[styleName];
-                });
-                while (table.caption.firstChild) {
-                    captionDiv.appendChild(table.caption.firstChild);
-                }
-                table.removeChild(table.caption);
-                wrapper.appendChild(captionDiv);
-            }
-            table.parentNode.insertBefore(wrapper, table);
-            wrapper.appendChild(table);
-            if (/%/.test(table.style.width)) {
-                wrapper.style.width = table.style.width;
-                table.style.width = '';
-            }
-        }
-    });
-};
-/**
- * Trims the whitespace around the provided block nodes.
- *
- * @param html - Input HTML content
- * @param trimAroundTags - Block elements to which trimming will be applied.
- * Defaults to block nodes of the current default schema:
- * 'div', 'ol', 'ul', 'li', 'table', 'tbody', 'thead', 'tfoot', 'td', 'th', 'p'
- * and additional table and semantic nodes from the default Angular Editor schema:
- * 'tr', 'col', 'colgroup', 'article', 'main', 'nav', 'header', 'footer', 'aside', 'section'
- *
- * @returns The trimmed HTML content
- */
-const trimWhitespace = (html, trimAroundTags = blockWrappers) => {
-    const tags = trimAroundTags.join('|');
-    return html.replace(new RegExp('\\s*(<(?:' + tags + ')(?:\\s[^>]*?)?>)', 'g'), '$1')
-        .replace(new RegExp('(<\\/(?:' + tags + ')(?:\\s[^>]*?)?>)\\s*', 'g'), '$1');
-};
-const styleAttr = 'data-style';
-const styleReplace = ' ' + styleAttr + '=';
-const reTag = /<[^>]+>/gm;
-const reStyle = /\sstyle=/gm;
-const replacer = (match) => {
-    return match.replace(reStyle, styleReplace);
-};
-const replaceStyleAttr = (html) => {
-    return html.replace(reTag, replacer);
-};
-const restoreStyleAttr = (container) => {
-    Array.from(container.querySelectorAll('[' + styleAttr + ']')).forEach((element) => {
-        const styleString = element.getAttribute(styleAttr);
-        element.removeAttribute(styleAttr);
-        setStyleAttr(element, styleString);
-    });
-};
-/**
- * Creates a DocumentFragment from the given HTML content.
- *
- * @param html
- * @returns DocumentFragment
- */
-const htmlToFragment = (html) => {
-    const template = document.createElement('template');
-    template.innerHTML = replaceStyleAttr(html);
-    restoreStyleAttr(template.content);
-    return template.content.cloneNode(true);
-};
-/**
- * @hidden
- */
-const fragmentToHtml = (fragment) => {
-    return Array.from(fragment.childNodes).reduce((acc, cur) => acc + (cur.outerHTML || cur.textContent || ''), '');
-};
-/**
- * Creates a DocumentFragment from the given ProseMirrorNode.
- *
- * @param doc ProseMirrorNode
- * @returns DocumentFragment
- */
-const pmDocToFragment = (doc) => {
-    const fragment = DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
-    restoreTables(fragment);
-    return fragment;
-};
-/**
- * Creates a ProseMirrorNode from the given DOM element.
- *
- * @param dom
- * @param schema
- * @param parseOptions
- * @returns ProseMirrorNode
- */
-const domToPmDoc = (dom, schema, parseOptions) => {
-    return DOMParser.fromSchema(schema).parse(dom, parseOptions);
-};
-/**
- * Creates a ProseMirrorNode from the given HTML content.
- *
- * @param content - The new HTML content.
- * @param schema - The document schema.
- * @param parseOptions - ProseMirror parse options recognized by the `parse` and `parseSlice` methods.
- * @returns - New ProseMirrorNode instance.
- */
-const parseContent = (content, schema, parseOptions) => {
-    const dom = htmlToFragment(content);
-    validateTablesToPmSchema(dom);
-    return domToPmDoc(dom, schema, parseOptions);
-};
-/**
- * A function that serializes the Editor State content as HTML string.
- *
- * @param state - The Editor State
- * @returns - The serialized content
- */
-const getHtml = (state) => {
-    const fragment = pmDocToFragment(state.doc);
-    return fragmentToHtml(fragment);
-};
-/**
- * Replaces the content of the editor with a new one.
- *
- * @param content - The new HTML content.
- * @param commandName - The name of the command.
- * @param parseOptions - ProseMirror parse options recognized by the `parse` and `parseSlice` methods.
- * @returns - Command function that takes an editor `state` and `dispatch` function.
- */
-const setHtml = (content, command = 'setHTML', parseOptions = { preserveWhitespace: 'full' }) => (state, dispatch) => dispatch(state.tr
-    .setSelection(new AllSelection(state.doc))
-    .replaceSelectionWith(parseContent(content, state.schema, parseOptions))
-    .setMeta('commandName', command));
-/**
- * @hidden
- */
-const hasSameMarkup = (dom1, dom2, schema, parseOptions) => {
-    const fragment1 = Fragment.from(parseContent(dom1, schema, parseOptions));
-    const fragment2 = Fragment.from(parseContent(dom2, schema, parseOptions));
-    return fragment1.eq(fragment2);
-};
-/**
- * Removes comments in HTML.
- */
-const removeComments = (html) => {
-    const fragment = htmlToFragment(html);
-    removeCommentsFromDom(fragment);
-    return fragmentToHtml(fragment);
-};
-const removeCommentsFromDom = (dom) => {
-    var _a;
-    const iterator = dom.ownerDocument.createNodeIterator(dom, NodeFilter.SHOW_COMMENT);
-    let commentNode = iterator.nextNode();
-    while (commentNode) {
-        (_a = commentNode.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(commentNode);
-        commentNode = iterator.nextNode();
-    }
-};
-
-export { domToPmDoc, fragmentToHtml, getHtml, hasSameMarkup, htmlToFragment, parseContent, pmDocToFragment, removeComments, setHtml, trimWhitespace };

package/dist/es2015/table.js

@@ -1,132 +0,0 @@
-import { addRowAfter as addRowAfter$1, addRowBefore as addRowBefore$1, addColumnBefore as addColumnBefore$1, addColumnAfter as addColumnAfter$1, deleteColumn as deleteColumn$1, TableMap } from 'prosemirror-tables';
-export { addColumnAfter as pmAddColumnAfter, addColumnBefore as pmAddColumnBefore, addRowAfter as pmAddRowAfter, addRowBefore as pmAddRowBefore, deleteColumn as pmDeleteColumn } from 'prosemirror-tables';
-import { colgroupAttr, rowTypeAttr } from './config/constants.js';
-import { parseStrColgroup } from './config/schema.js';
-
-/**
- * Creates a table.
- *
- * @returns Node
- */
-const createTable = (nodes, rows, columns) => {
-    const { table, table_row, table_cell } = nodes;
-    const tableRows = [];
-    let cells;
-    for (let r = 0; r < rows + 1; r++) {
-        cells = [];
-        for (let c = 0; c < columns + 1; c++) {
-            cells.push(table_cell.createAndFill());
-        }
-        tableRows.push(table_row.createAndFill(undefined, cells));
-    }
-    return table.createAndFill(undefined, tableRows);
-};
-const reTable = /^table$/;
-const reRow = /^table_row$/;
-const reCell = /^table_cell|table_header$/;
-const closest = (selection, name) => {
-    const pos = selection.$head;
-    for (let i = pos.depth; i > 0; i--) {
-        const node = pos.node(i);
-        if (name.test(node.type.name)) {
-            return {
-                pos: pos.before(i),
-                node
-            };
-        }
-    }
-    return null;
-};
-const addRowBefore = (state, dispatch) => {
-    const cmdDispatch = dispatch && (tr => {
-        const row = closest(tr.selection, reRow);
-        const table = closest(tr.selection, reTable);
-        if (row && table && row.node.attrs[rowTypeAttr]) {
-            let index = 0;
-            for (let i = 0; i < table.node.nodeSize; i++) {
-                if (table.node.child(i).eq(row.node)) {
-                    index = i;
-                    break;
-                }
-            }
-            const next = table.node.child(index - 1);
-            const from = row.pos - next.nodeSize;
-            tr.setNodeMarkup(from, undefined, { [rowTypeAttr]: row.node.attrs[rowTypeAttr] });
-        }
-        return dispatch(tr);
-    });
-    return addRowBefore$1(state, cmdDispatch);
-};
-const addRowAfter = (state, dispatch) => {
-    const cmdDispatch = dispatch && (tr => {
-        const row = closest(tr.selection, reRow);
-        if (row && row.node.attrs[rowTypeAttr]) {
-            const from = row.pos + row.node.nodeSize;
-            tr.setNodeMarkup(from, undefined, { [rowTypeAttr]: row.node.attrs[rowTypeAttr] });
-        }
-        return dispatch(tr);
-    });
-    return addRowAfter$1(state, cmdDispatch);
-};
-const columnIndex = (table, selection) => {
-    if (!table) {
-        return -1;
-    }
-    const map = TableMap.get(table.node);
-    const tableCell = closest(selection, reCell);
-    const idx = map.map.indexOf(tableCell.pos - table.pos - 1);
-    let colIndex = -1;
-    if (idx !== -1) {
-        colIndex = idx % map.width;
-    }
-    return colIndex;
-};
-const addCol = (tr, table, to) => {
-    const colIndex = columnIndex(table, tr.selection);
-    const colgroup = parseStrColgroup(table.node.attrs[colgroupAttr]);
-    colgroup.insertBefore(colgroup.ownerDocument.createElement('col'), colgroup.children[colIndex + to]);
-    tr.setNodeMarkup(table.pos, null, Object.assign(Object.assign({}, table.node.attrs), { [colgroupAttr]: colgroup.outerHTML }));
-};
-const deleteCol = (tr, table, colIndex) => {
-    const colgroup = parseStrColgroup(table.node.attrs[colgroupAttr]);
-    colgroup.removeChild(colgroup.children[colIndex]);
-    tr.setNodeMarkup(table.pos, null, Object.assign(Object.assign({}, table.node.attrs), { [colgroupAttr]: colgroup.outerHTML }));
-};
-const addColumnBefore = (state, dispatch) => {
-    const cmdDispatch = dispatch && (tr => {
-        const table = closest(tr.selection, reTable);
-        if (!table.node.attrs[colgroupAttr]) {
-            return dispatch(tr);
-        }
-        addCol(tr, table, -1);
-        return dispatch(tr);
-    });
-    return addColumnBefore$1(state, cmdDispatch);
-};
-const addColumnAfter = (state, dispatch) => {
-    const cmdDispatch = dispatch && (tr => {
-        const table = closest(tr.selection, reTable);
-        if (!table.node.attrs[colgroupAttr]) {
-            return dispatch(tr);
-        }
-        addCol(tr, table, 1);
-        return dispatch(tr);
-    });
-    return addColumnAfter$1(state, cmdDispatch);
-};
-const deleteColumn = (state, dispatch) => {
-    const parentTable = closest(state.selection, reTable);
-    const colgroup = parentTable && parentTable.node.attrs[colgroupAttr];
-    const colIndex = columnIndex(parentTable, state.selection);
-    const cmdDispatch = dispatch && ((tr) => {
-        if (!colgroup) {
-            return dispatch(tr);
-        }
-        const table = tr.doc.nodeAt(parentTable.pos);
-        deleteCol(tr, { node: table, pos: parentTable.pos }, colIndex);
-        return dispatch(tr);
-    });
-    return deleteColumn$1(state, cmdDispatch);
-};
-
-export { addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, createTable, deleteColumn };

package/dist/es2015/text.js

@@ -1,5 +0,0 @@
-const insertText = (attrs) => (state, dispatch) => {
-    dispatch(state.tr.insertText(attrs.text, attrs.from, attrs.to));
-};
-
-export { insertText };

package/dist/es2015/utils.js

@@ -1,289 +0,0 @@
-import { Node } from 'prosemirror-model';
-import { TextSelection, AllSelection, NodeSelection } from 'prosemirror-state';
-import { parseInlineStyles } from '@progress/kendo-common';
-
-const changeStylesString = (styleText, newStyle) => {
-    const styleToChange = newStyle.style;
-    const regExp = newStyle.value;
-    const newValue = newStyle.newValue;
-    if (!styleText) {
-        return { changed: false, style: null };
-    }
-    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(`${styleToChange}: ${newValue}`);
-    }
-    return {
-        style: filtered.join('; ') + (filtered.length ? ';' : ''),
-        changed: Boolean(newValue) || filtered.length !== styleNames.length
-    };
-};
-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 });
-        attrs = Object.assign(Object.assign({}, nodeAttrs), { style });
-    }
-    else if (nodeAttrs.style) {
-        attrs = Object.assign(Object.assign({}, nodeAttrs), { style: nodeAttrs.style.replace(/;$/, '') + '; ' + styleType + ': ' + value + ';' });
-    }
-    else {
-        attrs = Object.assign(Object.assign({}, nodeAttrs), { style: styleType + ': ' + value + ';' });
-    }
-    return attrs;
-}
-/**
- * Determines if a given node type can be inserted at the current cursor position.
- */
-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;
-};
-const getTypeName = (n) => {
-    return n instanceof Node ? n.type.name : n.name;
-};
-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 };
-                }
-            }
-        }
-    };
-};
-const findNthParentNodeOfType = (nodeType, depth = 1) => {
-    return (selection) => {
-        return findNthParentNode((node) => getTypeName(node) === getTypeName(nodeType), depth)(selection);
-    };
-};
-function parentNode(pos, predicate) {
-    for (let depth = pos.depth; depth > 0; depth--) {
-        const node = pos.node(depth);
-        if (predicate(node)) {
-            return { node, depth };
-        }
-    }
-    return null;
-}
-const filterEmptyAttrs = (attrs) => {
-    const result = {};
-    for (const attr in attrs) {
-        if (attr && (attrs[attr] || attrs[attr] === 0)) {
-            result[attr] = attrs[attr];
-        }
-    }
-    return result;
-};
-/**
- * Inserts the given node at the place of current selection.
- */
-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, Object.assign(Object.assign({}, filterEmptyAttrs(selection.node.attrs)), filterEmptyAttrs(node.attrs)));
-        tr.setSelection(NodeSelection.create(tr.doc, selection.from));
-    }
-    else {
-        tr.replaceSelectionWith(node);
-    }
-    if (scrollIntoView) {
-        tr.scrollIntoView();
-    }
-    dispatch(tr);
-};
-const getSelectionText = (state) => {
-    const sel = state.selection;
-    if (sel instanceof TextSelection || sel instanceof AllSelection) {
-        const fragment = sel.content().content;
-        return fragment.textBetween(0, fragment.size);
-    }
-    return '';
-};
-const getNodeFromSelection = (state) => {
-    if (state.selection instanceof NodeSelection) {
-        return state.selection.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
- * text from multiple block nodes, the function will return empty string.
- *
- * 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.
- */
-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, (node) => {
-            hasLeafs = hasLeafs || (node.isLeaf && !node.isText);
-        });
-        if (!hasLeafs) {
-            result = getSelectionText(state);
-        }
-    }
-    return result;
-};
-/**
- * Used by ViewHtml/ViewSource dialogs for making the HTML more readable.
- */
-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$/, '');
-};
-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 };
-/**
- * if options.applyToWord is set, expands the selection to the word where the cursor is and
- * returns modified state and dispatch.
- */
-const expandSelection = (state, dispatch, options) => {
-    if (!options.applyToWord || !state.selection.empty) {
-        return { state, dispatch };
-    }
-    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) {
-        const children = [];
-        selection.$head.parent.descendants((node, pos) => {
-            children.push({ node, pos });
-            return false;
-        });
-        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 -= element.node.nodeSize;
-            }
-        }
-        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;
-            }
-            else {
-                break;
-            }
-        }
-        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) {
-            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));
-            const cmdState = {
-                tr,
-                selection: tr.selection,
-                doc: tr.doc,
-                storedMarks: null,
-                schema: tr.doc.type.schema
-            };
-            const cmdDispatch = tran => {
-                tran.setSelection(TextSelection.create(tran.doc, initialPosition));
-                dispatch(tran);
-            };
-            return { state: cmdState, dispatch: cmdDispatch };
-        }
-    }
-    return { state, dispatch };
-};
-/**
- * if options.applyToWord is set, expands the selection to the word where the cursor is and
- * use the modified state for the passed command.
- * Designed to work with toggleInlineFormat, applyInlineStyle and applyLink functions.
- *
- * Example:
- * const applyToWord: boolean|{before: RegExp, after: RegExp} = true;
- * // or applyToWord = { before: /[^ !,?.\[\]{}()]+$/i, after: /^[^ !,?.\[\]{}()]+/i }};
- *
- * const command = expandToWordWrap(toggleInlineFormat, {...bold, applyToWord );
- * command(view.state, view.dispatch);
- */
-const expandToWordWrap = (command, options) => {
-    return (state, dispatch) => {
-        const { state: cmdState, dispatch: cmdDispatch } = expandSelection(state, dispatch, options);
-        return command(options)(cmdState, cmdDispatch);
-    };
-};
-const parseStyle = (styleText) => {
-    return parseInlineStyles(styleText);
-};
-const applyStyle = (styleText, styleType, styleValue) => {
-    const styles = parseStyle(styleText);
-    styles[styleType] = styleValue;
-    const result = Object.keys(styles)
-        .map(name => styles[name] ? `${name}: ${styles[name]}` : null)
-        .filter(Boolean)
-        .join('; ');
-    return result ? result + ';' : null;
-};
-const setStyleAttr = (element, styleString) => {
-    const styles = parseStyle(styleString);
-    for (const style in styles) {
-        if (style && element.style[style] !== undefined) {
-            element.style[style] = styles[style];
-        }
-    }
-};
-const setAttribute = (node, attrName, value) => {
-    const current = node.getAttribute(attrName);
-    if (value !== undefined && value !== current) {
-        if (attrName === 'style') {
-            node.removeAttribute(attrName);
-            setStyleAttr(node, value);
-        }
-        else {
-            node.setAttribute(attrName, value);
-        }
-    }
-    else if (value === undefined) {
-        node.removeAttribute(attrName);
-    }
-};
-
-export { applyStyle, canInsert, changeStylesString, expandSelection, expandToWordWrap, findNthParentNodeOfType, getNodeFromSelection, getSelectionText, indentHtml, insertNode, parentNode, parseStyle, selectedLineTextOnly, setAttribute, setNodeStyle, setStyleAttr, shallowEqual };