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

package/dist/es/indent.js

@@ -1,34 +1,35 @@
 import { sinkListItem, liftListItem } from 'prosemirror-schema-list';
-import { indentRules, outdentRules } from './config/indent-rules';
-import { blockNodes, addStyles, changeTextBlock, hasNode } from './blockNode';
-import { findNthParentNodeOfType } from './utils';
-import { liftBlockquote } from './blockquote';
+import { indentRules, outdentRules } from './config/indent-rules.js';
+import { blockNodes, addStyles, changeTextBlock, hasNode } 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.
  */
-export var indentBlocks = function (actions, command, dir) { return function (state, dispatch) {
-    var blocks = blockNodes(state);
-    var tr = state.tr;
+const indentBlocks = (actions, command, dir) => (state, dispatch) => {
+    const blocks = blockNodes(state);
+    const tr = state.tr;
     tr.setMeta('commandName', command);
-    blocks.forEach(function (node) {
+    blocks.forEach(node => {
         if (node.type.isTextblock) {
-            var newAttrs = void 0;
-            var action = actions.find(function (a) { return a.node === node.type.name; });
+            let newAttrs;
+            const action = actions.find(a => a.node === node.type.name);
             if (action) {
-                var style = dir === 'rtl' ? action.rtlStyle : action.style;
-                var newStyle = {
+                const style = dir === 'rtl' ? action.rtlStyle : action.style;
+                const newStyle = {
                     name: style,
-                    value: action.step > 0 ? "".concat(action.step).concat(action.unit) : ''
+                    value: action.step > 0 ? `${action.step}${action.unit}` : ''
                 };
                 if (node.attrs.style) {
-                    var re = new RegExp("".concat(style, ":\\s?(\\d+)").concat(action.unit), 'i');
-                    var match = node.attrs.style.match(re);
+                    const re = new RegExp(`${style}:\\s?(\\d+)${action.unit}`, 'i');
+                    const match = node.attrs.style.match(re);
                     if (match) {
-                        var newMargin = parseFloat(match[1]) + action.step;
+                        let newMargin = parseFloat(match[1]) + action.step;
                         newMargin = newMargin <= 0 ? '' : newMargin;
-                        newStyle.value = "".concat(newMargin).concat(newMargin ? action.unit : '');
+                        newStyle.value = `${newMargin}${newMargin ? action.unit : ''}`;
                     }
                 }
                 newAttrs = addStyles(node, [newStyle]);
@@ -38,47 +39,47 @@ export var indentBlocks = function (actions, command, dir) { return function (st
             }
         }
     });
-    var result = tr.docChanged;
+    const result = tr.docChanged;
     if (result) {
         dispatch(tr.scrollIntoView());
     }
     return result;
-}; };
-export var isIndented = function (state, rules, dir) {
-    var blocks = blockNodes(state);
-    var result = false;
-    blocks.forEach(function (node) {
+};
+const isIndented = (state, rules, dir) => {
+    const blocks = blockNodes(state);
+    let result = false;
+    blocks.forEach(node => {
         if (!result && node.type.isTextblock && node.attrs.style) {
-            var action = rules.find(function (a) { return a.node === node.type.name; });
+            const action = rules.find(a => a.node === node.type.name);
             if (action) {
-                var style = dir === 'rtl' ? action.rtlStyle : action.style;
-                var reIndent = new RegExp("".concat(style, ":\\s?\\d+").concat(action.unit), 'i');
+                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;
 };
-export var canIndentAsListItem = function (state, nodeType) {
+const canIndentAsListItem = (state, nodeType) => {
     return sinkListItem(nodeType)(state);
 };
-export var canOutdentAsListItem = function (state, rules) {
-    var listItem = state.schema.nodes[rules.listsTypes.listItem];
-    var orderedList = state.schema.nodes[rules.listsTypes.orderedList];
-    var bulletList = state.schema.nodes[rules.listsTypes.bulletList];
-    var isNestedInOL = !!findNthParentNodeOfType(orderedList, 2)(state.selection);
-    var isNestedInUL = !!findNthParentNodeOfType(bulletList, 2)(state.selection);
+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);
 };
-export var canBeIndented = function (state, rules) {
-    var nodes = state.schema.nodes;
-    var listItem = nodes[indentRules.listsTypes.listItem];
-    return ((isIndented(state, rules.nodes) || indentRules.nodes.some(function (rule) { return nodes[rule.node] && hasNode(state, nodes[rule.node]); })) &&
+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));
 };
-export var indent = function (state, dispatch) {
-    var listItem = state.schema.nodes[indentRules.listsTypes.listItem];
-    var isIndentableBlock = canBeIndented(state, indentRules);
+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);
     }
@@ -86,10 +87,10 @@ export var indent = function (state, dispatch) {
         indentBlocks(indentRules.nodes)(state, dispatch);
     }
 };
-export var outdent = function (state, dispatch) {
-    var nodes = state.schema.nodes;
-    var listItem = nodes[outdentRules.listsTypes.listItem];
-    var isIndentableBlock = canBeIndented(state, outdentRules);
+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);
     }
@@ -100,3 +101,5 @@ export var outdent = function (state, dispatch) {
         indentBlocks(outdentRules.nodes)(state, dispatch);
     }
 };
+
+export { canBeIndented, canIndentAsListItem, canOutdentAsListItem, indent, indentBlocks, isIndented, outdent };

package/dist/es/inline-style.js

@@ -1,32 +1,32 @@
-import { __assign, __spreadArray } from "tslib";
-import { AddMarkStep, RemoveMarkStep } from 'prosemirror-transform';
+import { RemoveMarkStep, AddMarkStep } from 'prosemirror-transform';
 import { TextSelection } from 'prosemirror-state';
-import { changeStylesString, shallowEqual } from './utils';
-import { markApplies, hasMark, removeMarks, toggleMark, styleValue, selectionMarks } from './mark';
-var changeStyleFromMark = function (marks, toChange) {
-    var styleMark = marks.find(function (m) { return m.type.name === 'style'; });
-    var elementStyle = styleMark && styleMark.attrs.style;
+import { changeStylesString, shallowEqual } from './utils.js';
+import { selectionMarks, styleValue, hasMark, removeMarks, toggleMark, markApplies } from './mark.js';
+
+const changeStyleFromMark = (marks, toChange) => {
+    const styleMark = marks.find(m => m.type.name === 'style');
+    const elementStyle = styleMark && styleMark.attrs.style;
     return changeStylesString(elementStyle, toChange);
 };
-var changeStyleMark = function (tr, from, to, attrs, markType) {
-    var mark = markType.create({ style: attrs.style });
-    var removed = [], added = [], removing = null, adding = null;
-    tr.doc.nodesBetween(from, to, function (node, pos, parent) {
+const changeStyleMark = (tr, from, to, attrs, markType) => {
+    const mark = markType.create({ style: attrs.style });
+    let removed = [], added = [], removing = null, adding = null;
+    tr.doc.nodesBetween(from, to, (node, pos, parent) => {
         if (!node.isInline) {
             return;
         }
-        var marks = node.marks;
+        const marks = node.marks;
         if (!mark.isInSet(marks) && parent.type.allowsMarkType(mark.type)) {
-            var start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
-            var newStyle = changeStyleFromMark(marks, attrs);
+            const start = Math.max(pos, from), end = Math.min(pos + node.nodeSize, to);
+            const newStyle = changeStyleFromMark(marks, attrs);
             if (newStyle.changed || attrs.newValue) {
-                var style = newStyle.changed ?
-                    { style: newStyle.style || null } : { style: "".concat([attrs.style], ": ").concat(attrs.newValue, ";") };
-                var currentMark = markType.isInSet(marks) ? marks.find(function (m) { return m.type.name === 'style'; }) : null;
-                var newMarkAttrs_1 = currentMark ? __assign(__assign({}, currentMark.attrs), style) : style;
-                var newStyleMark = markType.create(newMarkAttrs_1);
-                var newSet = newStyleMark.addToSet(marks);
-                for (var i = 0; i < marks.length; i++) {
+                const style = newStyle.changed ?
+                    { style: newStyle.style || null } : { style: `${[attrs.style]}: ${attrs.newValue};` };
+                const currentMark = markType.isInSet(marks) ? marks.find(m => m.type.name === 'style') : null;
+                const newMarkAttrs = currentMark ? { ...currentMark.attrs, ...style } : style;
+                const newStyleMark = markType.create(newMarkAttrs);
+                const newSet = newStyleMark.addToSet(marks);
+                for (let i = 0; i < marks.length; i++) {
                     if (!marks[i].isInSet(newSet)) {
                         if (removing && removing.to === start && removing.mark.eq(marks[i])) {
                             removing.to = end;
@@ -37,59 +37,59 @@ var changeStyleMark = function (tr, from, to, attrs, markType) {
                         }
                     }
                 }
-                var previousAdded = adding && adding.to === start;
-                var sameAdding = previousAdded && newStyleMark.attrs.style === adding.mark.attrs.style;
+                const previousAdded = adding && adding.to === start;
+                const sameAdding = previousAdded && newStyleMark.attrs.style === adding.mark.attrs.style;
                 if (previousAdded && sameAdding) {
                     adding.to = end;
                 }
-                else if (Object.keys(newMarkAttrs_1).some(function (attrName) { return newMarkAttrs_1[attrName] !== null; })) {
+                else if (Object.keys(newMarkAttrs).some(attrName => newMarkAttrs[attrName] !== null)) {
                     adding = new AddMarkStep(start, end, newStyleMark);
                     added.push(adding);
                 }
             }
         }
     });
-    removed.forEach(function (s) { return tr.step(s); });
-    added.forEach(function (s) { return tr.step(s); });
+    removed.forEach(s => tr.step(s));
+    added.forEach(s => tr.step(s));
     return removed.length + added.length > 0;
 };
 /**
  * Used by FontSize and FontName tools for getting their state.
  */
-export var getInlineStyles = function (state, style) {
-    var styleMark = state.schema.marks.style;
-    var marks = styleMark ? selectionMarks(state, styleMark) : [];
-    return marks.map(function (mark) { return styleValue(mark, style); }).filter(function (m) { return m !== null; });
+const getInlineStyles = (state, style) => {
+    const styleMark = state.schema.marks.style;
+    const marks = styleMark ? selectionMarks(state, styleMark) : [];
+    return marks.map(mark => styleValue(mark, style)).filter(m => m !== null);
 };
-var changeStyle = function (markType, attrs) {
+const changeStyle = (markType, attrs) => {
     return function (state, dispatch, tr) {
-        var _a = state.selection, empty = _a.empty, ranges = _a.ranges;
-        var $cursor = state.selection instanceof TextSelection && state.selection.$cursor;
+        const { empty, ranges } = state.selection;
+        const $cursor = state.selection instanceof TextSelection && state.selection.$cursor;
         if ((empty && !$cursor) || !markApplies(state.doc, ranges, markType)) {
             return false;
         }
-        var result = false;
+        let result = false;
         if (dispatch) {
-            var transaction = tr || state.tr;
+            const transaction = tr || state.tr;
             if ($cursor) {
-                var currentMarks = state.storedMarks || $cursor.marks();
+                const currentMarks = state.storedMarks || $cursor.marks();
                 if (markType.isInSet(currentMarks)) {
-                    var newStyle = changeStyleFromMark(currentMarks, attrs);
-                    var styleMark = currentMarks.find(function (m) { return m.type.name === 'style'; });
-                    var newAttrs_1 = __assign(__assign({}, (styleMark ? styleMark.attrs : {})), { style: newStyle.style || null });
-                    if (shallowEqual(styleMark.attrs, newAttrs_1)) {
+                    const newStyle = changeStyleFromMark(currentMarks, attrs);
+                    const styleMark = currentMarks.find(m => m.type.name === 'style');
+                    const newAttrs = { ...(styleMark ? styleMark.attrs : {}), style: newStyle.style || null };
+                    if (shallowEqual(styleMark.attrs, newAttrs)) {
                         return false;
                     }
                     dispatch(transaction.removeStoredMark(markType));
-                    if (Object.keys(newAttrs_1).some(function (attrName) { return newAttrs_1[attrName] !== null; })) {
-                        dispatch(transaction.addStoredMark(markType.create(newAttrs_1)));
+                    if (Object.keys(newAttrs).some(attrName => newAttrs[attrName] !== null)) {
+                        dispatch(transaction.addStoredMark(markType.create(newAttrs)));
                     }
                     result = true;
                 }
             }
             else {
-                for (var i = 0; i < ranges.length; i++) {
-                    var _b = ranges[i], $from = _b.$from, $to = _b.$to;
+                for (let i = 0; i < ranges.length; i++) {
+                    const { $from, $to } = ranges[i];
                     result = changeStyleMark(transaction, $from.pos, $to.pos, attrs, markType) || result;
                 }
                 if (result) {
@@ -104,19 +104,19 @@ var changeStyle = function (markType, attrs) {
 /**
  * Used by bold, italic, ... and link commands.
  */
-export var toggleInlineFormat = function (options, tr, markAttrs) { return function (state, dispatch) {
-    var marks = state.schema.marks;
-    var altStyle = options.altStyle, _a = options.altMarks, altMarks = _a === void 0 ? [] : _a, mark = options.mark;
-    var transaction = tr || state.tr;
-    var styleRemoved = false;
-    var dispatched = false;
-    var markDispatched = function () { return dispatched = true; };
+const toggleInlineFormat = (options, tr, markAttrs) => (state, dispatch) => {
+    const marks = state.schema.marks;
+    const { altStyle, altMarks = [], mark } = options;
+    const transaction = tr || state.tr;
+    let styleRemoved = false;
+    let dispatched = false;
+    const markDispatched = () => dispatched = true;
     if (altStyle && marks.style) {
-        var cmd = changeStyle(marks.style, { style: altStyle.name, value: altStyle.value });
+        const cmd = changeStyle(marks.style, { style: altStyle.name, value: altStyle.value });
         styleRemoved = cmd(state, markDispatched, transaction);
     }
-    var allMarks = __spreadArray([mark], altMarks, true).filter(function (m) { return marks[m]; });
-    var toRemove = allMarks.map(function (m) { return hasMark(state, { mark: m }) && marks[m]; }).filter(function (m) { return m; });
+    const allMarks = [mark, ...altMarks].filter(m => marks[m]);
+    const toRemove = allMarks.map(m => hasMark(state, { mark: m }) && marks[m]).filter(m => m);
     if (toRemove.length) {
         removeMarks(toRemove, state, markDispatched, transaction);
     }
@@ -129,42 +129,42 @@ export var toggleInlineFormat = function (options, tr, markAttrs) { return funct
         dispatch(transaction);
     }
     return dispatched;
-}; };
+};
 /**
  * Used by FontSize, FontName, Color and BackColor commands.
  */
-export var applyInlineStyle = function (options, command) { return function (state, dispatch) {
-    var marks = state.schema.marks;
-    var markType = marks.style;
-    var attrs = {
+const applyInlineStyle = (options, command) => (state, dispatch) => {
+    const marks = state.schema.marks;
+    const markType = marks.style;
+    const attrs = {
         style: options.style, value: /^.+$/, newValue: options.value
     };
-    var tr = state.tr;
+    const tr = state.tr;
     if (command) {
         tr.setMeta('commandName', command);
     }
     tr.setMeta('args', options);
-    var _a = state.selection, empty = _a.empty, $cursor = _a.$cursor, ranges = _a.ranges;
+    const { empty, $cursor, ranges } = state.selection;
     if ((empty && !$cursor) || !markType || !markApplies(state.doc, ranges, markType)) {
         return false;
     }
     // Empty selection
     if ($cursor) {
-        var marksFromSelection = state.storedMarks || $cursor.marks();
-        var currentMark = markType.isInSet(marksFromSelection) ? marksFromSelection.find(function (m) { return m.type.name === 'style'; }) : null;
-        var newStyles = { style: null };
+        const marksFromSelection = state.storedMarks || $cursor.marks();
+        const currentMark = markType.isInSet(marksFromSelection) ? marksFromSelection.find(m => m.type.name === 'style') : null;
+        const newStyles = { style: null };
         if (currentMark && currentMark.attrs.style) {
-            var resultStyles = changeStylesString(currentMark.attrs.style, attrs);
+            const resultStyles = changeStylesString(currentMark.attrs.style, attrs);
             if (resultStyles.changed && resultStyles.style) {
                 newStyles.style = resultStyles.style;
             }
         }
         else if (attrs.newValue) {
-            newStyles.style = "".concat([attrs.style], ": ").concat(attrs.newValue, ";");
+            newStyles.style = `${[attrs.style]}: ${attrs.newValue};`;
         }
-        var newMarkAttrs_2 = currentMark ? __assign(__assign({}, currentMark.attrs), newStyles) : newStyles;
-        if (Object.keys(newMarkAttrs_2).some(function (attrName) { return newMarkAttrs_2[attrName] !== null; })) {
-            dispatch(tr.addStoredMark(markType.create(newMarkAttrs_2)));
+        const newMarkAttrs = currentMark ? { ...currentMark.attrs, ...newStyles } : newStyles;
+        if (Object.keys(newMarkAttrs).some(attrName => newMarkAttrs[attrName] !== null)) {
+            dispatch(tr.addStoredMark(markType.create(newMarkAttrs)));
         }
         else {
             dispatch(tr.removeStoredMark(markType));
@@ -172,4 +172,6 @@ export var applyInlineStyle = function (options, command) { return function (sta
         return true;
     }
     return changeStyle(markType, attrs)(state, dispatch, tr);
-}; };
+};
+
+export { applyInlineStyle, getInlineStyles, toggleInlineFormat };

package/dist/es/link.js

@@ -1,11 +1,12 @@
-import { toggleInlineFormat } from './inline-style';
-import { hasMark, toggleMark, removeMark, selectionMarks } from './mark';
+import { toggleInlineFormat } from './inline-style.js';
+import { removeMark, hasMark, selectionMarks, toggleMark } from './mark.js';
 import { EditorState } from 'prosemirror-state';
-var modifyLink = function (options, tr) { return function (state, dispatch) {
-    var _a = state.selection, $cursor = _a.$cursor, from = _a.from, to = _a.to;
-    var markType = state.schema.marks[options.mark];
+
+const modifyLink = (options, tr) => (state, dispatch) => {
+    const { $cursor, from, to } = state.selection;
+    const markType = state.schema.marks[options.mark];
     if (!$cursor) {
-        tr.doc.nodesBetween(from, to, function (node, pos) {
+        tr.doc.nodesBetween(from, to, (node, pos) => {
             if (node.isInline && markType.isInSet(node.marks)) {
                 tr.removeMark(pos, pos + node.nodeSize, markType);
                 tr.addMark(pos, pos + node.nodeSize, markType.create(options.attrs));
@@ -14,11 +15,11 @@ var modifyLink = function (options, tr) { return function (state, dispatch) {
         });
     }
     else {
-        var parentNode = $cursor.parent;
-        var cursorNodeIndex = $cursor.index();
-        var mark = parentNode.child(cursorNodeIndex).marks.find(function (m) { return m.type === markType; });
-        var childCount = parentNode.childCount;
-        var linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index = void 0, nodeSize = void 0;
+        const parentNode = $cursor.parent;
+        const cursorNodeIndex = $cursor.index();
+        const mark = parentNode.child(cursorNodeIndex).marks.find(m => m.type === markType);
+        const childCount = parentNode.childCount;
+        let linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index, nodeSize;
         index = cursorNodeIndex - 1;
         while (index >= 0 && mark.isInSet(parentNode.child(index).marks)) {
             nodeSize = parentNode.child(index).nodeSize;
@@ -35,19 +36,19 @@ var modifyLink = function (options, tr) { return function (state, dispatch) {
         tr.addMark(linkStart, linkStart + linkSize, markType.create(options.attrs));
         dispatch(tr);
     }
-}; };
-export var removeLink = function (options, tr) { return function (state, dispatch) {
-    var $cursor = state.selection.$cursor;
+};
+const removeLink = (options, tr) => (state, dispatch) => {
+    const { $cursor } = state.selection;
     if (!$cursor) {
         toggleInlineFormat(options, tr)(state, dispatch);
     }
     else {
-        var parentNode = $cursor.parent;
-        var cursorNodeIndex = $cursor.index();
-        var toolMark_1 = state.schema.marks[options.mark];
-        var mark = parentNode.child(cursorNodeIndex).marks.find(function (m) { return m.type === toolMark_1; });
-        var childCount = parentNode.childCount;
-        var linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index = void 0, nodeSize = void 0;
+        const parentNode = $cursor.parent;
+        const cursorNodeIndex = $cursor.index();
+        const toolMark = state.schema.marks[options.mark];
+        const mark = parentNode.child(cursorNodeIndex).marks.find(m => m.type === toolMark);
+        const childCount = parentNode.childCount;
+        let linkStart = $cursor.pos - $cursor.textOffset, linkSize = parentNode.child(cursorNodeIndex).nodeSize, index, nodeSize;
         index = cursorNodeIndex - 1;
         while (index >= 0 && mark.isInSet(parentNode.child(index).marks)) {
             nodeSize = parentNode.child(index).nodeSize;
@@ -62,45 +63,43 @@ export var removeLink = function (options, tr) { return function (state, dispatc
         }
         dispatch(removeMark(tr || state.tr, linkStart, linkStart + linkSize, mark));
     }
-}; };
+};
 /**
  * Returns a mark which wraps the selection.
  */
-var getParentMark = function (state, markType) {
-    var marks = selectionMarks(state, markType);
+const getParentMark = (state, markType) => {
+    const marks = selectionMarks(state, markType);
     return marks.length === 1 && marks[0] ? marks[0] : null;
 };
-export var applyLink = function (_a, commandName) {
-    var mark = _a.mark, attrs = _a.attrs;
-    if (commandName === void 0) { commandName = 'link'; }
-    return function (state, dispatch) {
-        var marks = state.schema.marks;
-        var tr = state.tr;
-        if (commandName) {
-            tr.setMeta('commandName', commandName);
-            tr.setMeta('args', attrs);
+const applyLink = ({ mark, attrs }, commandName = 'link') => (state, dispatch) => {
+    const marks = state.schema.marks;
+    const tr = state.tr;
+    if (commandName) {
+        tr.setMeta('commandName', commandName);
+        tr.setMeta('args', attrs);
+    }
+    let dispatched = false;
+    const markDispatched = () => dispatched = true;
+    if (getParentMark(state, marks[mark])) {
+        modifyLink({ mark, attrs }, tr)(state, markDispatched);
+    }
+    else {
+        let nextState = state;
+        if (hasMark(state, { mark })) {
+            removeLink({ mark, attrs }, tr)(state, markDispatched);
+            nextState = EditorState.create({ doc: tr.doc, selection: tr.selection });
         }
-        var dispatched = false;
-        var markDispatched = function () { return dispatched = true; };
-        if (getParentMark(state, marks[mark])) {
-            modifyLink({ mark: mark, attrs: attrs }, tr)(state, markDispatched);
+        if (dispatched) {
+            toggleMark(marks[mark], attrs, tr)(nextState, markDispatched);
         }
         else {
-            var nextState = state;
-            if (hasMark(state, { mark: mark })) {
-                removeLink({ mark: mark, attrs: attrs }, tr)(state, markDispatched);
-                nextState = EditorState.create({ doc: tr.doc, selection: tr.selection });
-            }
-            if (dispatched) {
-                toggleMark(marks[mark], attrs, tr)(nextState, markDispatched);
-            }
-            else {
-                toggleInlineFormat({ mark: mark }, tr, attrs)(nextState, markDispatched);
-            }
-        }
-        if (dispatched) {
-            dispatch(tr);
+            toggleInlineFormat({ mark: mark }, tr, attrs)(nextState, markDispatched);
         }
-        return dispatched;
-    };
+    }
+    if (dispatched) {
+        dispatch(tr);
+    }
+    return dispatched;
 };
+
+export { applyLink, removeLink };