@lexical/list 0.12.2 → 0.12.3

package/LexicalList.dev.js

@@ -16,63 +16,54 @@ var utils = require('@lexical/utils');
  * LICENSE file in the root directory of this source tree.
  *
  */
+
 /**
  * Checks the depth of listNode from the root node.
  * @param listNode - The ListNode to be checked.
  * @returns The depth of the ListNode.
  */
-
 function $getListDepth(listNode) {
   let depth = 1;
   let parent = listNode.getParent();
-
   while (parent != null) {
     if ($isListItemNode(parent)) {
       const parentList = parent.getParent();
-
       if ($isListNode(parentList)) {
         depth++;
         parent = parentList.getParent();
         continue;
       }
-
       {
         throw Error(`A ListItemNode must have a ListNode for a parent.`);
       }
     }
-
     return depth;
   }
-
   return depth;
 }
+
 /**
  * Finds the nearest ancestral ListNode and returns it, throws an invariant if listItem is not a ListItemNode.
  * @param listItem - The node to be checked.
  * @returns The ListNode found.
  */
-
 function $getTopListNode(listItem) {
   let list = listItem.getParent();
-
   if (!$isListNode(list)) {
     {
       throw Error(`A ListItemNode must have a ListNode for a parent.`);
     }
   }
-
   let parent = list;
-
   while (parent !== null) {
     parent = parent.getParent();
-
     if ($isListNode(parent)) {
       list = parent;
     }
   }
-
   return list;
 }
+
 /**
  * A recursive Depth-First Search (Postorder Traversal) that finds all of a node's children
  * that are of type ListItemNode and returns them in an array.
@@ -80,33 +71,30 @@ function $getTopListNode(listItem) {
  * @returns An array containing all nodes of type ListItemNode found.
  */
 // This should probably be $getAllChildrenOfType
-
 function $getAllListItems(node) {
   let listItemNodes = [];
   const listChildren = node.getChildren().filter($isListItemNode);
-
   for (let i = 0; i < listChildren.length; i++) {
     const listItemNode = listChildren[i];
     const firstChild = listItemNode.getFirstChild();
-
     if ($isListNode(firstChild)) {
       listItemNodes = listItemNodes.concat($getAllListItems(firstChild));
     } else {
       listItemNodes.push(listItemNode);
     }
   }
-
   return listItemNodes;
 }
+
 /**
  * Checks to see if the passed node is a ListItemNode and has a ListNode as a child.
  * @param node - The node to be checked.
  * @returns true if the node is a ListItemNode and has a ListNode child, false otherwise.
  */
-
 function isNestedListNode(node) {
   return $isListItemNode(node) && $isListNode(node.getFirstChild());
 }
+
 /**
  * Takes a deeply nested ListNode or ListItemNode and traverses up the branch to delete the first
  * ancestral ListNode (which could be the root ListNode) or ListItemNode with siblings, essentially
@@ -114,7 +102,6 @@ function isNestedListNode(node) {
  * Should not break ListItem -> List -> ListItem chain as empty List/ItemNodes should be removed on .remove().
  * @param sublist - The nested ListNode or ListItemNode to be brought up the branch.
  */
-
 function $removeHighestEmptyListParent(sublist) {
   // Nodes may be repeatedly indented, to create deeply nested lists that each
   // contain just one bullet.
@@ -123,25 +110,21 @@ function $removeHighestEmptyListParent(sublist) {
   // (e.g. is actually part of the list contents) and delete that, or delete
   // the root of the list (if no list nodes have siblings.)
   let emptyListPtr = sublist;
-
   while (emptyListPtr.getNextSibling() == null && emptyListPtr.getPreviousSibling() == null) {
     const parent = emptyListPtr.getParent();
-
     if (parent == null || !($isListItemNode(emptyListPtr) || $isListNode(emptyListPtr))) {
       break;
     }
-
     emptyListPtr = parent;
   }
-
   emptyListPtr.remove();
 }
+
 /**
  * Wraps a node into a ListItemNode.
  * @param node - The node to be wrapped into a ListItemNode
  * @returns The ListItemNode which the passed node is wrapped in.
  */
-
 function wrapInListItem(node) {
   const listItemWrapper = $createListItemNode();
   return listItemWrapper.append(node);
@@ -154,15 +137,12 @@ function wrapInListItem(node) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 function $isSelectingEmptyListItem(anchorNode, nodes) {
   return $isListItemNode(anchorNode) && (nodes.length === 0 || nodes.length === 1 && anchorNode.is(nodes[0]) && anchorNode.getChildrenSize() === 0);
 }
-
 function $getListItemValue(listItem) {
   const list = listItem.getParent();
   let value = 1;
-
   if (list != null) {
     if (!$isListNode(list)) {
       {
@@ -172,19 +152,16 @@ function $getListItemValue(listItem) {
       value = list.getStart();
     }
   }
-
   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;
 }
+
 /**
  * Inserts a new ListNode. If the selection's anchor node is an empty ListItemNode and is a child of
  * the root/shadow root, it will replace the ListItemNode with a ListNode and the old ListItemNode.
@@ -195,55 +172,42 @@ function $getListItemValue(listItem) {
  * @param editor - The lexical editor.
  * @param listType - The type of list, "number" | "bullet" | "check".
  */
-
-
 function insertList(editor, listType) {
   editor.update(() => {
     const selection = lexical.$getSelection();
-
     if (lexical.$isRangeSelection(selection) || lexical.DEPRECATED_$isGridSelection(selection)) {
       const nodes = selection.getNodes();
       const anchor = selection.anchor;
       const anchorNode = anchor.getNode();
       const anchorNodeParent = anchorNode.getParent();
-
       if ($isSelectingEmptyListItem(anchorNode, nodes)) {
         const list = $createListNode(listType);
-
         if (lexical.$isRootOrShadowRoot(anchorNodeParent)) {
           anchorNode.replace(list);
           const listItem = $createListItemNode();
-
           if (lexical.$isElementNode(anchorNode)) {
             listItem.setFormat(anchorNode.getFormatType());
             listItem.setIndent(anchorNode.getIndent());
           }
-
           list.append(listItem);
         } else if ($isListItemNode(anchorNode)) {
           const parent = anchorNode.getParentOrThrow();
           append(list, parent.getChildren());
           parent.replace(list);
         }
-
         return;
       } else {
         const handled = new Set();
-
         for (let i = 0; i < nodes.length; i++) {
           const node = nodes[i];
-
           if (lexical.$isElementNode(node) && node.isEmpty() && !handled.has(node.getKey())) {
             createListOrMerge(node, listType);
             continue;
           }
-
           if (lexical.$isLeafNode(node)) {
             let parent = node.getParent();
-
             while (parent != null) {
               const parentKey = parent.getKey();
-
               if ($isListNode(parent)) {
                 if (!handled.has(parentKey)) {
                   const newListNode = $createListNode(listType);
@@ -252,17 +216,14 @@ function insertList(editor, listType) {
                   updateChildrenListItemValue(newListNode);
                   handled.add(parentKey);
                 }
-
                 break;
               } else {
                 const nextParent = parent.getParent();
-
                 if (lexical.$isRootOrShadowRoot(nextParent) && !handled.has(parentKey)) {
                   handled.add(parentKey);
                   createListOrMerge(parent, listType);
                   break;
                 }
-
                 parent = nextParent;
               }
             }
@@ -272,32 +233,28 @@ function insertList(editor, listType) {
     }
   });
 }
-
 function append(node, nodesToAppend) {
   node.splice(node.getChildrenSize(), 0, nodesToAppend);
 }
-
 function createListOrMerge(node, listType) {
   if ($isListNode(node)) {
     return node;
   }
-
   const previousSibling = node.getPreviousSibling();
   const nextSibling = node.getNextSibling();
   const listItem = $createListItemNode();
   listItem.setFormat(node.getFormatType());
   listItem.setIndent(node.getIndent());
   append(listItem, node.getChildren());
-
   if ($isListNode(previousSibling) && listType === previousSibling.getListType()) {
     previousSibling.append(listItem);
-    node.remove(); // if the same type of list is on both sides, merge them.
+    node.remove();
+    // if the same type of list is on both sides, merge them.
 
     if ($isListNode(nextSibling) && listType === nextSibling.getListType()) {
       append(previousSibling, nextSibling.getChildren());
       nextSibling.remove();
     }
-
     return previousSibling;
   } else if ($isListNode(nextSibling) && listType === nextSibling.getListType()) {
     nextSibling.getFirstChildOrThrow().insertBefore(listItem);
@@ -311,32 +268,28 @@ function createListOrMerge(node, listType) {
     return list;
   }
 }
+
 /**
  * A recursive function that goes through each list and their children, including nested lists,
  * appending list2 children after list1 children and updating ListItemNode values.
  * @param list1 - The first list to be merged.
  * @param list2 - The second list to be merged.
  */
-
-
 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();
   }
-
   const toMerge = list2.getChildren();
-
   if (toMerge.length > 0) {
     list1.append(...toMerge);
     updateChildrenListItemValue(list1);
   }
-
   list2.remove();
 }
+
 /**
  * Searches for the nearest ancestral ListNode and removes it. If selection is an empty ListItemNode
  * it will remove the whole list, including the ListItemNode. For each ListItemNode in the ListNode,
@@ -344,63 +297,55 @@ function mergeLists(list1, list2) {
  * inside a ListItemNode will be appended to the new ParagraphNodes.
  * @param editor - The lexical editor.
  */
-
 function removeList(editor) {
   editor.update(() => {
     const selection = lexical.$getSelection();
-
     if (lexical.$isRangeSelection(selection)) {
       const listNodes = new Set();
       const nodes = selection.getNodes();
       const anchorNode = selection.anchor.getNode();
-
       if ($isSelectingEmptyListItem(anchorNode, nodes)) {
         listNodes.add($getTopListNode(anchorNode));
       } else {
         for (let i = 0; i < nodes.length; i++) {
           const node = nodes[i];
-
           if (lexical.$isLeafNode(node)) {
             const listItemNode = utils.$getNearestNodeOfType(node, ListItemNode);
-
             if (listItemNode != null) {
               listNodes.add($getTopListNode(listItemNode));
             }
           }
         }
       }
-
       for (const listNode of listNodes) {
         let insertionPoint = listNode;
         const listItems = $getAllListItems(listNode);
-
         for (const listItemNode of listItems) {
           const paragraph = lexical.$createParagraphNode();
           append(paragraph, listItemNode.getChildren());
           insertionPoint.insertAfter(paragraph);
-          insertionPoint = paragraph; // When the anchor and focus fall on the textNode
+          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();
         }
-
         listNode.remove();
       }
     }
   });
 }
+
 /**
  * Takes the value of a child ListItemNode and makes it the value the ListItemNode
  * should be if it isn't already. If only certain children should be updated, they
@@ -408,18 +353,14 @@ function removeList(editor) {
  * @param list - The list whose children are updated.
  * @param children - An array of the children to be updated.
  */
-
 function updateChildrenListItemValue(list, children) {
   const childrenOrExisting = children || list.getChildren();
-
   if (childrenOrExisting !== undefined) {
     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);
         }
@@ -427,70 +368,63 @@ function updateChildrenListItemValue(list, children) {
     }
   }
 }
+
 /**
  * Adds an empty ListNode/ListItemNode chain at listItemNode, so as to
  * create an indent effect. Won't indent ListItemNodes that have a ListNode as
  * a child, but does merge sibling ListItemNodes if one has a nested ListNode.
  * @param listItemNode - The ListItemNode to be indented.
  */
-
 function $handleIndent(listItemNode) {
   // go through each node and decide where to move it.
   const removed = new Set();
-
   if (isNestedListNode(listItemNode) || removed.has(listItemNode.getKey())) {
     return;
   }
+  const parent = listItemNode.getParent();
 
-  const parent = listItemNode.getParent(); // We can cast both of the below `isNestedListNode` only returns a boolean type instead of a user-defined type guards
-
+  // We can cast both of the below `isNestedListNode` only returns a boolean type instead of a user-defined type guards
   const nextSibling = listItemNode.getNextSibling();
-  const previousSibling = listItemNode.getPreviousSibling(); // if there are nested lists on either side, merge them all together.
+  const previousSibling = listItemNode.getPreviousSibling();
+  // if there are nested lists on either side, merge them all together.
 
   if (isNestedListNode(nextSibling) && isNestedListNode(previousSibling)) {
     const innerList = previousSibling.getFirstChild();
-
     if ($isListNode(innerList)) {
       innerList.append(listItemNode);
       const nextInnerList = nextSibling.getFirstChild();
-
       if ($isListNode(nextInnerList)) {
         const children = nextInnerList.getChildren();
         append(innerList, children);
         nextSibling.remove();
         removed.add(nextSibling.getKey());
       }
-
       updateChildrenListItemValue(innerList);
     }
   } else if (isNestedListNode(nextSibling)) {
     // if the ListItemNode is next to a nested ListNode, merge them
     const innerList = nextSibling.getFirstChild();
-
     if ($isListNode(innerList)) {
       const firstChild = innerList.getFirstChild();
-
       if (firstChild !== null) {
         firstChild.insertBefore(listItemNode);
       }
-
       updateChildrenListItemValue(innerList);
     }
   } else if (isNestedListNode(previousSibling)) {
     const innerList = previousSibling.getFirstChild();
-
     if ($isListNode(innerList)) {
       innerList.append(listItemNode);
       updateChildrenListItemValue(innerList);
     }
   } else {
     // otherwise, we need to create a new nested ListNode
+
     if ($isListNode(parent)) {
       const newListItem = $createListItemNode();
       const newList = $createListNode(parent.getListType());
       newListItem.append(newList);
       newList.append(listItemNode);
-
       if (previousSibling) {
         previousSibling.insertAfter(newListItem);
       } else if (nextSibling) {
@@ -498,49 +432,45 @@ function $handleIndent(listItemNode) {
       } else {
         parent.append(newListItem);
       }
-
       updateChildrenListItemValue(newList);
     }
   }
-
   if ($isListNode(parent)) {
     updateChildrenListItemValue(parent);
   }
 }
+
 /**
  * Removes an indent by removing an empty ListNode/ListItemNode chain. An indented ListItemNode
  * has a great grandparent node of type ListNode, which is where the ListItemNode will reside
  * within as a child.
  * @param listItemNode - The ListItemNode to remove the indent (outdent).
  */
-
 function $handleOutdent(listItemNode) {
   // go through each node and decide where to move it.
+
   if (isNestedListNode(listItemNode)) {
     return;
   }
-
   const parentList = listItemNode.getParent();
   const grandparentListItem = parentList ? parentList.getParent() : undefined;
-  const greatGrandparentList = grandparentListItem ? grandparentListItem.getParent() : undefined; // If it doesn't have these ancestors, it's not indented.
+  const greatGrandparentList = grandparentListItem ? grandparentListItem.getParent() : undefined;
+  // If it doesn't have these ancestors, it's not indented.
 
   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
     const firstChild = parentList ? parentList.getFirstChild() : undefined;
     const lastChild = parentList ? parentList.getLastChild() : undefined;
-
     if (listItemNode.is(firstChild)) {
       grandparentListItem.insertBefore(listItemNode);
-
       if (parentList.isEmpty()) {
         grandparentListItem.remove();
-      } // if it's the last child in it's parent list, insert it into the
+      }
+      // if it's the last child in it's parent list, insert it into the
       // great grandparent list after the grandparent.
-
     } else if (listItemNode.is(lastChild)) {
       grandparentListItem.insertAfter(listItemNode);
-
       if (parentList.isEmpty()) {
         grandparentListItem.remove();
       }
@@ -554,18 +484,18 @@ function $handleOutdent(listItemNode) {
       const nextSiblingsListItem = $createListItemNode();
       const nextSiblingsList = $createListNode(listType);
       nextSiblingsListItem.append(nextSiblingsList);
-      append(nextSiblingsList, listItemNode.getNextSiblings()); // put the sibling nested lists on either side of the grandparent list item in the great grandparent.
-
+      append(nextSiblingsList, listItemNode.getNextSiblings());
+      // put the sibling nested lists on either side of the grandparent list item in the great grandparent.
       grandparentListItem.insertBefore(previousSiblingsListItem);
-      grandparentListItem.insertAfter(nextSiblingsListItem); // replace the grandparent list item (now between the siblings) with the outdented list item.
-
+      grandparentListItem.insertAfter(nextSiblingsListItem);
+      // replace the grandparent list item (now between the siblings) with the outdented list item.
       grandparentListItem.replace(listItemNode);
     }
-
     updateChildrenListItemValue(parentList);
     updateChildrenListItemValue(greatGrandparentList);
   }
 }
+
 /**
  * Attempts to insert a ParagraphNode at selection and selects the new node. The selection must contain a ListItemNode
  * or a node that does not already contain text. If its grandparent is the root/shadow root, it will get the ListNode
@@ -575,31 +505,23 @@ function $handleOutdent(listItemNode) {
  * @returns true if a ParagraphNode was inserted succesfully, false if there is no selection
  * or the selection does not contain a ListItemNode or the node already holds text.
  */
-
 function $handleListInsertParagraph() {
   const selection = lexical.$getSelection();
-
   if (!lexical.$isRangeSelection(selection) || !selection.isCollapsed()) {
     return false;
-  } // Only run this code on empty list items
-
-
+  }
+  // Only run this code on empty list items
   const anchor = selection.anchor.getNode();
-
   if (!$isListItemNode(anchor) || anchor.getChildrenSize() !== 0) {
     return false;
   }
-
   const topListNode = $getTopListNode(anchor);
   const parent = anchor.getParent();
-
   if (!$isListNode(parent)) {
     throw Error(`A ListItemNode must have a ListNode for a parent.`);
   }
-
   const grandparent = parent.getParent();
   let replacementNode;
-
   if (lexical.$isRootOrShadowRoot(grandparent)) {
     replacementNode = lexical.$createParagraphNode();
     topListNode.insertAfter(replacementNode);
@@ -609,13 +531,10 @@ function $handleListInsertParagraph() {
   } else {
     return false;
   }
-
   replacementNode.select();
   const nextSiblings = anchor.getNextSiblings();
-
   if (nextSiblings.length > 0) {
     const newList = $createListNode(parent.getListType());
-
     if (lexical.$isParagraphNode(replacementNode)) {
       replacementNode.insertAfter(newList);
     } else {
@@ -623,14 +542,13 @@ function $handleListInsertParagraph() {
       newListItem.append(newList);
       replacementNode.insertAfter(newListItem);
     }
-
     nextSiblings.forEach(sibling => {
       sibling.remove();
       newList.append(sibling);
     });
-  } // Don't leave hanging nested empty lists
-
+  }
 
+  // Don't leave hanging nested empty lists
   $removeHighestEmptyListParent(anchor);
   return true;
 }
@@ -642,66 +560,54 @@ function $handleListInsertParagraph() {
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 /** @noInheritDoc */
 class ListItemNode extends lexical.ElementNode {
   /** @internal */
 
   /** @internal */
+
   static getType() {
     return 'listitem';
   }
-
   static clone(node) {
     return new ListItemNode(node.__value, node.__checked, node.__key);
   }
-
   constructor(value, checked, key) {
     super(key);
     this.__value = value === undefined ? 1 : value;
     this.__checked = checked;
   }
-
   createDOM(config) {
     const element = document.createElement('li');
     const parent = this.getParent();
-
     if ($isListNode(parent) && parent.getListType() === 'check') {
       updateListItemChecked(element, this, null);
     }
-
     element.value = this.__value;
     $setListItemThemeClassNames(element, config.theme, this);
     return element;
   }
-
   updateDOM(prevNode, dom, config) {
     const parent = this.getParent();
-
     if ($isListNode(parent) && parent.getListType() === 'check') {
       updateListItemChecked(dom, this, prevNode);
-    } // @ts-expect-error - this is always HTMLListItemElement
-
-
+    }
+    // @ts-expect-error - this is always HTMLListItemElement
     dom.value = this.__value;
     $setListItemThemeClassNames(dom, config.theme, this);
     return false;
   }
-
   static transform() {
     return node => {
       const parent = node.getParent();
-
       if ($isListNode(parent)) {
         updateChildrenListItemValue(parent);
-
         if (parent.getListType() !== 'check' && node.getChecked() != null) {
           node.setChecked(undefined);
         }
       }
     };
   }
-
   static importDOM() {
     return {
       li: node => ({
@@ -710,7 +616,6 @@ class ListItemNode extends lexical.ElementNode {
       })
     };
   }
-
   static importJSON(serializedNode) {
     const node = $createListItemNode();
     node.setChecked(serializedNode.checked);
@@ -719,20 +624,25 @@ class ListItemNode extends lexical.ElementNode {
     node.setDirection(serializedNode.direction);
     return node;
   }
-
+  exportDOM(editor) {
+    const element = this.createDOM(editor._config);
+    element.style.textAlign = this.getFormatType();
+    return {
+      element
+    };
+  }
   exportJSON() {
-    return { ...super.exportJSON(),
+    return {
+      ...super.exportJSON(),
       checked: this.getChecked(),
       type: 'listitem',
       value: this.getValue(),
       version: 1
     };
   }
-
   append(...nodes) {
     for (let i = 0; i < nodes.length; i++) {
       const node = nodes[i];
-
       if (lexical.$isElementNode(node) && this.canMergeWith(node)) {
         const children = node.getChildren();
         this.append(...children);
@@ -741,19 +651,15 @@ class ListItemNode extends lexical.ElementNode {
         super.append(node);
       }
     }
-
     return this;
   }
-
   replace(replaceWithNode, includeChildren) {
     if ($isListItemNode(replaceWithNode)) {
       return super.replace(replaceWithNode);
     }
-
     this.setIndent(0);
     const list = this.getParentOrThrow();
     if (!$isListNode(list)) return replaceWithNode;
-
     if (list.__first === this.getKey()) {
       list.insertBefore(replaceWithNode);
     } else if (list.__last === this.getKey()) {
@@ -762,103 +668,83 @@ class ListItemNode extends lexical.ElementNode {
       // Split the list
       const newList = $createListNode(list.getListType());
       let nextSibling = this.getNextSibling();
-
       while (nextSibling) {
         const nodeToAppend = nextSibling;
         nextSibling = nextSibling.getNextSibling();
         newList.append(nodeToAppend);
       }
-
       list.insertAfter(replaceWithNode);
       replaceWithNode.insertAfter(newList);
     }
-
     if (includeChildren) {
       this.getChildren().forEach(child => {
         replaceWithNode.append(child);
       });
     }
-
     this.remove();
-
     if (list.getChildrenSize() === 0) {
       list.remove();
     }
-
     return replaceWithNode;
   }
-
   insertAfter(node, restoreSelection = true) {
     const listNode = this.getParentOrThrow();
-
     if (!$isListNode(listNode)) {
       {
         throw Error(`insertAfter: list node is not parent of list item node`);
       }
     }
-
     const siblings = this.getNextSiblings();
-
     if ($isListItemNode(node)) {
       const after = super.insertAfter(node, restoreSelection);
       const afterListNode = node.getParentOrThrow();
-
       if ($isListNode(afterListNode)) {
         updateChildrenListItemValue(afterListNode);
       }
-
       return after;
-    } // Attempt to merge if the list is of the same type.
+    }
 
+    // Attempt to merge if the list is of the same type.
 
     if ($isListNode(node)) {
       let child = node;
       const children = node.getChildren();
-
       for (let i = children.length - 1; i >= 0; i--) {
         child = children[i];
         this.insertAfter(child, restoreSelection);
       }
-
       return child;
-    } // Otherwise, split the list
-    // Split the lists and insert the node in between them
-
+    }
 
+    // Otherwise, split the list
+    // Split the lists and insert the node in between them
     listNode.insertAfter(node, restoreSelection);
-
     if (siblings.length !== 0) {
       const newListNode = $createListNode(listNode.getListType());
       siblings.forEach(sibling => newListNode.append(sibling));
       node.insertAfter(newListNode, restoreSelection);
     }
-
     return node;
   }
-
   remove(preserveEmptyParent) {
     const prevSibling = this.getPreviousSibling();
     const nextSibling = this.getNextSibling();
     super.remove(preserveEmptyParent);
-
     if (prevSibling && nextSibling && isNestedListNode(prevSibling) && isNestedListNode(nextSibling)) {
       mergeLists(prevSibling.getFirstChild(), nextSibling.getFirstChild());
       nextSibling.remove();
     } else if (nextSibling) {
       const parent = nextSibling.getParent();
-
       if ($isListNode(parent)) {
         updateChildrenListItemValue(parent);
       }
     }
   }
-
   insertNewAfter(_, restoreSelection = true) {
     const newElement = $createListItemNode(this.__checked == null ? undefined : false);
     this.insertAfter(newElement, restoreSelection);
     return newElement;
   }
-
   collapseAtStart(selection) {
     const paragraph = lexical.$createParagraphNode();
     const children = this.getChildren();
@@ -866,7 +752,6 @@ class ListItemNode extends lexical.ElementNode {
     const listNode = this.getParentOrThrow();
     const listNodeParent = listNode.getParentOrThrow();
     const isIndented = $isListItemNode(listNodeParent);
-
     if (listNode.getChildrenSize() === 1) {
       if (isIndented) {
         // if the list node is nested, we just want to remove it,
@@ -875,17 +760,15 @@ class ListItemNode extends lexical.ElementNode {
         listNodeParent.select();
       } else {
         listNode.insertBefore(paragraph);
-        listNode.remove(); // If we have selection on the list item, we'll need to move it
+        listNode.remove();
+        // If we have selection on the list item, we'll need to move it
         // to the paragraph
-
         const anchor = selection.anchor;
         const focus = selection.focus;
         const key = paragraph.getKey();
-
         if (anchor.type === 'element' && anchor.getNode().is(this)) {
           anchor.set(key, anchor.offset, 'element');
         }
-
         if (focus.type === 'element' && focus.getNode().is(this)) {
           focus.set(key, focus.offset, 'element');
         }
@@ -894,61 +777,47 @@ class ListItemNode extends lexical.ElementNode {
       listNode.insertBefore(paragraph);
       this.remove();
     }
-
     return true;
   }
-
   getValue() {
     const self = this.getLatest();
     return self.__value;
   }
-
   setValue(value) {
     const self = this.getWritable();
     self.__value = value;
   }
-
   getChecked() {
     const self = this.getLatest();
     return self.__checked;
   }
-
   setChecked(checked) {
     const self = this.getWritable();
     self.__checked = checked;
   }
-
   toggleChecked() {
     this.setChecked(!this.__checked);
   }
-
   getIndent() {
     // If we don't have a parent, we are likely serializing
     const parent = this.getParent();
-
     if (parent === null) {
       return this.getLatest().__indent;
-    } // ListItemNode should always have a ListNode for a parent.
-
-
+    }
+    // ListItemNode should always have a ListNode for a parent.
     let listNodeParent = parent.getParentOrThrow();
     let indentLevel = 0;
-
     while ($isListItemNode(listNodeParent)) {
       listNodeParent = listNodeParent.getParentOrThrow().getParentOrThrow();
       indentLevel++;
     }
-
     return indentLevel;
   }
-
   setIndent(indent) {
     if (!(typeof indent === 'number' && indent > -1)) {
       throw Error(`Invalid indent value.`);
     }
-
     let currentIndent = this.getIndent();
-
     while (currentIndent !== indent) {
       if (currentIndent < indent) {
         $handleIndent(this);
@@ -958,108 +827,84 @@ class ListItemNode extends lexical.ElementNode {
         currentIndent--;
       }
     }
-
     return this;
   }
-
   insertBefore(nodeToInsert) {
     if ($isListItemNode(nodeToInsert)) {
       const parent = this.getParentOrThrow();
-
       if ($isListNode(parent)) {
         const siblings = this.getNextSiblings();
         updateChildrenListItemValue(parent, siblings);
       }
     }
-
     return super.insertBefore(nodeToInsert);
   }
-
   canInsertAfter(node) {
     return $isListItemNode(node);
   }
-
   canReplaceWith(replacement) {
     return $isListItemNode(replacement);
   }
-
   canMergeWith(node) {
     return lexical.$isParagraphNode(node) || $isListItemNode(node);
   }
-
   extractWithChild(child, selection) {
     if (!lexical.$isRangeSelection(selection)) {
       return false;
     }
-
     const anchorNode = selection.anchor.getNode();
     const focusNode = selection.focus.getNode();
     return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && this.getTextContent().length === selection.getTextContent().length;
   }
-
   isParentRequired() {
     return true;
   }
-
   createParentElementNode() {
     return $createListNode('bullet');
   }
-
 }
-
 function $setListItemThemeClassNames(dom, editorThemeClasses, node) {
   const classesToAdd = [];
   const classesToRemove = [];
   const listTheme = editorThemeClasses.list;
   const listItemClassName = listTheme ? listTheme.listitem : undefined;
   let nestedListItemClassName;
-
   if (listTheme && listTheme.nested) {
     nestedListItemClassName = listTheme.nested.listitem;
   }
-
   if (listItemClassName !== undefined) {
     const listItemClasses = listItemClassName.split(' ');
     classesToAdd.push(...listItemClasses);
   }
-
   if (listTheme) {
     const parentNode = node.getParent();
     const isCheckList = $isListNode(parentNode) && parentNode.getListType() === 'check';
     const checked = node.getChecked();
-
     if (!isCheckList || checked) {
       classesToRemove.push(listTheme.listitemUnchecked);
     }
-
     if (!isCheckList || !checked) {
       classesToRemove.push(listTheme.listitemChecked);
     }
-
     if (isCheckList) {
       classesToAdd.push(checked ? listTheme.listitemChecked : listTheme.listitemUnchecked);
     }
   }
-
   if (nestedListItemClassName !== undefined) {
     const nestedListItemClasses = nestedListItemClassName.split(' ');
-
     if (node.getChildren().some(child => $isListNode(child))) {
       classesToAdd.push(...nestedListItemClasses);
     } else {
       classesToRemove.push(...nestedListItemClasses);
     }
   }
-
   if (classesToRemove.length > 0) {
     utils.removeClassNamesFromElement(dom, ...classesToRemove);
   }
-
   if (classesToAdd.length > 0) {
     utils.addClassNamesToElement(dom, ...classesToAdd);
   }
 }
-
 function updateListItemChecked(dom, listItemNode, prevListItemNode, listNode) {
   // Only add attributes for leaf list items
   if ($isListNode(listItemNode.getFirstChild())) {
@@ -1069,35 +914,32 @@ function updateListItemChecked(dom, listItemNode, prevListItemNode, listNode) {
   } else {
     dom.setAttribute('role', 'checkbox');
     dom.setAttribute('tabIndex', '-1');
-
     if (!prevListItemNode || listItemNode.__checked !== prevListItemNode.__checked) {
       dom.setAttribute('aria-checked', listItemNode.getChecked() ? 'true' : 'false');
     }
   }
 }
-
 function convertListItemElement(domNode) {
   const checked = utils.isHTMLElement(domNode) && domNode.getAttribute('aria-checked') === 'true';
   return {
     node: $createListItemNode(checked)
   };
 }
+
 /**
  * Creates a new List Item node, passing true/false will convert it to a checkbox input.
  * @param checked - Is the List Item a checkbox and, if so, is it checked? undefined/null: not a checkbox, true/false is a checkbox and checked/unchecked, respectively.
  * @returns The new List Item.
  */
-
-
 function $createListItemNode(checked) {
   return lexical.$applyNodeReplacement(new ListItemNode(undefined, checked));
 }
+
 /**
  * Checks to see if the node is a ListItemNode.
  * @param node - The node to be checked.
  * @returns true if the node is a ListItemNode, false otherwise.
  */
-
 function $isListItemNode(node) {
   return node instanceof ListItemNode;
 }
@@ -1109,7 +951,6 @@ function $isListItemNode(node) {
  * LICENSE file in the root directory of this source tree.
  *
  */
-
 /** @noInheritDoc */
 class ListNode extends lexical.ElementNode {
   /** @internal */
@@ -1117,67 +958,56 @@ class ListNode extends lexical.ElementNode {
   /** @internal */
 
   /** @internal */
+
   static getType() {
     return 'list';
   }
-
   static clone(node) {
     const listType = node.__listType || TAG_TO_LIST_TYPE[node.__tag];
     return new ListNode(listType, node.__start, node.__key);
   }
-
   constructor(listType, start, key) {
     super(key);
-
     const _listType = TAG_TO_LIST_TYPE[listType] || listType;
-
     this.__listType = _listType;
     this.__tag = _listType === 'number' ? 'ol' : 'ul';
     this.__start = start;
   }
-
   getTag() {
     return this.__tag;
   }
-
   setListType(type) {
     const writable = this.getWritable();
     writable.__listType = type;
     writable.__tag = type === 'number' ? 'ol' : 'ul';
   }
-
   getListType() {
     return this.__listType;
   }
-
   getStart() {
     return this.__start;
-  } // View
+  }
 
+  // View
 
   createDOM(config, _editor) {
     const tag = this.__tag;
     const dom = document.createElement(tag);
-
     if (this.__start !== 1) {
       dom.setAttribute('start', String(this.__start));
-    } // @ts-expect-error Internal field.
-
-
+    }
+    // @ts-expect-error Internal field.
     dom.__lexicalListType = this.__listType;
     setListThemeClassNames(dom, config.theme, this);
     return dom;
   }
-
   updateDOM(prevNode, dom, config) {
     if (prevNode.__tag !== this.__tag) {
       return true;
     }
-
     setListThemeClassNames(dom, config.theme, this);
     return false;
   }
-
   static importDOM() {
     return {
       ol: node => ({
@@ -1190,7 +1020,6 @@ class ListNode extends lexical.ElementNode {
       })
     };
   }
-
   static importJSON(serializedNode) {
     const node = $createListNode(serializedNode.listType, serializedNode.start);
     node.setFormat(serializedNode.format);
@@ -1198,29 +1027,25 @@ class ListNode extends lexical.ElementNode {
     node.setDirection(serializedNode.direction);
     return node;
   }
-
   exportDOM(editor) {
     const {
       element
     } = super.exportDOM(editor);
-
     if (element && utils.isHTMLElement(element)) {
       if (this.__start !== 1) {
         element.setAttribute('start', String(this.__start));
       }
-
       if (this.__listType === 'check') {
         element.setAttribute('__lexicalListType', 'check');
       }
     }
-
     return {
       element
     };
   }
-
   exportJSON() {
-    return { ...super.exportJSON(),
+    return {
+      ...super.exportJSON(),
       listType: this.getListType(),
       start: this.getStart(),
       tag: this.getTag(),
@@ -1228,24 +1053,19 @@ class ListNode extends lexical.ElementNode {
       version: 1
     };
   }
-
   canBeEmpty() {
     return false;
   }
-
   canIndent() {
     return false;
   }
-
   append(...nodesToAppend) {
     for (let i = 0; i < nodesToAppend.length; i++) {
       const currentNode = nodesToAppend[i];
-
       if ($isListItemNode(currentNode)) {
         super.append(currentNode);
       } else {
         const listItemNode = $createListItemNode();
-
         if ($isListNode(currentNode)) {
           listItemNode.append(currentNode);
         } else if (lexical.$isElementNode(currentNode)) {
@@ -1254,26 +1074,20 @@ class ListNode extends lexical.ElementNode {
         } else {
           listItemNode.append(currentNode);
         }
-
         super.append(listItemNode);
       }
     }
-
     updateChildrenListItemValue(this);
     return this;
   }
-
   extractWithChild(child) {
     return $isListItemNode(child);
   }
-
 }
-
 function setListThemeClassNames(dom, editorThemeClasses, node) {
   const classesToAdd = [];
   const classesToRemove = [];
   const listTheme = editorThemeClasses.list;
-
   if (listTheme !== undefined) {
     const listLevelsClassNames = listTheme[`${node.__tag}Depth`] || [];
     const listDepth = $getListDepth(node) - 1;
@@ -1282,29 +1096,23 @@ function setListThemeClassNames(dom, editorThemeClasses, node) {
     const listClassName = listTheme[node.__tag];
     let nestedListClassName;
     const nestedListTheme = listTheme.nested;
-
     if (nestedListTheme !== undefined && nestedListTheme.list) {
       nestedListClassName = nestedListTheme.list;
     }
-
     if (listClassName !== undefined) {
       classesToAdd.push(listClassName);
     }
-
     if (listLevelClassName !== undefined) {
       const listItemClasses = listLevelClassName.split(' ');
       classesToAdd.push(...listItemClasses);
-
       for (let i = 0; i < listLevelsClassNames.length; i++) {
         if (i !== normalizedListDepth) {
           classesToRemove.push(node.__tag + i);
         }
       }
     }
-
     if (nestedListClassName !== undefined) {
       const nestedListItemClasses = nestedListClassName.split(' ');
-
       if (listDepth > 1) {
         classesToAdd.push(...nestedListItemClasses);
       } else {
@@ -1312,32 +1120,26 @@ function setListThemeClassNames(dom, editorThemeClasses, node) {
       }
     }
   }
-
   if (classesToRemove.length > 0) {
     utils.removeClassNamesFromElement(dom, ...classesToRemove);
   }
-
   if (classesToAdd.length > 0) {
     utils.addClassNamesToElement(dom, ...classesToAdd);
   }
 }
+
 /*
  * This function normalizes the children of a ListNode after the conversion from HTML,
  * ensuring that they are all ListItemNodes and contain either a single nested ListNode
  * or some other inline content.
  */
-
-
 function normalizeChildren(nodes) {
   const normalizedListItems = [];
-
   for (let i = 0; i < nodes.length; i++) {
     const node = nodes[i];
-
     if ($isListItemNode(node)) {
       normalizedListItems.push(node);
       const children = node.getChildren();
-
       if (children.length > 1) {
         children.forEach(child => {
           if ($isListNode(child)) {
@@ -1349,14 +1151,11 @@ function normalizeChildren(nodes) {
       normalizedListItems.push(wrapInListItem(node));
     }
   }
-
   return normalizedListItems;
 }
-
 function convertListNode(domNode) {
   const nodeName = domNode.nodeName.toLowerCase();
   let node = null;
-
   if (nodeName === 'ol') {
     // @ts-ignore
     const start = domNode.start;
@@ -1368,33 +1167,31 @@ function convertListNode(domNode) {
       node = $createListNode('bullet');
     }
   }
-
   return {
     after: normalizeChildren,
     node
   };
 }
-
 const TAG_TO_LIST_TYPE = {
   ol: 'number',
   ul: 'bullet'
 };
+
 /**
  * Creates a ListNode of listType.
  * @param listType - The type of list to be created. Can be 'number', 'bullet', or 'check'.
  * @param start - Where an ordered list starts its count, start = 1 if left undefined.
  * @returns The new ListNode
  */
-
 function $createListNode(listType, start = 1) {
   return lexical.$applyNodeReplacement(new ListNode(listType, start));
 }
+
 /**
  * Checks to see if the node is a ListNode.
  * @param node - The node to be checked.
  * @returns true if the node is a ListNode, false otherwise.
  */
-
 function $isListNode(node) {
   return node instanceof ListNode;
 }