@webiny/lexical-nodes 6.0.0-beta.0 → 6.0.0-rc.0

package/utils/formatList.js

@@ -1,103 +1,86 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.$handleIndent = $handleIndent;
-exports.$handleListInsertParagraph = $handleListInsertParagraph;
-exports.$handleOutdent = $handleOutdent;
-exports.indentList = indentList;
-exports.insertList = insertList;
-exports.mergeLists = mergeLists;
-exports.outdentList = outdentList;
-exports.removeList = removeList;
-exports.updateChildrenListItemValue = updateChildrenListItemValue;
-var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _lexical = require("lexical");
-var _ListNode = require("../ListNode");
-var _utils = require("@lexical/utils");
-var _ListItemNode = require("../ListItemNode");
-var _ParagraphNode = require("../ParagraphNode");
-var _listNode = require("./listNode");
-var DEFAULT_LIST_START_NUMBER = 1;
+import { $getSelection, $isElementNode, $isLeafNode, $isParagraphNode, $isRangeSelection, $isRootOrShadowRoot } from "lexical";
+import { $createListNode, $isListNode } from "../ListNode.js";
+import { $getNearestNodeOfType } from "@lexical/utils";
+import { $createListItemNode, $isListItemNode, ListItemNode } from "../ListItemNode.js";
+import { $createParagraphNode } from "../ParagraphNode.js";
+import { $getAllListItems, $getTopListNode, $removeHighestEmptyListParent, findNearestListItemNode, getUniqueListItemNodes, isNestedListNode } from "./listNode.js";
+const DEFAULT_LIST_START_NUMBER = 1;
 function $isSelectingEmptyListItem(anchorNode, nodes) {
-  return (0, _ListItemNode.$isListItemNode)(anchorNode) && (nodes.length === 0 || nodes.length === 1 && anchorNode.is(nodes[0]) && anchorNode.getChildrenSize() === 0);
+  return $isListItemNode(anchorNode) && (nodes.length === 0 || nodes.length === 1 && anchorNode.is(nodes[0]) && anchorNode.getChildrenSize() === 0);
 }
 function $getListItemValue(listItem) {
-  var list = listItem.getParent();
-  var value = 1;
+  const list = listItem.getParent();
+  let value = 1;
   if (list !== null) {
-    if (!(0, _ListNode.$isListNode)(list)) {
+    if (!$isListNode(list)) {
       console.log("$getListItemValue: webiny list node is not parent of webiny list item node");
       return DEFAULT_LIST_START_NUMBER;
     } else {
       value = list.getStart();
     }
   }
-  var siblings = listItem.getPreviousSiblings();
-  for (var i = 0; i < siblings.length; i++) {
-    var sibling = siblings[i];
-    if ((0, _ListItemNode.$isListItemNode)(sibling) && !(0, _ListNode.$isListNode)(sibling.getFirstChild())) {
+  const siblings = listItem.getPreviousSiblings();
+  for (let i = 0; i < siblings.length; i++) {
+    const sibling = siblings[i];
+    if ($isListItemNode(sibling) && !$isListNode(sibling.getFirstChild())) {
       value++;
     }
   }
   return value;
 }
-function insertList(editor, listType, styleId) {
-  editor.update(function () {
-    var selection = (0, _lexical.$getSelection)();
-    if ((0, _lexical.$isRangeSelection)(selection) || (0, _lexical.DEPRECATED_$isGridSelection)(selection)) {
-      var nodes = selection.getNodes();
-      var anchor = selection.anchor;
-      var anchorNode = anchor.getNode();
-      var anchorNodeParent = anchorNode.getParent();
+export function insertList(editor, listType, styleId) {
+  editor.update(() => {
+    const selection = $getSelection();
+    if (selection && $isRangeSelection(selection)) {
+      const nodes = selection.getNodes();
+      const anchor = selection.anchor;
+      const anchorNode = anchor.getNode();
+      const anchorNodeParent = anchorNode.getParent();
       if ($isSelectingEmptyListItem(anchorNode, nodes)) {
-        var list = (0, _ListNode.$createListNode)(listType, styleId);
-        if ((0, _lexical.$isRootOrShadowRoot)(anchorNodeParent)) {
+        const list = $createListNode(listType, styleId);
+        if ($isRootOrShadowRoot(anchorNodeParent)) {
           anchorNode.replace(list);
-          var listItem = (0, _ListItemNode.$createListItemNode)();
-          if ((0, _lexical.$isElementNode)(anchorNode)) {
+          const listItem = $createListItemNode();
+          if ($isElementNode(anchorNode)) {
             listItem.setFormat(anchorNode.getFormatType());
             listItem.setIndent(anchorNode.getIndent());
           }
           list.append(listItem);
-        } else if ((0, _ListItemNode.$isListItemNode)(anchorNode)) {
-          var parent = anchorNode.getParentOrThrow();
+        } else if ($isListItemNode(anchorNode)) {
+          const parent = anchorNode.getParentOrThrow();
           append(list, parent.getChildren());
           parent.replace(list);
         }
         return;
       } else {
-        var handled = new Set();
-        for (var i = 0; i < nodes.length; i++) {
-          var node = nodes[i];
-          if ((0, _lexical.$isElementNode)(node) && node.isEmpty() && !handled.has(node.getKey())) {
+        const handled = new Set();
+        for (let i = 0; i < nodes.length; i++) {
+          const node = nodes[i];
+          if ($isElementNode(node) && node.isEmpty() && !handled.has(node.getKey())) {
             createListOrMerge(node, listType, styleId);
             continue;
           }
-          if ((0, _lexical.$isLeafNode)(node)) {
-            var _parent = node.getParent();
-            while (_parent != null) {
-              var parentKey = _parent.getKey();
-              if ((0, _ListNode.$isListNode)(_parent)) {
+          if ($isLeafNode(node)) {
+            let parent = node.getParent();
+            while (parent != null) {
+              const parentKey = parent.getKey();
+              if ($isListNode(parent)) {
                 if (!handled.has(parentKey)) {
-                  var newListNode = (0, _ListNode.$createListNode)(listType, styleId);
-                  append(newListNode, _parent.getChildren());
-                  _parent.replace(newListNode);
+                  const newListNode = $createListNode(listType, styleId);
+                  append(newListNode, parent.getChildren());
+                  parent.replace(newListNode);
                   updateChildrenListItemValue(newListNode);
                   handled.add(parentKey);
                 }
                 break;
               } else {
-                var nextParent = _parent.getParent();
-                if ((0, _lexical.$isRootOrShadowRoot)(nextParent) && !handled.has(parentKey)) {
+                const nextParent = parent.getParent();
+                if ($isRootOrShadowRoot(nextParent) && !handled.has(parentKey)) {
                   handled.add(parentKey);
-                  createListOrMerge(_parent, listType, styleId);
+                  createListOrMerge(parent, listType, styleId);
                   break;
                 }
-                _parent = nextParent;
+                parent = nextParent;
               }
             }
           }
@@ -110,31 +93,31 @@ function append(node, nodesToAppend) {
   node.splice(node.getChildrenSize(), 0, nodesToAppend);
 }
 function createListOrMerge(node, listType, styleId) {
-  if ((0, _ListNode.$isListNode)(node)) {
+  if ($isListNode(node)) {
     return node;
   }
-  var previousSibling = node.getPreviousSibling();
-  var nextSibling = node.getNextSibling();
-  var listItem = (0, _ListItemNode.$createListItemNode)();
+  const previousSibling = node.getPreviousSibling();
+  const nextSibling = node.getNextSibling();
+  const listItem = $createListItemNode();
   listItem.setFormat(node.getFormatType());
   listItem.setIndent(node.getIndent());
   append(listItem, node.getChildren());
-  if ((0, _ListNode.$isListNode)(previousSibling) && listType === previousSibling.getListType()) {
+  if ($isListNode(previousSibling) && listType === previousSibling.getListType()) {
     previousSibling.append(listItem);
     node.remove();
     // if the same type of list is on both sides, merge them.
 
-    if ((0, _ListNode.$isListNode)(nextSibling) && listType === nextSibling.getListType()) {
+    if ($isListNode(nextSibling) && listType === nextSibling.getListType()) {
       append(previousSibling, nextSibling.getChildren());
       nextSibling.remove();
     }
     return previousSibling;
-  } else if ((0, _ListNode.$isListNode)(nextSibling) && listType === nextSibling.getListType()) {
+  } else if ($isListNode(nextSibling) && listType === nextSibling.getListType()) {
     nextSibling.getFirstChildOrThrow().insertBefore(listItem);
     node.remove();
     return nextSibling;
   } else {
-    var list = (0, _ListNode.$createListNode)(listType, styleId);
+    const list = $createListNode(listType, styleId);
     list.append(listItem);
     node.replace(list);
     updateChildrenListItemValue(list);
@@ -148,94 +131,76 @@ function createListOrMerge(node, listType, styleId) {
  * @param list1 - The first list to be merged.
  * @param list2 - The second list to be merged.
  */
-function mergeLists(list1, list2) {
-  var listItem1 = list1.getLastChild();
-  var listItem2 = list2.getFirstChild();
-  if (listItem1 && listItem2 && (0, _listNode.isNestedListNode)(listItem1) && (0, _listNode.isNestedListNode)(listItem2)) {
+export function mergeLists(list1, list2) {
+  const listItem1 = list1.getLastChild();
+  const listItem2 = list2.getFirstChild();
+  if (listItem1 && listItem2 && isNestedListNode(listItem1) && isNestedListNode(listItem2)) {
     mergeLists(listItem1.getFirstChild(), listItem2.getFirstChild());
     listItem2.remove();
   }
-  var toMerge = list2.getChildren();
+  const toMerge = list2.getChildren();
   if (toMerge.length > 0) {
-    list1.append.apply(list1, (0, _toConsumableArray2.default)(toMerge));
+    list1.append(...toMerge);
     updateChildrenListItemValue(list1);
   }
   list2.remove();
 }
-function removeList(editor) {
-  editor.update(function () {
-    var selection = (0, _lexical.$getSelection)();
-    if ((0, _lexical.$isRangeSelection)(selection)) {
-      var listNodes = new Set();
-      var nodes = selection.getNodes();
-      var anchorNode = selection.anchor.getNode();
+export function removeList(editor) {
+  editor.update(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection)) {
+      const listNodes = new Set();
+      const nodes = selection.getNodes();
+      const anchorNode = selection.anchor.getNode();
       if ($isSelectingEmptyListItem(anchorNode, nodes)) {
-        listNodes.add((0, _listNode.$getTopListNode)(anchorNode));
+        listNodes.add($getTopListNode(anchorNode));
       } else {
-        for (var i = 0; i < nodes.length; i++) {
-          var node = nodes[i];
-          if ((0, _lexical.$isLeafNode)(node)) {
-            var listItemNode = (0, _utils.$getNearestNodeOfType)(node, _ListItemNode.ListItemNode);
+        for (let i = 0; i < nodes.length; i++) {
+          const node = nodes[i];
+          if ($isLeafNode(node)) {
+            const listItemNode = $getNearestNodeOfType(node, ListItemNode);
             if (listItemNode != null) {
-              listNodes.add((0, _listNode.$getTopListNode)(listItemNode));
+              listNodes.add($getTopListNode(listItemNode));
             }
           }
         }
       }
-      var _iterator = (0, _createForOfIteratorHelper2.default)(listNodes),
-        _step;
-      try {
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          var listNode = _step.value;
-          var insertionPoint = listNode;
-          var listItems = (0, _listNode.$getAllListItems)(listNode);
-          var _iterator2 = (0, _createForOfIteratorHelper2.default)(listItems),
-            _step2;
-          try {
-            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-              var _listItemNode = _step2.value;
-              var paragraph = (0, _ParagraphNode.$createParagraphNode)();
-              append(paragraph, _listItemNode.getChildren());
-              insertionPoint.insertAfter(paragraph);
-              insertionPoint = paragraph;
+      for (const listNode of listNodes) {
+        let insertionPoint = listNode;
+        const listItems = $getAllListItems(listNode);
+        for (const listItemNode of listItems) {
+          const paragraph = $createParagraphNode();
+          append(paragraph, listItemNode.getChildren());
+          insertionPoint.insertAfter(paragraph);
+          insertionPoint = paragraph;
 
-              // When the anchor and focus fall on the textNode
-              // we don't have to change the selection because the textNode will be appended to
-              // the newly generated paragraph.
-              // When selection is in empty nested list item, selection is actually on the listItemNode.
-              // When the corresponding listItemNode is deleted and replaced by the newly generated paragraph
-              // we should manually set the selection's focus and anchor to the newly generated paragraph.
-              if (_listItemNode.__key === selection.anchor.key) {
-                selection.anchor.set(paragraph.getKey(), 0, "element");
-              }
-              if (_listItemNode.__key === selection.focus.key) {
-                selection.focus.set(paragraph.getKey(), 0, "element");
-              }
-              _listItemNode.remove();
-            }
-          } catch (err) {
-            _iterator2.e(err);
-          } finally {
-            _iterator2.f();
+          // When the anchor and focus fall on the textNode
+          // we don't have to change the selection because the textNode will be appended to
+          // the newly generated paragraph.
+          // When selection is in empty nested list item, selection is actually on the listItemNode.
+          // When the corresponding listItemNode is deleted and replaced by the newly generated paragraph
+          // we should manually set the selection's focus and anchor to the newly generated paragraph.
+          if (listItemNode.__key === selection.anchor.key) {
+            selection.anchor.set(paragraph.getKey(), 0, "element");
           }
-          listNode.remove();
+          if (listItemNode.__key === selection.focus.key) {
+            selection.focus.set(paragraph.getKey(), 0, "element");
+          }
+          listItemNode.remove();
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
+        listNode.remove();
       }
     }
   });
 }
-function updateChildrenListItemValue(list, children) {
-  var childrenOrExisting = children || list.getChildren();
+export function updateChildrenListItemValue(list, children) {
+  const childrenOrExisting = children || list.getChildren();
   if (childrenOrExisting !== undefined) {
-    for (var i = 0; i < childrenOrExisting.length; i++) {
-      var child = childrenOrExisting[i];
-      if ((0, _ListItemNode.$isListItemNode)(child)) {
-        var prevValue = child.getValue();
-        var nextValue = $getListItemValue(child);
+    for (let i = 0; i < childrenOrExisting.length; i++) {
+      const child = childrenOrExisting[i];
+      if ($isListItemNode(child)) {
+        const prevValue = child.getValue();
+        const nextValue = $getListItemValue(child);
         if (prevValue !== nextValue) {
           child.setValue(nextValue);
         }
@@ -243,55 +208,55 @@ function updateChildrenListItemValue(list, children) {
     }
   }
 }
-function $handleIndent(WebinyListItemNodes) {
+export function $handleIndent(WebinyListItemNodes) {
   // go through each node and decide where to move it.
-  var removed = new Set();
-  WebinyListItemNodes.forEach(function (WebinyListItemNode) {
-    if ((0, _listNode.isNestedListNode)(WebinyListItemNode) || removed.has(WebinyListItemNode.getKey())) {
+  const removed = new Set();
+  WebinyListItemNodes.forEach(WebinyListItemNode => {
+    if (isNestedListNode(WebinyListItemNode) || removed.has(WebinyListItemNode.getKey())) {
       return;
     }
-    var parent = WebinyListItemNode.getParent();
+    const parent = WebinyListItemNode.getParent();
 
     // We can cast both of the below `isNestedListNode` only returns a boolean type instead of a user-defined type guards
-    var nextSibling = WebinyListItemNode.getNextSibling();
-    var previousSibling = WebinyListItemNode.getPreviousSibling();
+    const nextSibling = WebinyListItemNode.getNextSibling();
+    const previousSibling = WebinyListItemNode.getPreviousSibling();
     // if there are nested lists on either side, merge them all together.
 
-    if ((0, _listNode.isNestedListNode)(nextSibling) && (0, _listNode.isNestedListNode)(previousSibling)) {
-      var innerList = previousSibling.getFirstChild();
-      if ((0, _ListNode.$isListNode)(innerList)) {
+    if (isNestedListNode(nextSibling) && isNestedListNode(previousSibling)) {
+      const innerList = previousSibling.getFirstChild();
+      if ($isListNode(innerList)) {
         innerList.append(WebinyListItemNode);
-        var nextInnerList = nextSibling.getFirstChild();
-        if ((0, _ListNode.$isListNode)(nextInnerList)) {
-          var children = nextInnerList.getChildren();
+        const nextInnerList = nextSibling.getFirstChild();
+        if ($isListNode(nextInnerList)) {
+          const children = nextInnerList.getChildren();
           append(innerList, children);
           nextSibling.remove();
           removed.add(nextSibling.getKey());
         }
         updateChildrenListItemValue(innerList);
       }
-    } else if ((0, _listNode.isNestedListNode)(nextSibling)) {
+    } else if (isNestedListNode(nextSibling)) {
       // if the WebinyListItemNode is next to a nested ListNode, merge them
-      var _innerList = nextSibling.getFirstChild();
-      if ((0, _ListNode.$isListNode)(_innerList)) {
-        var firstChild = _innerList.getFirstChild();
+      const innerList = nextSibling.getFirstChild();
+      if ($isListNode(innerList)) {
+        const firstChild = innerList.getFirstChild();
         if (firstChild !== null) {
           firstChild.insertBefore(WebinyListItemNode);
         }
-        updateChildrenListItemValue(_innerList);
+        updateChildrenListItemValue(innerList);
       }
-    } else if ((0, _listNode.isNestedListNode)(previousSibling)) {
-      var _innerList2 = previousSibling.getFirstChild();
-      if ((0, _ListNode.$isListNode)(_innerList2)) {
-        _innerList2.append(WebinyListItemNode);
-        updateChildrenListItemValue(_innerList2);
+    } else if (isNestedListNode(previousSibling)) {
+      const innerList = previousSibling.getFirstChild();
+      if ($isListNode(innerList)) {
+        innerList.append(WebinyListItemNode);
+        updateChildrenListItemValue(innerList);
       }
     } else {
       // otherwise, we need to create a new nested ListNode
 
-      if ((0, _ListNode.$isListNode)(parent)) {
-        var newListItem = (0, _ListItemNode.$createListItemNode)();
-        var newList = (0, _ListNode.$createListNode)(parent.getListType(), parent.getStyleId());
+      if ($isListNode(parent)) {
+        const newListItem = $createListItemNode();
+        const newList = $createListNode(parent.getListType(), parent.getStyleId());
         newListItem.append(newList);
         newList.append(WebinyListItemNode);
         if (previousSibling) {
@@ -303,28 +268,28 @@ function $handleIndent(WebinyListItemNodes) {
         }
       }
     }
-    if ((0, _ListNode.$isListNode)(parent)) {
+    if ($isListNode(parent)) {
       updateChildrenListItemValue(parent);
     }
   });
 }
-function $handleOutdent(WebinyListItemNodes) {
+export function $handleOutdent(WebinyListItemNodes) {
   // go through each node and decide where to move it.
 
-  WebinyListItemNodes.forEach(function (WebinyListItemNode) {
-    if ((0, _listNode.isNestedListNode)(WebinyListItemNode)) {
+  WebinyListItemNodes.forEach(WebinyListItemNode => {
+    if (isNestedListNode(WebinyListItemNode)) {
       return;
     }
-    var parentList = WebinyListItemNode.getParent();
-    var grandparentListItem = parentList ? parentList.getParent() : undefined;
-    var greatGrandparentList = grandparentListItem ? grandparentListItem.getParent() : undefined;
+    const parentList = WebinyListItemNode.getParent();
+    const grandparentListItem = parentList ? parentList.getParent() : undefined;
+    const greatGrandparentList = grandparentListItem ? grandparentListItem.getParent() : undefined;
     // If it doesn't have these ancestors, it's not indented.
 
-    if ((0, _ListNode.$isListNode)(greatGrandparentList) && (0, _ListItemNode.$isListItemNode)(grandparentListItem) && (0, _ListNode.$isListNode)(parentList)) {
+    if ($isListNode(greatGrandparentList) && $isListItemNode(grandparentListItem) && $isListNode(parentList)) {
       // if it's the first child in it's parent list, insert it into the
       // great grandparent list before the grandparent
-      var firstChild = parentList ? parentList.getFirstChild() : undefined;
-      var lastChild = parentList ? parentList.getLastChild() : undefined;
+      const firstChild = parentList ? parentList.getFirstChild() : undefined;
+      const lastChild = parentList ? parentList.getLastChild() : undefined;
       if (WebinyListItemNode.is(firstChild)) {
         grandparentListItem.insertBefore(WebinyListItemNode);
         if (parentList.isEmpty()) {
@@ -339,16 +304,14 @@ function $handleOutdent(WebinyListItemNodes) {
         }
       } else {
         // otherwise, we need to split the siblings into two new nested lists
-        var listType = parentList.getListType();
-        var themeStyleId = parentList.getStyleId();
-        var previousSiblingsListItem = (0, _ListItemNode.$createListItemNode)();
-        var previousSiblingsList = (0, _ListNode.$createListNode)(listType, themeStyleId);
+        const listType = parentList.getListType();
+        const themeStyleId = parentList.getStyleId();
+        const previousSiblingsListItem = $createListItemNode();
+        const previousSiblingsList = $createListNode(listType, themeStyleId);
         previousSiblingsListItem.append(previousSiblingsList);
-        WebinyListItemNode.getPreviousSiblings().forEach(function (sibling) {
-          return previousSiblingsList.append(sibling);
-        });
-        var nextSiblingsListItem = (0, _ListItemNode.$createListItemNode)();
-        var nextSiblingsList = (0, _ListNode.$createListNode)(listType, themeStyleId);
+        WebinyListItemNode.getPreviousSiblings().forEach(sibling => previousSiblingsList.append(sibling));
+        const nextSiblingsListItem = $createListItemNode();
+        const nextSiblingsList = $createListNode(listType, themeStyleId);
         nextSiblingsListItem.append(nextSiblingsList);
         append(nextSiblingsList, WebinyListItemNode.getNextSiblings());
         // put the sibling nested lists on either side of the grandparent list item in the great grandparent.
@@ -363,24 +326,24 @@ function $handleOutdent(WebinyListItemNodes) {
   });
 }
 function maybeIndentOrOutdent(direction) {
-  var selection = (0, _lexical.$getSelection)();
-  if (!(0, _lexical.$isRangeSelection)(selection)) {
+  const selection = $getSelection();
+  if (!$isRangeSelection(selection)) {
     return;
   }
-  var selectedNodes = selection.getNodes();
-  var webinyListItemNodes = [];
+  const selectedNodes = selection.getNodes();
+  let webinyListItemNodes = [];
   if (selectedNodes.length === 0) {
     selectedNodes.push(selection.anchor.getNode());
   }
   if (selectedNodes.length === 1) {
     // Only 1 node selected. Selection may not contain the ListNodeItem so we traverse the tree to
     // find whether this is part of a WebinyListItemNode
-    var nearestWebinyListItemNode = (0, _listNode.findNearestListItemNode)(selectedNodes[0]);
+    const nearestWebinyListItemNode = findNearestListItemNode(selectedNodes[0]);
     if (nearestWebinyListItemNode !== null) {
       webinyListItemNodes = [nearestWebinyListItemNode];
     }
   } else {
-    webinyListItemNodes = (0, _listNode.getUniqueListItemNodes)(selectedNodes);
+    webinyListItemNodes = getUniqueListItemNodes(selectedNodes);
   }
   if (webinyListItemNodes.length > 0) {
     if (direction === "indent") {
@@ -390,59 +353,59 @@ function maybeIndentOrOutdent(direction) {
     }
   }
 }
-function indentList() {
+export function indentList() {
   maybeIndentOrOutdent("indent");
 }
-function outdentList() {
+export function outdentList() {
   maybeIndentOrOutdent("outdent");
 }
-function $handleListInsertParagraph() {
-  var selection = (0, _lexical.$getSelection)();
-  if (!(0, _lexical.$isRangeSelection)(selection) || !selection.isCollapsed()) {
+export function $handleListInsertParagraph() {
+  const selection = $getSelection();
+  if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
     return false;
   }
 
   // Only run this code on empty list items
-  var anchor = selection.anchor.getNode();
-  if (!(0, _ListItemNode.$isListItemNode)(anchor) || anchor.getTextContent() !== "") {
+  const anchor = selection.anchor.getNode();
+  if (!$isListItemNode(anchor) || anchor.getTextContent() !== "") {
     return false;
   }
-  var topListNode = (0, _listNode.$getTopListNode)(anchor);
-  var parent = anchor.getParent();
-  if (!(0, _ListNode.$isListNode)(parent)) {
+  const topListNode = $getTopListNode(anchor);
+  const parent = anchor.getParent();
+  if (!$isListNode(parent)) {
     console.log("A WebinyListItemNode must have a WebinyListNode for a parent.");
     return false;
   }
-  var grandparent = parent?.getParent() || null;
-  var replacementNode;
-  if ((0, _lexical.$isRootOrShadowRoot)(grandparent)) {
-    replacementNode = (0, _ParagraphNode.$createParagraphNode)();
+  const grandparent = parent?.getParent() || null;
+  let replacementNode;
+  if ($isRootOrShadowRoot(grandparent)) {
+    replacementNode = $createParagraphNode();
     topListNode.insertAfter(replacementNode);
-  } else if ((0, _ListItemNode.$isListItemNode)(grandparent)) {
-    replacementNode = (0, _ListItemNode.$createListItemNode)();
+  } else if ($isListItemNode(grandparent)) {
+    replacementNode = $createListItemNode();
     grandparent.insertAfter(replacementNode);
   } else {
     return false;
   }
   replacementNode.select();
-  var nextSiblings = anchor.getNextSiblings();
+  const nextSiblings = anchor.getNextSiblings();
   if (nextSiblings.length > 0) {
-    var newList = (0, _ListNode.$createListNode)(parent?.getListType(), parent?.getStyleId());
-    if ((0, _lexical.$isParagraphNode)(replacementNode)) {
+    const newList = $createListNode(parent?.getListType(), parent?.getStyleId());
+    if ($isParagraphNode(replacementNode)) {
       replacementNode.insertAfter(newList);
     } else {
-      var newListItem = (0, _ListItemNode.$createListItemNode)();
+      const newListItem = $createListItemNode();
       newListItem.append(newList);
       replacementNode.insertAfter(newListItem);
     }
-    nextSiblings.forEach(function (sibling) {
+    nextSiblings.forEach(sibling => {
       sibling.remove();
       newList.append(sibling);
     });
   }
 
   // Don't leave hanging nested empty lists
-  (0, _listNode.$removeHighestEmptyListParent)(anchor);
+  $removeHighestEmptyListParent(anchor);
   return true;
 }