@titaui/pc 1.16.93-beta.3 → 1.16.94

package/lib/components/rich-editor/plugins/block/lists/commond/index.js

@@ -1,6 +1,7 @@
 "use strict";
 
 function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -22,30 +23,55 @@ exports.rootListDepth = void 0;
 exports.toggleBulletList = toggleBulletList;
 exports.toggleList = toggleList;
 exports.toggleOrderedList = toggleOrderedList;
+
 var _prosemirrorModel = require("prosemirror-model");
+
 var _prosemirrorState = require("prosemirror-state");
+
 var baseCommand = _interopRequireWildcard(require("prosemirror-commands"));
+
 var _prosemirrorUtils = require("prosemirror-utils");
+
 var _document = require("../../../../utils/document");
+
 var _commands = require("../../../../utils/commands");
+
 var _mark = require("../../../../utils/mark");
+
 var _transforms = require("../transforms");
+
 var _selection = require("../utils/selection");
+
 var _listBackspace = require("./listBackspace");
+
 var _joinListItemForward = require("./join-list-item-forward");
+
 var _conversions = require("../actions/conversions");
+
 var _wrapAndJoinLists = require("../actions/wrap-and-join-lists");
+
 var _outdentList = require("./outdent-list");
+
 var _indentList = require("./indent-list");
+
 var _replaceContent = require("../utils/replace-content");
+
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
 function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
 function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
 function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
 function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
 function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
 // export type InputMethod = INPUT_METHOD.KEYBOARD | INPUT_METHOD.TOOLBAR;
 
 /**
@@ -59,14 +85,19 @@ function splitListItem(itemType) {
     var $from = ref.$from;
     var $to = ref.$to;
     var node = ref.node;
+
     if (node && node.isBlock || $from.depth < 2 || !$from.sameParent($to)) {
       return false;
     }
+
     var grandParent = $from.node(-1);
+
     if (grandParent.type !== itemType) {
       return false;
     }
     /** --> The following line changed from the original PM implementation to allow list additions with multiple paragraphs */
+
+
     if (grandParent.content.content.length <= 1 && $from.parent.content.size === 0 && !(grandParent.content.size === 0)) {
       // In an empty block. If this is a nested list, the wrapping
       // list item should be split. Otherwise, bail out and let next
@@ -74,98 +105,123 @@ function splitListItem(itemType) {
       if ($from.depth === 2 || $from.node(-3).type !== itemType || $from.index(-2) !== $from.node(-2).childCount - 1) {
         return false;
       }
+
       if (dispatch) {
         var wrap = _prosemirrorModel.Fragment.empty;
-        var keepItem = $from.index(-1) > 0;
-        // Build a fragment containing empty versions of the structure
+        var keepItem = $from.index(-1) > 0; // Build a fragment containing empty versions of the structure
         // from the outer list item to the parent node of the cursor
+
         for (var d = $from.depth - (keepItem ? 1 : 2); d >= $from.depth - 3; d -= 1) {
           wrap = _prosemirrorModel.Fragment.from($from.node(d).copy(wrap));
-        }
-        // Add a second list item with an empty default start node
+        } // Add a second list item with an empty default start node
+
+
         wrap = wrap.append(_prosemirrorModel.Fragment.from(itemType.createAndFill()));
         var tr$1 = state.tr.replace($from.before(keepItem ? undefined : -1), $from.after(-3), new _prosemirrorModel.Slice(wrap, keepItem ? 3 : 2, 2));
         tr$1.setSelection(state.selection.constructor.near(tr$1.doc.resolve($from.pos + (keepItem ? 3 : 2))));
         dispatch(tr$1.scrollIntoView());
       }
+
       return true;
     }
+
     var nextType = $to.pos === $from.end() ? grandParent.contentMatchAt(0).defaultType : undefined;
     var tr = state.tr["delete"]($from.pos, $to.pos);
     var types = nextType && [undefined, {
       type: nextType
     }];
+
     if (dispatch) {
       dispatch(tr.split($from.pos, 2, types).scrollIntoView());
     }
+
     return true;
   };
 }
+
 var deletePreviousEmptyListItem = function deletePreviousEmptyListItem(state, dispatch) {
   var $from = state.selection.$from;
   var listItem = state.schema.nodes.listItem;
   var $cut = (0, _commands.findCutBefore)($from);
+
   if (!$cut || !$cut.nodeBefore || !($cut.nodeBefore.type === listItem)) {
     return false;
   }
+
   var previousListItemEmpty = $cut.nodeBefore.childCount === 1 && $cut.nodeBefore.firstChild.nodeSize <= 2;
+
   if (previousListItemEmpty) {
     var tr = state.tr;
+
     if (dispatch) {
       dispatch(tr["delete"]($cut.pos - $cut.nodeBefore.nodeSize, $from.pos).scrollIntoView());
     }
+
     return true;
   }
+
   return false;
 };
+
 var enterKeyCommand = function enterKeyCommand(state, dispatch) {
   var selection = state.selection;
+
   if (selection.empty) {
     var $from = selection.$from;
     var _state$schema$nodes = state.schema.nodes,
-      listItem = _state$schema$nodes.listItem,
-      codeBlock = _state$schema$nodes.codeBlock;
+        listItem = _state$schema$nodes.listItem,
+        codeBlock = _state$schema$nodes.codeBlock;
     var node = $from.node($from.depth);
     var wrapper = $from.node($from.depth - 1);
+
     if (wrapper && wrapper.type === listItem) {
       /** Check if the wrapper has any visible content */
       var wrapperHasContent = (0, _document.hasVisibleContent)(wrapper);
+
       if ((0, _document.isNodeEmpty)(node) && !wrapperHasContent) {
         return (0, _outdentList.outdentList)()(state, dispatch);
       }
+
       if (!(0, _prosemirrorUtils.hasParentNodeOfType)(codeBlock)(selection)) {
         return splitListItem(listItem)(state, dispatch);
       }
     }
   }
+
   return false;
 };
+
 exports.enterKeyCommand = enterKeyCommand;
+
 var joinToPreviousListItem = function joinToPreviousListItem(state, dispatch) {
   var $from = state.selection.$from;
   var _state$schema$nodes2 = state.schema.nodes,
-    paragraph = _state$schema$nodes2.paragraph,
-    codeBlock = _state$schema$nodes2.codeBlock,
-    bulletList = _state$schema$nodes2.bulletList,
-    orderedList = _state$schema$nodes2.orderedList;
-  // const isGapCursorShown = state.selection instanceof GapCursorSelection;
-  var $cutPos = /* isGapCursorShown ? state.doc.resolve($from.pos + 1) : */$from;
+      paragraph = _state$schema$nodes2.paragraph,
+      codeBlock = _state$schema$nodes2.codeBlock,
+      bulletList = _state$schema$nodes2.bulletList,
+      orderedList = _state$schema$nodes2.orderedList; // const isGapCursorShown = state.selection instanceof GapCursorSelection;
+
+  var $cutPos =
+  /* isGapCursorShown ? state.doc.resolve($from.pos + 1) : */
+  $from;
   var $cut = (0, _commands.findCutBefore)($cutPos);
+
   if (!$cut) {
     return false;
-  }
+  } // see if the containing node is a list
+
 
-  // see if the containing node is a list
   if ($cut.nodeBefore && [bulletList, orderedList].indexOf($cut.nodeBefore.type) > -1) {
     // and the node after this is a paragraph or a codeBlock
     if ($cut.nodeAfter && ($cut.nodeAfter.type === paragraph || $cut.nodeAfter.type === codeBlock)) {
       // find the nearest paragraph that precedes this node
       var $lastNode = $cut.doc.resolve($cut.pos - 1);
+
       while ($lastNode.parent.type !== paragraph) {
         $lastNode = state.doc.resolve($lastNode.pos - 1);
       }
-      var tr = state.tr;
-      // if (isGapCursorShown) {
+
+      var tr = state.tr; // if (isGapCursorShown) {
       //   const nodeBeforePos = findPositionOfNodeBefore(tr.selection);
       //   if (typeof nodeBeforePos !== 'number') {
       //     return false;
@@ -182,71 +238,80 @@ var joinToPreviousListItem = function joinToPreviousListItem(state, dispatch) {
       //     list,
       //   );
       // } else {
+
       var step = (0, _replaceContent.moveTargetIntoList)({
         insertPosition: $lastNode.pos,
         $target: $cut
-      });
-
-      // ED-13966: check if the step will cause an ProseMirror error
+      }); // ED-13966: check if the step will cause an ProseMirror error
       // if there's an error don't apply the step as it will might lead into a data loss.
       // It doesn't play well with media being a leaf node.
+
       var stepResult = state.tr.maybeStep(step);
+
       if (stepResult.failed) {
         return false;
       }
-      tr = state.tr.step(step);
-
-      // }
 
+      tr = state.tr.step(step); // }
       // find out if there's now another list following and join them
       // as in, [list, p, list] => [list with p, list], and we want [joined list]
+
       var $postCut = tr.doc.resolve(tr.mapping.map($cut.pos + $cut.nodeAfter.nodeSize));
+
       if ($postCut.nodeBefore && $postCut.nodeAfter && $postCut.nodeBefore.type === $postCut.nodeAfter.type && [bulletList, orderedList].indexOf($postCut.nodeBefore.type) > -1) {
         tr = tr.join($postCut.pos);
       }
+
       if (dispatch) {
         dispatch(tr.scrollIntoView());
       }
+
       return true;
     }
   }
+
   return false;
 };
+
 var backspaceKeyCommand = function backspaceKeyCommand(state, dispatch) {
-  return baseCommand.chainCommands(_listBackspace.listBackspace,
-  // if we're at the start of a list item, we need to either backspace
+  return baseCommand.chainCommands(_listBackspace.listBackspace, // if we're at the start of a list item, we need to either backspace
   // directly to an empty list item above, or outdent this node
-  (0, _commands.filter)([_commands.isEmptySelectionAtStart,
-  // list items might have multiple paragraphs; only do this at the first one
-  _commands.isFirstChildOfParent, _selection.isInsideListItem], baseCommand.chainCommands(deletePreviousEmptyListItem, (0, _outdentList.outdentList)())),
-  // if we're just inside a paragraph node (or gapcursor is shown) and backspace, then try to join
+  (0, _commands.filter)([_commands.isEmptySelectionAtStart, // list items might have multiple paragraphs; only do this at the first one
+  _commands.isFirstChildOfParent, _selection.isInsideListItem], baseCommand.chainCommands(deletePreviousEmptyListItem, (0, _outdentList.outdentList)())), // if we're just inside a paragraph node (or gapcursor is shown) and backspace, then try to join
   // the text to the previous list item, if one exists
   (0, _commands.filter)([function (state) {
     return state.selection.empty;
   }, _selection.canJoinToPreviousListItem], joinToPreviousListItem))(state, dispatch);
 };
+
 exports.backspaceKeyCommand = backspaceKeyCommand;
-var deleteKeyCommand = _joinListItemForward.joinListItemForward;
+var deleteKeyCommand = _joinListItemForward.joinListItemForward; // Get the depth of the nearest ancestor list
 
-// Get the depth of the nearest ancestor list
 exports.deleteKeyCommand = deleteKeyCommand;
+
 var rootListDepth = function rootListDepth(pos, nodes) {
   var bulletList = nodes.bulletList,
-    orderedList = nodes.orderedList,
-    listItem = nodes.listItem;
+      orderedList = nodes.orderedList,
+      listItem = nodes.listItem;
   var depth;
+
   for (var i = pos.depth - 1; i > 0; i -= 1) {
     var node = pos.node(i);
+
     if (node.type === bulletList || node.type === orderedList) {
       depth = i;
     }
+
     if (node.type !== bulletList && node.type !== orderedList && node.type !== listItem) {
       break;
     }
   }
+
   return depth;
 };
+
 exports.rootListDepth = rootListDepth;
+
 function untoggleSelectedList(tr) {
   var selection = tr.selection;
   var depth = rootListDepth(selection.$to, tr.doc.type.schema.nodes);
@@ -254,23 +319,29 @@ function untoggleSelectedList(tr) {
   newtr = (0, _transforms.liftSelectionList)(selection, tr);
   return newtr;
 }
+
 function toggleList(listType) {
   return function (state, dispatch) {
     var tr = state.tr;
     var listInsideSelection = (0, _selection.selectionContainsList)(tr);
     var listNodeType = state.schema.nodes[listType];
+
     if (listInsideSelection) {
       var selection = state.selection;
       var fromNode = selection.$from.node(selection.$from.depth - 2);
       var toNode = selection.$to.node(selection.$to.depth - 2);
+
       if ((fromNode === null || fromNode === void 0 ? void 0 : fromNode.type.name) === listType && (toNode === null || toNode === void 0 ? void 0 : toNode.type.name) === listType) {
         var _tr = state.tr;
         _tr = untoggleSelectedList(_tr);
+
         if (dispatch) {
           dispatch(_tr);
         }
+
         return true;
       }
+
       (0, _conversions.convertListType)({
         tr: tr,
         nextListNodeType: listNodeType
@@ -280,38 +351,46 @@ function toggleList(listType) {
       // For example, if trying to convert centre or right aligned paragraphs to lists
       (0, _mark.sanitiseMarksInSelection)(tr, listNodeType);
       (0, _wrapAndJoinLists.wrapInListAndJoin)(listNodeType, tr);
-    }
-
-    // If document wasn't changed, return false from the command to indicate that the
+    } // If document wasn't changed, return false from the command to indicate that the
     // editing action failed
+
+
     if (!tr.docChanged) {
       return false;
     }
+
     if (dispatch) {
       dispatch(tr);
     }
+
     return true;
   };
 }
+
 function toggleBulletList(view) {
   return toggleList("bulletList")(view.state, view.dispatch);
 }
+
 function toggleOrderedList(view) {
   return toggleList("orderedList")(view.state, view.dispatch);
 }
+
 var insertContentDeleteRange = function insertContentDeleteRange(tr, getSelectionResolvedPos, insertions, deletions) {
   insertions.forEach(function (contentInsert) {
     var _contentInsert = _slicedToArray(contentInsert, 2),
-      content = _contentInsert[0],
-      pos = _contentInsert[1];
+        content = _contentInsert[0],
+        pos = _contentInsert[1];
+
     tr.insert(tr.mapping.map(pos), content);
   });
   deletions.forEach(function (deleteRange) {
     var _deleteRange = _slicedToArray(deleteRange, 2),
-      firstPos = _deleteRange[0],
-      lastPos = _deleteRange[1];
+        firstPos = _deleteRange[0],
+        lastPos = _deleteRange[1];
+
     tr["delete"](tr.mapping.map(firstPos), tr.mapping.map(lastPos));
   });
   tr.setSelection(new _prosemirrorState.TextSelection(getSelectionResolvedPos(tr)));
 };
+
 exports.insertContentDeleteRange = insertContentDeleteRange;

package/lib/components/rich-editor/plugins/block/lists/commond/join-list-item-forward.js

@@ -4,31 +4,42 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.joinListItemForward = void 0;
+
 var _commands = require("../../../../utils/commands");
+
 var _joinListItemsForward = require("../actions/join-list-items-forward");
+
 var joinListItemForward = function joinListItemForward(state, dispatch) {
   var tr = state.tr,
-    $head = state.selection.$head;
+      $head = state.selection.$head;
   var walkNode = (0, _commands.walkNextNode)($head);
+
   if (!(0, _commands.isEmptySelectionAtEnd)(state)) {
     return false;
   }
+
   var scenarios = (0, _joinListItemsForward.calcJoinListScenario)(walkNode, $head);
+
   if (!scenarios) {
     return false;
   }
+
   var action = scenarios;
   var result = action({
     tr: tr,
     $next: walkNode.$pos,
     $head: $head
   });
+
   if (!result) {
     return false;
   }
+
   if (dispatch) {
     dispatch(tr);
   }
+
   return true;
 };
+
 exports.joinListItemForward = joinListItemForward;

package/lib/components/rich-editor/plugins/block/lists/commond/listBackspace.js

@@ -4,13 +4,18 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.listBackspace = exports.calcJoinListScenario = void 0;
+
 var _commands = require("../../../../utils/commands");
+
 var _node = require("../utils/node");
+
 var _selection = require("../utils/selection");
+
 var _BACKSPACE_COMMANDS;
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-//Cases below refer to the cases found in this document: https://product-fabric.atlassian.net/wiki/spaces/E/pages/1146954996/List+Backspace+and+Delete+Behaviour
 
+//Cases below refer to the cases found in this document: https://product-fabric.atlassian.net/wiki/spaces/E/pages/1146954996/List+Backspace+and+Delete+Behaviour
 //Case for two adjacent list items of the same indentation
 var listBackspaceCase2 = function listBackspaceCase2(tr, dispatch, $prev, $head) {
   /* CASE 2
@@ -38,27 +43,31 @@ var listBackspaceCase2 = function listBackspaceCase2(tr, dispatch, $prev, $head)
    * }
    *
    */
-
   var listItemE = $head.node(-1); //Head is inside listItem E so it must have a first and last child
+
   if (!listItemE.firstChild) {
     return false;
   }
+
   var beforeListItemE = $head.before(-1);
   var afterListItemE = $head.after(-1);
   var textInsertPos = $prev.pos - 1; //Paragraph D must be directly behind $prev otherwise it would be case 4
+
   var childrenGInsertPos = $prev.pos;
   var textContent = $head.parent.content;
   var childrenGContent = listItemE.content.cut(listItemE.firstChild.nodeSize);
   (0, _commands.insertContentDeleteRange)(tr, function (tr) {
     return tr.doc.resolve(textInsertPos);
   }, [[textContent, textInsertPos], [childrenGContent, childrenGInsertPos]], [[beforeListItemE, afterListItemE]]);
+
   if (dispatch) {
     dispatch(tr);
   }
+
   return true;
-};
+}; //Case for two adjacent list items with the first being of lower indentation
+
 
-//Case for two adjacent list items with the first being of lower indentation
 var listBackspaceCase3 = function listBackspaceCase3(tr, dispatch, $prev, $head) {
   /* CASE 3
    * Initial Structure:
@@ -95,12 +104,13 @@ var listBackspaceCase3 = function listBackspaceCase3(tr, dispatch, $prev, $head)
    * }
    *
    */
-
   var listE = $head.node(-2);
   var listItemF = $head.node(-1); //Head is inside listItem F so it must have a first and last child
+
   if (!listItemF.firstChild || !listItemF.lastChild) {
     return false;
   }
+
   var beforeListE = $head.before(-2);
   var beforeListItemF = $head.before(-1);
   var afterParagraphD = $prev.after();
@@ -109,23 +119,27 @@ var listBackspaceCase3 = function listBackspaceCase3(tr, dispatch, $prev, $head)
   var startListE = $head.start(-2);
   var containsChildrenJ = (0, _node.isListNode)(listItemF.lastChild);
   var shouldRemoveListE = listE.childCount === 1 && !containsChildrenJ; //Assures no Children J and K
+
   var textInsertPos = $prev.pos;
   var childrenHInsertPos = afterParagraphD;
   var childrenJInsertPos = startListE;
   var textContent = $head.parent.content;
   var childrenHContent = containsChildrenJ ? listItemF.content.cut(listItemF.firstChild.nodeSize, listItemF.nodeSize - listItemF.lastChild.nodeSize - 2) : listItemF.content.cut(listItemF.firstChild.nodeSize); //If Children J doesn't exist then Children H will include the last node
+
   var childrenJContent = listItemF.lastChild.content; //Will be invalid if there are no Children J but it will be unused
 
   (0, _commands.insertContentDeleteRange)(tr, function (tr) {
     return tr.doc.resolve(textInsertPos);
   }, containsChildrenJ ? [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos], [childrenJContent, childrenJInsertPos]] : [[textContent, textInsertPos], [childrenHContent, childrenHInsertPos]], [shouldRemoveListE ? [beforeListE, afterListE] : [beforeListItemF, afterListItemF]]);
+
   if (dispatch) {
     dispatch(tr);
   }
+
   return true;
-};
+}; //Case for two adjacent list items with the first being of greater indentation
+
 
-//Case for two adjacent list items with the first being of greater indentation
 var listBackspaceCase4 = function listBackspaceCase4(tr, dispatch, $prev, $head, $last) {
   /* CASE 4
    * Initial Structure:
@@ -178,15 +192,17 @@ var listBackspaceCase4 = function listBackspaceCase4(tr, dispatch, $prev, $head,
    * }
    *
    */
-
   if (!$last) {
     //Exit if an invalid last was given as a parameter
     return false;
   }
+
   var listItemK = $head.node(-1); //Head is inside listItem K so it must have a first and last child
+
   if (!listItemK.firstChild || !listItemK.lastChild) {
     return false;
   }
+
   var paragraphL = $head.parent;
   var beforeListItemK = $head.before(-1);
   var afterParagraphJ = $last.after();
@@ -202,67 +218,85 @@ var listBackspaceCase4 = function listBackspaceCase4(tr, dispatch, $prev, $head,
   (0, _commands.insertContentDeleteRange)(tr, function (tr) {
     return tr.doc.resolve(textInsertPos);
   }, containsChildrenO ? [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos], [childrenOContent, childrenOInsertPos]] : [[textContent, textInsertPos], [childrenMContent, childrenMInsertPos]], [[beforeListItemK, afterListItemK]]);
+
   if (dispatch) {
     dispatch(tr);
   }
+
   return true;
 };
+
 var ScenariosAllowed;
+
 (function (ScenariosAllowed) {
   ScenariosAllowed[ScenariosAllowed["JOIN_SIBLINGS"] = 0] = "JOIN_SIBLINGS";
   ScenariosAllowed[ScenariosAllowed["JOIN_DESCENDANT_TO_PARENT"] = 1] = "JOIN_DESCENDANT_TO_PARENT";
   ScenariosAllowed[ScenariosAllowed["JOIN_TO_SIBLING_DESCENDANT"] = 2] = "JOIN_TO_SIBLING_DESCENDANT";
 })(ScenariosAllowed || (ScenariosAllowed = {}));
+
 var BACKSPACE_COMMANDS = (_BACKSPACE_COMMANDS = {}, _defineProperty(_BACKSPACE_COMMANDS, ScenariosAllowed.JOIN_SIBLINGS, listBackspaceCase2), _defineProperty(_BACKSPACE_COMMANDS, ScenariosAllowed.JOIN_DESCENDANT_TO_PARENT, listBackspaceCase3), _defineProperty(_BACKSPACE_COMMANDS, ScenariosAllowed.JOIN_TO_SIBLING_DESCENDANT, listBackspaceCase4), _BACKSPACE_COMMANDS);
+
 var calcJoinListScenario = function calcJoinListScenario(walkNode, $head, tr) {
   var $prev = walkNode.$pos,
-    prevFoundNode = walkNode.foundNode;
+      prevFoundNode = walkNode.foundNode;
   var prevInList = (0, _selection.isPosInsideList)($prev);
   var headInParagraph = (0, _selection.isPosInsideParagraph)($head);
   var headInFirstChild = $head.index(-1) === 0;
-  var headInList = (0, _selection.isPosInsideList)($head);
-
-  //Must be at the start of the selection of the first child in the listItem
+  var headInList = (0, _selection.isPosInsideList)($head); //Must be at the start of the selection of the first child in the listItem
 
   if (!prevFoundNode || !prevInList || !headInParagraph || !headInFirstChild || !headInList) {
     return false;
   }
+
   var prevInParagraph = (0, _selection.isPosInsideParagraph)($prev);
+
   if (prevInParagraph) {
     return [ScenariosAllowed.JOIN_DESCENDANT_TO_PARENT, null];
   }
-  var prevParentLastChildIsList = $prev.parent.lastChild && (0, _node.isListNode)($prev.parent.lastChild);
-  var prevParentLastChildIsParagraph = (0, _node.isParagraphNode)($prev.parent.lastChild);
 
-  // Will search for the possible last node for case 4 (where the list could be indented multiple times)
+  var prevParentLastChildIsList = $prev.parent.lastChild && (0, _node.isListNode)($prev.parent.lastChild);
+  var prevParentLastChildIsParagraph = (0, _node.isParagraphNode)($prev.parent.lastChild); // Will search for the possible last node for case 4 (where the list could be indented multiple times)
   // $last is required to determine whether we are in case 2 or 4
+
   var $last = tr.doc.resolve($prev.pos);
   var lastFoundNode;
+
   do {
     var _walkNode = (0, _commands.walkPrevNode)($last);
+
     $last = _walkNode.$pos;
     lastFoundNode = _walkNode.foundNode;
   } while (lastFoundNode && !$last.parent.isTextblock);
+
   var lastInParagraph = (0, _selection.isPosInsideParagraph)($last);
+
   if (lastFoundNode && prevParentLastChildIsList && lastInParagraph) {
     return [ScenariosAllowed.JOIN_TO_SIBLING_DESCENDANT, $last];
   } else if (prevParentLastChildIsParagraph) {
     return [ScenariosAllowed.JOIN_SIBLINGS, null];
   }
+
   return false;
 };
+
 exports.calcJoinListScenario = calcJoinListScenario;
+
 var listBackspace = function listBackspace(state, dispatch) {
   var tr = state.tr,
-    $head = state.selection.$head;
+      $head = state.selection.$head;
   var walkNode = (0, _commands.walkPrevNode)($head);
+
   if (!(0, _commands.isEmptySelectionAtStart)(state)) {
     return false;
   }
+
   var scenario = calcJoinListScenario(walkNode, $head, tr);
+
   if (!scenario) {
     return false;
   }
+
   return BACKSPACE_COMMANDS[scenario[0]](tr, dispatch, walkNode.$pos, $head, scenario[1]);
 };
+
 exports.listBackspace = listBackspace;