@atlaskit/editor-core 178.1.0 → 178.1.2

package/dist/esm/utils/input-rules.js

@@ -1,9 +1,6 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
-
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-
 import { TextSelection } from 'prosemirror-state';
 import { canJoin, findWrapping } from 'prosemirror-transform';
 import { GapCursorSelection } from '@atlaskit/editor-common/selection';
@@ -17,12 +14,10 @@ export var ruleWithAnalytics = function ruleWithAnalytics(getPayload) {
     var onHandlerApply = function onHandlerApply(state, tr, matchResult) {
       var payload = typeof getPayload === 'function' ? getPayload(state, matchResult) : getPayload;
       addAnalytics(state, tr, payload);
-
       if (originalRule.onHandlerApply) {
         originalRule.onHandlerApply(state, tr, matchResult);
       }
     };
-
     return _objectSpread(_objectSpread({}, originalRule), {}, {
       onHandlerApply: onHandlerApply
     });
@@ -32,12 +27,10 @@ export var ruleWithTransform = function ruleWithTransform(transform) {
   return function (originalRule) {
     var onHandlerApply = function onHandlerApply(state, tr, matchResult) {
       transform(state, tr);
-
       if (originalRule.onHandlerApply) {
         originalRule.onHandlerApply(state, tr, matchResult);
       }
     };
-
     return _objectSpread(_objectSpread({}, originalRule), {}, {
       onHandlerApply: onHandlerApply
     });
@@ -55,24 +48,20 @@ export var createRule = function createRule(match, handler) {
 export var createPlugin = function createPlugin(pluginName, rules) {
   var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   var _options$isBlockNodeR = options.isBlockNodeRule,
-      isBlockNodeRule = _options$isBlockNodeR === void 0 ? false : _options$isBlockNodeR,
-      _options$allowInsertT = options.allowInsertTextOnDocument,
-      allowInsertTextOnDocument = _options$allowInsertT === void 0 ? true : _options$allowInsertT;
-
+    isBlockNodeRule = _options$isBlockNodeR === void 0 ? false : _options$isBlockNodeR,
+    _options$allowInsertT = options.allowInsertTextOnDocument,
+    allowInsertTextOnDocument = _options$allowInsertT === void 0 ? true : _options$allowInsertT;
   var onInputEvent = function onInputEvent(_ref) {
     var state = _ref.state,
-        from = _ref.from,
-        to = _ref.to;
+      from = _ref.from,
+      to = _ref.to;
     var unsupportedMarks = isBlockNodeRule ? ['code', 'link', 'typeAheadQuery'] : ['code'];
     var $from = state.selection.$from;
-
     if ($from.parent.type.spec.code || !(state.selection instanceof TextSelection) && !(state.selection instanceof GapCursorSelection) || hasUnsupportedMarks(state, from, to, unsupportedMarks) || isBlockNodeRule && isCursorInsideUnsupportedMarks(state, unsupportedMarks)) {
       return false;
     }
-
     return true;
   };
-
   return createInputRulePlugin(pluginName, rules, {
     allowInsertTextOnDocument: allowInsertTextOnDocument,
     onInputEvent: onInputEvent,
@@ -83,30 +72,25 @@ export var createPlugin = function createPlugin(pluginName, rules) {
 };
 export var createWrappingTextBlockRule = function createWrappingTextBlockRule(_ref2) {
   var match = _ref2.match,
-      nodeType = _ref2.nodeType,
-      getAttrs = _ref2.getAttrs;
-
+    nodeType = _ref2.nodeType,
+    getAttrs = _ref2.getAttrs;
   var handler = function handler(state, match, start, end) {
     var fixedStart = Math.max(start, 1);
     var $start = state.doc.resolve(fixedStart);
     var attrs = getAttrs instanceof Function ? getAttrs(match) : getAttrs;
     var nodeBefore = $start.node(-1);
-
     if (nodeBefore && !nodeBefore.canReplaceWith($start.index(-1), $start.indexAfter(-1), nodeType)) {
       return null;
     }
-
     return state.tr.delete(fixedStart, end).setBlockType(fixedStart, fixedStart, nodeType, attrs);
   };
-
   return createRule(match, handler);
 };
 export var createWrappingJoinRule = function createWrappingJoinRule(_ref3) {
   var match = _ref3.match,
-      nodeType = _ref3.nodeType,
-      getAttrs = _ref3.getAttrs,
-      joinPredicate = _ref3.joinPredicate;
-
+    nodeType = _ref3.nodeType,
+    getAttrs = _ref3.getAttrs,
+    joinPredicate = _ref3.joinPredicate;
   var handler = function handler(state, match, start, end) {
     var attrs = (getAttrs instanceof Function ? getAttrs(match) : getAttrs) || {};
     var tr = state.tr;
@@ -115,50 +99,38 @@ export var createWrappingJoinRule = function createWrappingJoinRule(_ref3) {
     var $start = tr.doc.resolve(fixedStart);
     var range = $start.blockRange();
     var wrapping = range && findWrapping(range, nodeType, attrs);
-
     if (!wrapping || !range) {
       return null;
     }
-
     var parentNodePosMapped = tr.mapping.map(range.start);
     var parentNode = tr.doc.nodeAt(parentNodePosMapped);
     var lastWrap = wrapping[wrapping.length - 1];
-
     if (parentNode && lastWrap) {
       var allowedMarks = lastWrap.type.allowedMarks(parentNode.marks) || [];
       tr.setNodeMarkup(parentNodePosMapped, parentNode.type, parentNode.attrs, allowedMarks);
     }
-
     tr.wrap(range, wrapping);
     var featureFlags = getFeatureFlags(state);
-
     if (featureFlags !== null && featureFlags !== void 0 && featureFlags.restartNumberedLists && nodeType === state.schema.nodes.orderedList) {
       // if an orderedList node would be inserted by the input rule match, and
       // that orderedList node is being added directly before another orderedList
       // node, then join those nodes
       var $end = tr.doc.resolve(tr.mapping.map(end));
-
       var _node = findParentNodeOfTypeClosestToPos($end, nodeType);
-
       if (_node) {
         var nodeEnd = _node.pos + _node.node.nodeSize;
         var after = tr.doc.resolve(nodeEnd).nodeAfter;
-
         if (after && after.type === nodeType && canJoin(tr.doc, nodeEnd) && (!joinPredicate || joinPredicate(match, after))) {
           tr.join(nodeEnd);
         }
       }
     }
-
     var before = tr.doc.resolve(fixedStart - 1).nodeBefore;
-
     if (before && before.type === nodeType && canJoin(tr.doc, fixedStart - 1) && (!joinPredicate || joinPredicate(match, before))) {
       tr.join(fixedStart - 1);
     }
-
     return tr;
   };
-
   return createRule(match, handler);
 };
 export var createJoinNodesRule = function createJoinNodesRule(match, nodeType) {
@@ -171,32 +143,24 @@ export var createJoinNodesRule = function createJoinNodesRule(match, nodeType) {
     }
   });
 };
-
 var hasUnsupportedMarks = function hasUnsupportedMarks(state, start, end, marksNameUnsupported) {
   var isUnsupportedMark = function isUnsupportedMark(node) {
     return (marksNameUnsupported || []).includes(node.type.name);
   };
-
   var $from = state.doc.resolve(start);
   var $to = state.doc.resolve(end);
   var marksInSelection = start === end ? $from.marks() : $from.marksAcross($to);
   return (marksInSelection || []).some(isUnsupportedMark);
 };
-
 var isCursorInsideUnsupportedMarks = function isCursorInsideUnsupportedMarks(state, marksNameUnsupported) {
   var _$cursor$nodeBefore, _$cursor$nodeBefore$m;
-
   var selection = state.selection;
-
   if (!(selection instanceof TextSelection)) {
     return false;
   }
-
   var $cursor = selection.$cursor;
-
   var isUnsupportedMark = function isUnsupportedMark(node) {
     return marksNameUnsupported.includes(node.type.name);
   };
-
   return Boolean($cursor === null || $cursor === void 0 ? void 0 : (_$cursor$nodeBefore = $cursor.nodeBefore) === null || _$cursor$nodeBefore === void 0 ? void 0 : (_$cursor$nodeBefore$m = _$cursor$nodeBefore.marks) === null || _$cursor$nodeBefore$m === void 0 ? void 0 : _$cursor$nodeBefore$m.some(isUnsupportedMark));
 };

package/dist/esm/utils/insert.js

@@ -6,25 +6,20 @@ import { isEmptyParagraph } from './document';
 import { GapCursorSelection, Side } from '../plugins/selection/gap-cursor-selection';
 import { normaliseNestedLayout } from './selection';
 export var LookDirection;
-
 (function (LookDirection) {
   LookDirection["Before"] = "before";
   LookDirection["After"] = "after";
 })(LookDirection || (LookDirection = {}));
-
 var isLastChild = function isLastChild($pos, doc) {
   return doc.resolve($pos.after()).node().lastChild === $pos.node();
 };
-
 var isFirstChild = function isFirstChild($pos, doc) {
   return doc.resolve($pos.before()).node().firstChild === $pos.node();
 };
-
 var nodeIsInsideAList = function nodeIsInsideAList(tr) {
   var nodes = tr.doc.type.schema.nodes;
   return hasParentNodeOfType([nodes.orderedList, nodes.bulletList])(tr.selection);
 };
-
 var insertBeforeOrAfter = function insertBeforeOrAfter(tr, lookDirection, $parentPos, $proposedPosition, content) {
   /**
    * This block caters for the first item in a parent with the cursor being at the very start
@@ -36,42 +31,41 @@ var insertBeforeOrAfter = function insertBeforeOrAfter(tr, lookDirection, $paren
    *  li
    *  li Scenario two{<>}
    */
+
   if (isFirstChild($proposedPosition, tr.doc) && lookDirection === LookDirection.Before || isLastChild($proposedPosition, tr.doc) && lookDirection === LookDirection.After) {
     return tr.insert($parentPos[lookDirection](), content);
   }
-
   return tr.insert($proposedPosition[lookDirection](), content);
-}; // FIXME: A more sustainable and configurable way to choose when to split
-
+};
 
+// FIXME: A more sustainable and configurable way to choose when to split
 var shouldSplit = function shouldSplit(nodeType, schemaNodes) {
   return [schemaNodes.bulletList, schemaNodes.orderedList, schemaNodes.panel].includes(nodeType);
 };
-
 export var safeInsert = function safeInsert(content, position) {
   return function (tr) {
     var _tr$selection$$from$n;
-
     var nodes = tr.doc.type.schema.nodes;
-    var whitelist = [nodes.rule, nodes.mediaSingle]; // fallback if the node to insert is not in the whitelist, or if the insertion should happen within a list.
+    var whitelist = [nodes.rule, nodes.mediaSingle];
 
+    // fallback if the node to insert is not in the whitelist, or if the insertion should happen within a list.
     if (content instanceof Fragment || !whitelist.includes(content.type) || nodeIsInsideAList(tr)) {
       return null;
-    } // Check for selection
-
+    }
 
+    // Check for selection
     if (!tr.selection.empty || isNodeSelection(tr.selection)) {
       // NOT IMPLEMENTED
       return null;
     }
-
     var $from = tr.selection.$from;
     var $insertPos = position ? tr.doc.resolve(position) : isNodeSelection(tr.selection) ? tr.doc.resolve($from.pos + 1) : $from;
     var lookDirection;
     var insertPosEnd = $insertPos.end();
-    var insertPosStart = $insertPos.start(); // When parent node is an empty paragraph,
-    // check the empty paragraph is the first or last node of its parent.
+    var insertPosStart = $insertPos.start();
 
+    // When parent node is an empty paragraph,
+    // check the empty paragraph is the first or last node of its parent.
     if (isEmptyParagraph($insertPos.parent)) {
       if (isLastChild($insertPos, tr.doc)) {
         lookDirection = LookDirection.After;
@@ -85,10 +79,8 @@ export var safeInsert = function safeInsert(content, position) {
         lookDirection = LookDirection.Before;
       }
     }
-
     var grandParentNodeType = (_tr$selection$$from$n = tr.selection.$from.node(-1)) === null || _tr$selection$$from$n === void 0 ? void 0 : _tr$selection$$from$n.type;
     var parentNodeType = tr.selection.$from.parent.type;
-
     if (!lookDirection && !shouldSplitSelectedNodeOnNodeInsertion({
       parentNodeType: parentNodeType,
       grandParentNodeType: grandParentNodeType,
@@ -97,66 +89,58 @@ export var safeInsert = function safeInsert(content, position) {
       // node to be inserted is an invalid child of selection so insert below selected node
       return pmSafeInsert(content, tr.selection.from)(tr);
     }
-
     if (!lookDirection) {
       // fallback to consumer for now
       return null;
-    } // Replace empty paragraph
-
+    }
 
+    // Replace empty paragraph
     if (isEmptyParagraph($insertPos.parent) && canInsert(tr.doc.resolve($insertPos[lookDirection]()), content)) {
       return finaliseInsert(tr.replaceWith($insertPos.before(), $insertPos.after(), content), -1);
     }
-
     var $proposedPosition = $insertPos;
-
     while ($proposedPosition.depth > 0) {
       var $parentPos = tr.doc.resolve($proposedPosition[lookDirection]());
-      var parentNode = $parentPos.node(); // Insert at position (before or after target pos)
+      var parentNode = $parentPos.node();
 
+      // Insert at position (before or after target pos)
       if (canInsert($proposedPosition, content)) {
         return finaliseInsert(tr.insert($proposedPosition.pos, content), content.nodeSize);
-      } // If we can't insert, and we think we should split, we fallback to consumer for now
-
+      }
 
+      // If we can't insert, and we think we should split, we fallback to consumer for now
       if (shouldSplit(parentNode.type, tr.doc.type.schema.nodes)) {
         return finaliseInsert(insertBeforeOrAfter(tr, lookDirection, $parentPos, $proposedPosition, content), content.nodeSize);
-      } // Can not insert into current parent, step up one parent
-
+      }
 
+      // Can not insert into current parent, step up one parent
       $proposedPosition = $parentPos;
     }
-
     return finaliseInsert(tr.insert($proposedPosition.pos, content), content.nodeSize);
   };
 };
-
 var finaliseInsert = function finaliseInsert(tr, nodeLength) {
   var lastStep = tr.steps[tr.steps.length - 1];
-
   if (!(lastStep instanceof ReplaceStep || lastStep instanceof ReplaceAroundStep)) {
     return null;
-  } // Place gap cursor after the newly inserted node
-
+  }
 
+  // Place gap cursor after the newly inserted node
   var gapCursorPos = lastStep.to + lastStep.slice.openStart + nodeLength;
   return tr.setSelection(new GapCursorSelection(tr.doc.resolve(gapCursorPos), Side.RIGHT)).scrollIntoView();
 };
+
 /**
  * Method extracted from typeahed plugin to be shared with the element browser on handling element insertion.
  */
-
-
 export var insertSelectedItem = function insertSelectedItem(maybeNode) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   return function (state, tr, start) {
     if (!maybeNode) {
       return tr;
     }
-
     var isInputFragment = maybeNode instanceof Fragment;
     var node;
-
     try {
       node = maybeNode instanceof Node || isInputFragment ? maybeNode : typeof maybeNode === 'string' ? state.schema.text(maybeNode) : Node.fromJSON(state.schema, maybeNode);
     } catch (e) {
@@ -164,9 +148,9 @@ export var insertSelectedItem = function insertSelectedItem(maybeNode) {
       console.error(e);
       return tr;
     }
-
     if (node.isText) {
       tr = tr.replaceWith(start, start, node);
+
       /**
        *
        * Replacing a type ahead query mark with a block node.
@@ -174,6 +158,7 @@ export var insertSelectedItem = function insertSelectedItem(maybeNode) {
        */
     } else if (node.isBlock) {
       tr = pmSafeInsert(normaliseNestedLayout(state, node), undefined, true)(tr);
+
       /**
        *
        * Replacing a type ahead query mark with an inline node.
@@ -182,7 +167,6 @@ export var insertSelectedItem = function insertSelectedItem(maybeNode) {
     } else if (node.isInline || isInputFragment) {
       var fragment = isInputFragment ? node : Fragment.fromArray([node, state.schema.text(' ')]);
       tr = tr.replaceWith(start, start, fragment);
-
       if (opts.selectInlineNode) {
         // Select inserted node
         tr = tr.setSelection(NodeSelection.create(tr.doc, start));
@@ -191,24 +175,21 @@ export var insertSelectedItem = function insertSelectedItem(maybeNode) {
         tr = tr.setSelection(Selection.near(tr.doc.resolve(start + fragment.size)));
       }
     }
-
     return tr;
   };
 };
+
 /**
  * ED-14584: Util to check if the destination node is a paragraph & the
  * content being inserted is a valid child of the grandparent node.
  * In this case, the destination node should split
  */
-
 export var shouldSplitSelectedNodeOnNodeInsertion = function shouldSplitSelectedNodeOnNodeInsertion(_ref) {
   var parentNodeType = _ref.parentNodeType,
-      grandParentNodeType = _ref.grandParentNodeType,
-      content = _ref.content;
-
+    grandParentNodeType = _ref.grandParentNodeType,
+    content = _ref.content;
   if (parentNodeType.name === 'doc' || parentNodeType.name === 'paragraph' && grandParentNodeType.validContent(Fragment.from(content))) {
     return true;
   }
-
   return false;
 };

package/dist/esm/utils/is-text-input.js

@@ -2,16 +2,14 @@ import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
 import { ReplaceStep } from 'prosemirror-transform';
 export var isTextInput = function isTextInput(tr) {
   var _tr$steps = _slicedToArray(tr.steps, 1),
-      step = _tr$steps[0];
-
+    step = _tr$steps[0];
   if (!step || !(step instanceof ReplaceStep)) {
     return false;
   }
-
   var _ref = step,
-      content = _ref.slice.content,
-      from = _ref.from,
-      to = _ref.to;
+    content = _ref.slice.content,
+    from = _ref.from,
+    to = _ref.to;
   var char = content.firstChild;
   return from === to && content.childCount === 1 && !!char && !!char.text && char.text.length === 1;
 };

package/dist/esm/utils/keymap.js

@@ -1,6 +1,7 @@
 import { SafePlugin } from '@atlaskit/editor-common/safe-plugin';
 import { keydownHandler } from 'prosemirror-keymap';
 import { base, keyName } from 'w3c-keyname';
+
 /**
  * A workaround for mostly Cyrillic but should have a positive affect
  * on other languages / layouts. Attempts a similar approach to OS X.
@@ -8,15 +9,14 @@ import { base, keyName } from 'w3c-keyname';
  * @see https://github.com/ProseMirror/prosemirror/issues/957
  * @param bindings
  */
-
 export function keymap(bindings) {
   return new SafePlugin({
     props: {
       handleKeyDown: function handleKeyDown(view, event) {
         var name = keyName(event);
         var keyboardEvent = event;
-
-        if (event.ctrlKey && name.length === 1 && // Check the unicode of the character to
+        if (event.ctrlKey && name.length === 1 &&
+        // Check the unicode of the character to
         // assert that its not an ASCII character.
         // These are characters outside Latin's range.
         /[^\u0000-\u007f]/.test(name)) {
@@ -26,7 +26,6 @@ export function keymap(bindings) {
             ctrlKey: true
           });
         }
-
         return keydownHandler(bindings)(view, keyboardEvent);
       }
     }

package/dist/esm/utils/linking-utils.js

@@ -10,31 +10,26 @@ export var buildEditLinkPayload = function buildEditLinkPayload(type) {
     eventType: EVENT_TYPE.UI
   };
 };
-
 var mapLinkTypeToCardAppearance = function mapLinkTypeToCardAppearance(type) {
   switch (type) {
     case ACTION_SUBJECT_ID.CARD_INLINE:
       {
         return 'inline';
       }
-
     case ACTION_SUBJECT_ID.CARD_BLOCK:
       {
         return 'block';
       }
-
     case ACTION_SUBJECT_ID.EMBEDS:
       {
         return 'embed';
       }
-
     default:
       {
         return 'url';
       }
   }
 };
-
 export var buildVisitedLinkPayload = function buildVisitedLinkPayload(type) {
   return type === ACTION_SUBJECT_ID.HYPERLINK ? {
     action: ACTION.VISITED,

package/dist/esm/utils/list-commands.js

@@ -1,5 +1,6 @@
-import { indentList, outdentList, toggleOrderedList, toggleBulletList } from '../plugins/list/commands'; // getListCommands provides commands for manipulating lists in the document.
+import { indentList, outdentList, toggleOrderedList, toggleBulletList } from '../plugins/list/commands';
 
+// getListCommands provides commands for manipulating lists in the document.
 export var getListCommands = function getListCommands() {
   return {
     indentList: indentList,

package/dist/esm/utils/mark.js

@@ -2,31 +2,26 @@ import _typeof from "@babel/runtime/helpers/typeof";
 export var isMarkAllowedInRange = function isMarkAllowedInRange(doc, ranges, type) {
   var _loop = function _loop(i) {
     var _ranges$i = ranges[i],
-        $from = _ranges$i.$from,
-        $to = _ranges$i.$to;
+      $from = _ranges$i.$from,
+      $to = _ranges$i.$to;
     var can = $from.depth === 0 ? doc.type.allowsMarkType(type) : false;
     doc.nodesBetween($from.pos, $to.pos, function (node) {
       if (can) {
         return false;
       }
-
       can = node.inlineContent && node.type.allowsMarkType(type);
       return;
     });
-
     if (can) {
       return {
         v: can
       };
     }
   };
-
   for (var i = 0; i < ranges.length; i++) {
     var _ret = _loop(i);
-
     if (_typeof(_ret) === "object") return _ret.v;
   }
-
   return false;
 };
 export var isMarkExcluded = function isMarkExcluded(type, marks) {
@@ -35,31 +30,26 @@ export var isMarkExcluded = function isMarkExcluded(type, marks) {
       return mark.type !== type && mark.type.excludes(type);
     });
   }
-
   return false;
 };
-
 var not = function not(fn) {
   return function (arg) {
     return !fn(arg);
   };
 };
-
 export var removeBlockMarks = function removeBlockMarks(state, marks) {
   var selection = state.selection,
-      schema = state.schema;
-  var tr = state.tr; // Marks might not exist in Schema
+    schema = state.schema;
+  var tr = state.tr;
 
+  // Marks might not exist in Schema
   var marksToRemove = marks.filter(Boolean);
-
   if (marksToRemove.length === 0) {
     return undefined;
   }
-  /** Saves an extra dispatch */
-
 
+  /** Saves an extra dispatch */
   var blockMarksExists = false;
-
   var hasMark = function hasMark(mark) {
     return marksToRemove.indexOf(mark.type) > -1;
   };
@@ -67,8 +57,6 @@ export var removeBlockMarks = function removeBlockMarks(state, marks) {
    * When you need to toggle the selection
    * when another type which does not allow alignment is applied
    */
-
-
   state.doc.nodesBetween(selection.from, selection.to, function (node, pos) {
     if (node.type === schema.nodes.paragraph && node.marks.some(hasMark)) {
       blockMarksExists = true;
@@ -79,10 +67,10 @@ export var removeBlockMarks = function removeBlockMarks(state, marks) {
   });
   return blockMarksExists ? tr : undefined;
 };
+
 /**
  * Removes marks from nodes in the current selection that are not supported
  */
-
 export var sanitiseSelectionMarksForWrapping = function sanitiseSelectionMarksForWrapping(state, newParentType) {
   var tr = state.tr;
   sanitiseMarksInSelection(tr, newParentType);
@@ -90,20 +78,18 @@ export var sanitiseSelectionMarksForWrapping = function sanitiseSelectionMarksFo
 };
 export var sanitiseMarksInSelection = function sanitiseMarksInSelection(tr, newParentType) {
   var _tr$selection = tr.selection,
-      from = _tr$selection.from,
-      to = _tr$selection.to;
+    from = _tr$selection.from,
+    to = _tr$selection.to;
   var nodesSanitized = [];
   tr.doc.nodesBetween(from, to, function (node, pos, parent) {
     if (node.isText) {
       return false;
-    } // Skip expands and layouts if they are outside selection
+    }
+    // Skip expands and layouts if they are outside selection
     // but continue to iterate over their children.
-
-
     if (['expand', 'layoutSection'].includes(node.type.name) && (pos < from || pos > to)) {
       return true;
     }
-
     node.marks.forEach(function (mark) {
       if (!parent.type.allowsMarkType(mark.type) || newParentType && !newParentType.allowsMarkType(mark.type)) {
         var filteredMarks = node.marks.filter(function (m) {

package/dist/esm/utils/node-width.js

@@ -1,8 +1,8 @@
 export { getParentNodeWidth } from '@atlaskit/editor-common/node-width';
+
 /**
  * Returns the breakout mode of a given node
  */
-
 export var getBreakoutMode = function getBreakoutMode(node, breakout) {
   var breakoutMark = breakout && breakout.isInSet(node.marks);
   return breakoutMark ? breakoutMark.attrs.mode : node.attrs.layout;