@lexical/list 0.1.7 → 0.1.8

package/LexicalList.dev.js

@@ -0,0 +1,991 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';
+
+var list = require('@lexical/list');
+var lexical = require('lexical');
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function $getNearestNodeOfType(node, klass) {
+  let parent = node;
+
+  while (parent != null) {
+    if (parent instanceof klass) {
+      return parent;
+    }
+
+    parent = parent.getParent();
+  }
+
+  return parent;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function $getListDepth(listNode) {
+  let depth = 1;
+  let parent = listNode.getParent();
+
+  while (parent != null) {
+    if (list.$isListItemNode(parent)) {
+      const parentList = parent.getParent();
+
+      if (list.$isListNode(parentList)) {
+        depth++;
+        parent = parentList.getParent();
+        continue;
+      }
+
+      {
+        throw Error(`A ListItemNode must have a ListNode for a parent.`);
+      }
+    }
+
+    return depth;
+  }
+
+  return depth;
+}
+function $getTopListNode(listItem) {
+  let list$1 = listItem.getParent();
+
+  if (!list.$isListNode(list$1)) {
+    {
+      throw Error(`A ListItemNode must have a ListNode for a parent.`);
+    }
+  }
+
+  let parent = list$1;
+
+  while (parent !== null) {
+    parent = parent.getParent();
+
+    if (list.$isListNode(parent)) {
+      list$1 = parent;
+    }
+  }
+
+  return list$1;
+}
+function $isLastItemInList(listItem) {
+  let isLast = true;
+  const firstChild = listItem.getFirstChild();
+
+  if (list.$isListNode(firstChild)) {
+    return false;
+  }
+
+  let parent = listItem;
+
+  while (parent !== null) {
+    if (list.$isListItemNode(parent)) {
+      if (parent.getNextSiblings().length > 0) {
+        isLast = false;
+      }
+    }
+
+    parent = parent.getParent();
+  }
+
+  return isLast;
+} // This should probably be $getAllChildrenOfType
+
+function $getAllListItems(node) {
+  let listItemNodes = []; //$FlowFixMe - the result of this will always be an array of ListItemNodes.
+
+  const listChildren = node.getChildren().filter(list.$isListItemNode);
+
+  for (let i = 0; i < listChildren.length; i++) {
+    const listItemNode = listChildren[i];
+    const firstChild = listItemNode.getFirstChild();
+
+    if (list.$isListNode(firstChild)) {
+      listItemNodes = listItemNodes.concat($getAllListItems(firstChild));
+    } else {
+      listItemNodes.push(listItemNode);
+    }
+  }
+
+  return listItemNodes;
+}
+function isNestedListNode(node) {
+  return list.$isListItemNode(node) && list.$isListNode(node.getFirstChild());
+}
+function findNearestListItemNode(node) {
+  let currentNode = node;
+
+  while (currentNode !== null) {
+    if (list.$isListItemNode(currentNode)) {
+      return currentNode;
+    }
+
+    currentNode = currentNode.getParent();
+  }
+
+  return null;
+}
+function getUniqueListItemNodes(nodeList) {
+  const keys = new Set();
+
+  for (let i = 0; i < nodeList.length; i++) {
+    const node = nodeList[i];
+
+    if (list.$isListItemNode(node)) {
+      keys.add(node);
+    }
+  }
+
+  return Array.from(keys);
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function insertList(editor, listType) {
+  editor.update(() => {
+    lexical.$log('formatList');
+    const selection = lexical.$getSelection();
+
+    if (selection !== null) {
+      const nodes = selection.getNodes();
+      const anchor = selection.anchor;
+      const anchorNode = anchor.getNode();
+      const anchorNodeParent = anchorNode.getParent(); // This is a special case for when there's nothing selected
+
+      if (nodes.length === 0) {
+        const list$1 = list.$createListNode(listType);
+
+        if (lexical.$isRootNode(anchorNodeParent)) {
+          anchorNode.replace(list$1);
+          const listItem = list.$createListItemNode();
+          list$1.append(listItem);
+        } else if (list.$isListItemNode(anchorNode)) {
+          const parent = anchorNode.getParentOrThrow();
+          list$1.append(...parent.getChildren());
+          parent.replace(list$1);
+        }
+
+        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 (list.$isListNode(parent)) {
+                if (!handled.has(parentKey)) {
+                  const newListNode = list.$createListNode(listType);
+                  newListNode.append(...parent.getChildren());
+                  parent.replace(newListNode);
+                  handled.add(parentKey);
+                }
+
+                break;
+              } else {
+                const nextParent = parent.getParent();
+
+                if (lexical.$isRootNode(nextParent) && !handled.has(parentKey)) {
+                  handled.add(parentKey);
+                  createListOrMerge(parent, listType);
+                  break;
+                }
+
+                parent = nextParent;
+              }
+            }
+          }
+        }
+      }
+    }
+  });
+}
+
+function createListOrMerge(node, listType) {
+  if (list.$isListNode(node)) {
+    return node;
+  }
+
+  const previousSibling = node.getPreviousSibling();
+  const nextSibling = node.getNextSibling();
+  const listItem = list.$createListItemNode();
+
+  if (list.$isListNode(previousSibling) && listType === previousSibling.getTag()) {
+    listItem.append(node);
+    previousSibling.append(listItem); // if the same type of list is on both sides, merge them.
+
+    if (list.$isListNode(nextSibling) && listType === nextSibling.getTag()) {
+      previousSibling.append(...nextSibling.getChildren());
+      nextSibling.remove();
+    }
+
+    return previousSibling;
+  } else if (list.$isListNode(nextSibling) && listType === nextSibling.getTag()) {
+    listItem.append(node);
+    nextSibling.getFirstChildOrThrow().insertBefore(listItem);
+    return nextSibling;
+  } else {
+    const list$1 = list.$createListNode(listType);
+    list$1.append(listItem);
+    node.replace(list$1);
+    listItem.append(node);
+    return list$1;
+  }
+}
+
+function removeList(editor) {
+  editor.update(() => {
+    lexical.$log('removeList');
+    const selection = lexical.$getSelection();
+
+    if (selection !== null) {
+      const listNodes = new Set();
+      const nodes = selection.getNodes();
+      const anchorNode = selection.anchor.getNode();
+
+      if (nodes.length === 0 && list.$isListItemNode(anchorNode)) {
+        listNodes.add($getTopListNode(anchorNode));
+      } else {
+        for (let i = 0; i < nodes.length; i++) {
+          const node = nodes[i];
+
+          if (lexical.$isLeafNode(node)) {
+            const listItemNode = $getNearestNodeOfType(node, list.ListItemNode);
+
+            if (listItemNode != null) {
+              listNodes.add($getTopListNode(listItemNode));
+            }
+          }
+        }
+      }
+
+      listNodes.forEach(listNode => {
+        let insertionPoint = listNode;
+        const listItems = $getAllListItems(listNode);
+        listItems.forEach(listItemNode => {
+          if (listItemNode != null) {
+            const paragraph = lexical.$createParagraphNode();
+            paragraph.append(...listItemNode.getChildren());
+            insertionPoint.insertAfter(paragraph);
+            insertionPoint = paragraph;
+            listItemNode.remove();
+          }
+        });
+        listNode.remove();
+      });
+    }
+  });
+}
+function $handleIndent(listItemNodes) {
+  // go through each node and decide where to move it.
+  listItemNodes.forEach(listItemNode => {
+    if (isNestedListNode(listItemNode)) {
+      return;
+    }
+
+    const parent = listItemNode.getParent();
+    const nextSibling = listItemNode.getNextSibling();
+    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 (list.$isListNode(innerList)) {
+        innerList.append(listItemNode);
+        const nextInnerList = nextSibling.getFirstChild();
+
+        if (list.$isListNode(nextInnerList)) {
+          const children = nextInnerList.getChildren();
+          innerList.append(...children);
+          nextInnerList.remove();
+        }
+
+        innerList.getChildren().forEach(child => child.markDirty());
+      }
+    } else if (isNestedListNode(nextSibling)) {
+      // if the ListItemNode is next to a nested ListNode, merge them
+      const innerList = nextSibling.getFirstChild();
+
+      if (list.$isListNode(innerList)) {
+        const firstChild = innerList.getFirstChild();
+
+        if (firstChild !== null) {
+          firstChild.insertBefore(listItemNode);
+        }
+
+        innerList.getChildren().forEach(child => child.markDirty());
+      }
+    } else if (isNestedListNode(previousSibling)) {
+      const innerList = previousSibling.getFirstChild();
+
+      if (list.$isListNode(innerList)) {
+        innerList.append(listItemNode);
+        innerList.getChildren().forEach(child => child.markDirty());
+      }
+    } else {
+      // otherwise, we need to create a new nested ListNode
+      if (list.$isListNode(parent)) {
+        const newListItem = list.$createListItemNode();
+        const newList = list.$createListNode(parent.getTag());
+        newListItem.append(newList);
+        newList.append(listItemNode);
+
+        if (previousSibling) {
+          previousSibling.insertAfter(newListItem);
+        } else if (nextSibling) {
+          nextSibling.insertBefore(newListItem);
+        } else {
+          parent.append(newListItem);
+        }
+      }
+    }
+
+    if (list.$isListNode(parent)) {
+      parent.getChildren().forEach(child => child.markDirty());
+    }
+  });
+}
+function $handleOutdent(listItemNodes) {
+  // go through each node and decide where to move it.
+  listItemNodes.forEach(listItemNode => {
+    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.
+
+    if (list.$isListNode(greatGrandparentList) && list.$isListItemNode(grandparentListItem) && list.$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
+        // great grandparent list after the grandparent.
+
+      } else if (listItemNode.is(lastChild)) {
+        grandparentListItem.insertAfter(listItemNode);
+
+        if (parentList.isEmpty()) {
+          grandparentListItem.remove();
+        }
+      } else {
+        // otherwise, we need to split the siblings into two new nested lists
+        const tag = parentList.getTag();
+        const previousSiblingsListItem = list.$createListItemNode();
+        const previousSiblingsList = list.$createListNode(tag);
+        previousSiblingsListItem.append(previousSiblingsList);
+        listItemNode.getPreviousSiblings().forEach(sibling => previousSiblingsList.append(sibling));
+        const nextSiblingsListItem = list.$createListItemNode();
+        const nextSiblingsList = list.$createListNode(tag);
+        nextSiblingsListItem.append(nextSiblingsList);
+        nextSiblingsList.append(...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.replace(listItemNode);
+      }
+
+      parentList.getChildren().forEach(child => child.markDirty());
+      greatGrandparentList.getChildren().forEach(child => child.markDirty());
+    }
+  });
+}
+
+function maybeIndentOrOutdent(direction) {
+  const selection = lexical.$getSelection();
+
+  if (selection === null) {
+    return false;
+  }
+
+  const selectedNodes = selection.getNodes();
+  let listItemNodes = [];
+
+  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 ListItemNode
+    const nearestListItemNode = findNearestListItemNode(selectedNodes[0]);
+
+    if (nearestListItemNode !== null) {
+      listItemNodes = [nearestListItemNode];
+    }
+  } else {
+    listItemNodes = getUniqueListItemNodes(selectedNodes);
+  }
+
+  if (listItemNodes.length > 0) {
+    if (direction === 'indent') {
+      $handleIndent(listItemNodes);
+    } else {
+      $handleOutdent(listItemNodes);
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
+function indentList() {
+  return maybeIndentOrOutdent('indent');
+}
+function outdentList() {
+  return maybeIndentOrOutdent('outdent');
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+function addClassNamesToElement(element, ...classNames) {
+  classNames.forEach(className => {
+    if (className != null && typeof className === 'string') {
+      element.classList.add(...className.split(' '));
+    }
+  });
+}
+function removeClassNamesFromElement(element, ...classNames) {
+  classNames.forEach(className => {
+    element.classList.remove(...className.split(' '));
+  });
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+class ListItemNode extends lexical.ElementNode {
+  static getType() {
+    return 'listitem';
+  }
+
+  static clone(node) {
+    return new ListItemNode(node.__key);
+  }
+
+  constructor(key) {
+    super(key);
+  } // View
+
+
+  createDOM(config) {
+    const element = document.createElement('li');
+    element.value = getListItemValue(this);
+    $setListItemThemeClassNames(element, config.theme, this);
+    return element;
+  }
+
+  updateDOM(prevNode, dom, config) {
+    //$FlowFixMe - this is always HTMLListItemElement
+    dom.value = getListItemValue(this);
+    $setListItemThemeClassNames(dom, config.theme, this);
+    return false;
+  } // Mutation
+
+
+  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);
+        node.remove();
+      } else {
+        super.append(node);
+      }
+    }
+
+    return this;
+  }
+
+  replace(replaceWithNode) {
+    if ($isListItemNode(replaceWithNode)) {
+      return super.replace(replaceWithNode);
+    }
+
+    const list$1 = this.getParentOrThrow();
+
+    if (list.$isListNode(list$1)) {
+      const childrenKeys = list$1.__children;
+      const childrenLength = childrenKeys.length;
+      const index = childrenKeys.indexOf(this.__key);
+
+      if (index === 0) {
+        list$1.insertBefore(replaceWithNode);
+      } else if (index === childrenLength - 1) {
+        list$1.insertAfter(replaceWithNode);
+      } else {
+        // Split the list
+        const newList = list.$createListNode(list$1.__tag);
+        const children = list$1.getChildren();
+
+        for (let i = index + 1; i < childrenLength; i++) {
+          const child = children[i];
+          newList.append(child);
+        }
+
+        list$1.insertAfter(replaceWithNode);
+        replaceWithNode.insertAfter(newList);
+      }
+
+      this.remove();
+
+      if (childrenLength === 1) {
+        list$1.remove();
+      }
+    }
+
+    return replaceWithNode;
+  }
+
+  insertAfter(node) {
+    const siblings = this.getNextSiblings();
+
+    if ($isListItemNode(node)) {
+      // mark subsequent list items dirty so we update their value attribute.
+      siblings.forEach(sibling => sibling.markDirty());
+      return super.insertAfter(node);
+    }
+
+    const listNode = this.getParentOrThrow();
+
+    if (!list.$isListNode(listNode)) {
+      {
+        throw Error(`insertAfter: list node is not parent of list item node`);
+      }
+    } // Attempt to merge tables if the list is of the same type.
+
+
+    if (list.$isListNode(node) && node.getTag() === listNode.getTag()) {
+      let child = node;
+      const children = node.getChildren();
+
+      for (let i = children.length - 1; i >= 0; i--) {
+        child = children[i];
+        this.insertAfter(child);
+      }
+
+      return child;
+    } // Otherwise, split the list
+    // Split the lists and insert the node in between them
+
+
+    listNode.insertAfter(node);
+
+    if (siblings.length !== 0) {
+      const newListNode = list.$createListNode(listNode.getTag());
+      siblings.forEach(sibling => newListNode.append(sibling));
+      node.insertAfter(newListNode);
+    }
+
+    return node;
+  }
+
+  insertNewAfter() {
+    const nextSibling = this.getNextSibling();
+    const prevSibling = this.getPreviousSibling();
+    const list$1 = $getTopListNode(this);
+    const isLast = $isLastItemInList(this);
+    let newElement;
+
+    if (lexical.$isElementNode(list$1) && this.getTextContent() === '' && (prevSibling === null || nextSibling === null) && isLast) {
+      if (nextSibling === null) {
+        newElement = lexical.$createParagraphNode();
+        list$1.insertAfter(newElement);
+      } else {
+        newElement = lexical.$createParagraphNode();
+        list$1.insertBefore(newElement);
+      } // The naive approach would be to remove this list item and then the list, if it's empty.
+      // However, nodes may be repeatedly indented, to create deeply nested lists that each
+      // contain just one bullet.
+      // Our goal is to remove these (now-empty) deeply nested lists. The easiest way to do that
+      // is crawl back up the tree until we find a node that has siblings (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 = this;
+
+      while (emptyListPtr.getNextSibling() == null && emptyListPtr.getPreviousSibling() == null) {
+        const parent = emptyListPtr.getParent();
+
+        if (parent == null || !($isListItemNode(emptyListPtr) || list.$isListNode(emptyListPtr))) {
+          break;
+        }
+
+        emptyListPtr = parent;
+      }
+
+      emptyListPtr.remove();
+    } else {
+      newElement = $createListItemNode();
+      this.insertAfter(newElement);
+    }
+
+    return newElement;
+  }
+
+  collapseAtStart(selection) {
+    const paragraph = lexical.$createParagraphNode();
+    const children = this.getChildren();
+    children.forEach(child => paragraph.append(child));
+    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,
+        // effectively unindenting it.
+        listNode.remove();
+        listNodeParent.select();
+      } else {
+        listNode.replace(paragraph); // 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');
+        }
+      }
+    } else {
+      listNode.insertBefore(paragraph);
+      this.remove();
+    }
+
+    return true;
+  }
+
+  getIndent() {
+    // ListItemNode should always have a ListNode for a parent.
+    let listNodeParent = this.getParentOrThrow().getParentOrThrow();
+    let indentLevel = 0;
+
+    while ($isListItemNode(listNodeParent)) {
+      listNodeParent = listNodeParent.getParentOrThrow().getParentOrThrow();
+      indentLevel++;
+    }
+
+    return indentLevel;
+  }
+
+  setIndent(indent) {
+    let currentIndent = this.getIndent();
+
+    while (currentIndent !== indent) {
+      if (currentIndent < indent) {
+        $handleIndent([this]);
+        currentIndent++;
+      } else {
+        $handleOutdent([this]);
+        currentIndent--;
+      }
+    }
+
+    return this;
+  }
+
+  insertBefore(nodeToInsert) {
+    const siblings = this.getNextSiblings();
+
+    if ($isListItemNode(nodeToInsert)) {
+      // mark subsequent list items dirty so we update their value attribute.
+      siblings.forEach(sibling => sibling.markDirty());
+    }
+
+    return super.insertBefore(nodeToInsert);
+  }
+
+  canInsertAfter(node) {
+    return $isListItemNode(node);
+  }
+
+  canReplaceWith(replacement) {
+    return $isListItemNode(replacement);
+  }
+
+  canMergeWith(node) {
+    return lexical.$isParagraphNode(node) || $isListItemNode(node);
+  }
+
+}
+
+function getListItemValue(listItem) {
+  const list$1 = listItem.getParent();
+  let value = 1;
+
+  if (list$1 != null) {
+    if (!list.$isListNode(list$1)) {
+      {
+        throw Error(`getListItemValue: list node is not parent of list item node`);
+      }
+    } else {
+      value = list$1.__start;
+    }
+  }
+
+  const siblings = listItem.getPreviousSiblings();
+
+  for (let i = 0; i < siblings.length; i++) {
+    const sibling = siblings[i];
+
+    if ($isListItemNode(sibling) && !list.$isListNode(sibling.getFirstChild())) {
+      value++;
+    }
+  }
+
+  return value;
+}
+
+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 (nestedListItemClassName !== undefined) {
+    const nestedListItemClasses = nestedListItemClassName.split(' ');
+
+    if (node.getChildren().some(child => list.$isListNode(child))) {
+      classesToAdd.push(...nestedListItemClasses);
+    } else {
+      classesToRemove.push(...nestedListItemClasses);
+    }
+  }
+
+  if (classesToAdd.length > 0) {
+    addClassNamesToElement(dom, ...classesToAdd);
+  }
+
+  if (classesToRemove.length > 0) {
+    removeClassNamesFromElement(dom, ...classesToRemove);
+  }
+}
+
+function $createListItemNode() {
+  return new ListItemNode();
+}
+function $isListItemNode(node) {
+  return node instanceof ListItemNode;
+}
+
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * 
+ */
+class ListNode extends lexical.ElementNode {
+  static getType() {
+    return 'list';
+  }
+
+  static clone(node) {
+    return new ListNode(node.__tag, node.__start, node.__key);
+  }
+
+  constructor(tag, start, key) {
+    super(key);
+    this.__tag = tag;
+    this.__start = start;
+  }
+
+  getTag() {
+    return this.__tag;
+  } // View
+
+
+  createDOM(config) {
+    const tag = this.__tag;
+    const dom = document.createElement(tag);
+
+    if (this.__start !== 1) {
+      dom.setAttribute('start', String(this.__start));
+    }
+
+    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;
+  }
+
+  canBeEmpty() {
+    return false;
+  }
+
+  append(...nodesToAppend) {
+    for (let i = 0; i < nodesToAppend.length; i++) {
+      const currentNode = nodesToAppend[i];
+
+      if (list.$isListItemNode(currentNode)) {
+        super.append(currentNode);
+      } else {
+        const listItemNode = list.$createListItemNode();
+
+        if ($isListNode(currentNode)) {
+          listItemNode.append(currentNode);
+        } else {
+          const textNode = lexical.$createTextNode(currentNode.getTextContent());
+          listItemNode.append(textNode);
+        }
+
+        super.append(listItemNode);
+      }
+    }
+
+    return this;
+  }
+
+}
+
+function setListThemeClassNames(dom, editorThemeClasses, node) {
+  const classesToAdd = [];
+  const classesToRemove = [];
+  const listTheme = editorThemeClasses.list;
+
+  if (listTheme !== undefined) {
+    const listDepth = $getListDepth(node);
+    const normalizedListDepth = listDepth % 5;
+    const listThemeLevel = normalizedListDepth === 0 ? 5 : normalizedListDepth;
+    const listThemeLevelClassName = node.__tag + listThemeLevel;
+    const listLevelClassName = listTheme[listThemeLevelClassName];
+    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 = 1; i < 6; i++) {
+        if (i !== normalizedListDepth) {
+          classesToRemove.push(node.__tag + i);
+        }
+      }
+    }
+
+    if (nestedListClassName !== undefined) {
+      const nestedListItemClasses = nestedListClassName.split(' ');
+
+      if (listDepth > 1) {
+        classesToAdd.push(...nestedListItemClasses);
+      } else {
+        classesToRemove.push(...nestedListItemClasses);
+      }
+    }
+  }
+
+  if (classesToAdd.length > 0) {
+    addClassNamesToElement(dom, ...classesToAdd);
+  }
+
+  if (classesToRemove.length > 0) {
+    removeClassNamesFromElement(dom, ...classesToRemove);
+  }
+}
+
+function $createListNode(tag, start = 1) {
+  return new ListNode(tag, start);
+}
+function $isListNode(node) {
+  return node instanceof ListNode;
+}
+
+exports.$createListItemNode = $createListItemNode;
+exports.$createListNode = $createListNode;
+exports.$isListItemNode = $isListItemNode;
+exports.$isListNode = $isListNode;
+exports.ListItemNode = ListItemNode;
+exports.ListNode = ListNode;
+exports.indentList = indentList;
+exports.insertList = insertList;
+exports.outdentList = outdentList;
+exports.removeList = removeList;

package/LexicalList.js

@@ -1,23 +1,9 @@
-'use strict';var f=require("lexical"),k=require("@lexical/list");function n(c,...a){a.forEach(b=>{null!=b&&"string"===typeof b&&c.classList.add(...b.split(" "))})}function p(c,...a){a.forEach(b=>{c.classList.remove(...b.split(" "))})}function r(c){throw Error(`Minified Lexical error #${c}; see codes.json for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}
-function t(c){c=c.getParent();k.$isListNode(c)||r(2);let a=c;for(;null!==a;)a=a.getParent(),k.$isListNode(a)&&(c=a);return c}function u(c){let a=[];c=c.getChildren().filter(k.$isListItemNode);for(let b=0;b<c.length;b++){const d=c[b],e=d.getFirstChild();k.$isListNode(e)?a=a.concat(u(e)):a.push(d)}return a}function v(c){return k.$isListItemNode(c)&&k.$isListNode(c.getFirstChild())}
-class w extends f.ElementNode{static getType(){return"list"}static clone(c){return new w(c.__tag,c.__start,c.__key)}constructor(c,a,b){super(b);this.__tag=c;this.__start=a}getTag(){return this.__tag}createDOM(c){const a=document.createElement(this.__tag);1!==this.__start&&a.setAttribute("start",String(this.__start));x(a,c.theme,this);return a}updateDOM(c,a,b){if(c.__tag!==this.__tag)return!0;x(a,b.theme,this);return!1}canBeEmpty(){return!1}append(...c){for(let b=0;b<c.length;b++){var a=c[b];if(k.$isListItemNode(a))super.append(a);
-else{const d=k.$createListItemNode();y(a)?d.append(a):(a=f.$createTextNode(a.getTextContent()),d.append(a));super.append(d)}}return this}}
-function x(c,a,b){const d=[],e=[];a=a.list;if(void 0!==a){a:{var g=1;for(var h=b.getParent();null!=h;){if(k.$isListItemNode(h)){h=h.getParent();if(k.$isListNode(h)){g++;h=h.getParent();continue}r(2)}break a}}h=g%5;const l=a[b.__tag+(0===h?5:h)],m=a[b.__tag];let q;a=a.nested;void 0!==a&&a.list&&(q=a.list);void 0!==m&&d.push(m);if(void 0!==l)for(a=l.split(" "),d.push(...a),a=1;6>a;a++)a!==h&&e.push(b.__tag+a);void 0!==q&&(b=q.split(" "),1<g?d.push(...b):e.push(...b))}0<d.length&&n(c,...d);0<e.length&&
-p(c,...e)}function y(c){return c instanceof w}
-class z extends f.ElementNode{static getType(){return"listitem"}static clone(c){return new z(c.__key)}constructor(c){super(c)}createDOM(c){const a=document.createElement("li");a.value=A(this);B(a,c.theme,this);return a}updateDOM(c,a,b){a.value=A(this);B(a,b.theme,this);return!1}append(...c){for(let a=0;a<c.length;a++){const b=c[a];if(f.$isElementNode(b)&&this.canMergeWith(b)){const d=b.getChildren();this.append(...d);b.remove()}else super.append(b)}return this}replace(c){if(C(c))return super.replace(c);const a=
-this.getParentOrThrow();if(k.$isListNode(a)){var b=a.__children;const e=b.length;var d=b.indexOf(this.__key);if(0===d)a.insertBefore(c);else if(d===e-1)a.insertAfter(c);else{b=k.$createListNode(a.__tag);const g=a.getChildren();for(d+=1;d<e;d++)b.append(g[d]);a.insertAfter(c);c.insertAfter(b)}this.remove();1===e&&a.remove()}return c}insertAfter(c){var a=this.getNextSiblings();if(C(c))return a.forEach(d=>d.markDirty()),super.insertAfter(c);var b=this.getParentOrThrow();k.$isListNode(b)||r(1);if(k.$isListNode(c)&&
-c.getTag()===b.getTag()){a=c;c=c.getChildren();for(b=c.length-1;0<=b;b--)a=c[b],this.insertAfter(a);return a}b.insertAfter(c);if(0!==a.length){const d=k.$createListNode(b.getTag());a.forEach(e=>d.append(e));c.insertAfter(d)}return c}insertNewAfter(){var c=this.getNextSibling(),a=this.getPreviousSibling(),b=t(this);var d=!0;var e=this.getFirstChild();if(k.$isListNode(e))d=!1;else for(e=this;null!==e;)k.$isListItemNode(e)&&0<e.getNextSiblings().length&&(d=!1),e=e.getParent();if(f.$isElementNode(b)&&
-""===this.getTextContent()&&(null===a||null===c)&&d){null===c?(c=f.$createParagraphNode(),b.insertAfter(c)):(c=f.$createParagraphNode(),b.insertBefore(c));for(b=this;null==b.getNextSibling()&&null==b.getPreviousSibling();){a=b.getParent();if(null==a||!C(b)&&!k.$isListNode(b))break;b=a}b.remove()}else c=D(),this.insertAfter(c);return c}collapseAtStart(c){const a=f.$createParagraphNode();this.getChildren().forEach(g=>a.append(g));var b=this.getParentOrThrow(),d=b.getParentOrThrow();const e=C(d);1===
-b.getChildrenSize()?e?(b.remove(),d.select()):(b.replace(a),b=c.anchor,c=c.focus,d=a.getKey(),"element"===b.type&&b.getNode().is(this)&&b.set(d,b.offset,"element"),"element"===c.type&&c.getNode().is(this)&&c.set(d,c.offset,"element")):(b.insertBefore(a),this.remove());return!0}getIndent(){let c=this.getParentOrThrow().getParentOrThrow(),a=0;for(;C(c);)c=c.getParentOrThrow().getParentOrThrow(),a++;return a}setIndent(){return this}insertBefore(c){const a=this.getNextSiblings();C(c)&&a.forEach(b=>b.markDirty());
-return super.insertBefore(c)}canInsertAfter(c){return C(c)}canReplaceWith(c){return C(c)}canMergeWith(c){return f.$isParagraphNode(c)||C(c)}}function A(c){var a=c.getParent();let b=1;null!=a&&(k.$isListNode(a)?b=a.__start:r(47));c=c.getPreviousSiblings();for(a=0;a<c.length;a++){const d=c[a];C(d)&&!k.$isListNode(d.getFirstChild())&&b++}return b}
-function B(c,a,b){const d=[],e=[],g=(a=a.list)?a.listitem:void 0;if(a&&a.nested)var h=a.nested.listitem;void 0!==g&&(a=g.split(" "),d.push(...a));void 0!==h&&(h=h.split(" "),b.getChildren().some(l=>k.$isListNode(l))?d.push(...h):e.push(...h));0<d.length&&n(c,...d);0<e.length&&p(c,...e)}function D(){return new z}function C(c){return c instanceof z}function E(c,a){for(;null!=c&&!(c instanceof a);)c=c.getParent();return c}
-function F(c,a){if(k.$isListNode(c))return c;const b=c.getPreviousSibling(),d=c.getNextSibling(),e=k.$createListItemNode();if(k.$isListNode(b)&&a===b.getTag())return e.append(c),b.append(e),k.$isListNode(d)&&a===d.getTag()&&(b.append(...d.getChildren()),d.remove()),b;if(k.$isListNode(d)&&a===d.getTag())return e.append(c),d.getFirstChildOrThrow().insertBefore(e),d;a=k.$createListNode(a);a.append(e);c.replace(a);e.append(c);return a}
-function G(c){c.forEach(a=>{if(!v(a)){var b=a.getParent(),d=a.getNextSibling(),e=a.getPreviousSibling();if(v(d)&&v(e))e=e.getFirstChild(),k.$isListNode(e)&&(e.append(a),a=d.getFirstChild(),k.$isListNode(a)&&(d=a.getChildren(),e.append(...d),a.remove()),e.getChildren().forEach(g=>g.markDirty()));else if(v(d))d=d.getFirstChild(),k.$isListNode(d)&&(e=d.getFirstChild(),null!==e&&e.insertBefore(a),d.getChildren().forEach(g=>g.markDirty()));else if(v(e))d=e.getFirstChild(),k.$isListNode(d)&&(d.append(a),
-d.getChildren().forEach(g=>g.markDirty()));else if(k.$isListNode(b)){const g=k.$createListItemNode(),h=k.$createListNode(b.getTag());g.append(h);h.append(a);e?e.insertAfter(g):d?d.insertBefore(g):b.append(g)}k.$isListNode(b)&&b.getChildren().forEach(g=>g.markDirty())}})}
-function H(c){c.forEach(a=>{if(!v(a)){var b=a.getParent(),d=b?b.getParent():void 0,e=d?d.getParent():void 0;if(k.$isListNode(e)&&k.$isListItemNode(d)&&k.$isListNode(b)){var g=b?b.getFirstChild():void 0,h=b?b.getLastChild():void 0;if(a.is(g))d.insertBefore(a),b.isEmpty()&&d.remove();else if(a.is(h))d.insertAfter(a),b.isEmpty()&&d.remove();else{var l=b.getTag();g=k.$createListItemNode();const m=k.$createListNode(l);g.append(m);a.getPreviousSiblings().forEach(q=>m.append(q));h=k.$createListItemNode();
-l=k.$createListNode(l);h.append(l);l.append(...a.getNextSiblings());d.insertBefore(g);d.insertAfter(h);d.replace(a)}b.getChildren().forEach(m=>m.markDirty());e.getChildren().forEach(m=>m.markDirty())}}})}
-function I(c){var a=f.$getSelection();if(null===a)return!1;var b=a.getNodes(),d=[];0===b.length&&b.push(a.anchor.getNode());if(1===b.length){a:{for(b=b[0];null!==b;){if(k.$isListItemNode(b))break a;b=b.getParent()}b=null}null!==b&&(d=[b])}else{d=new Set;for(a=0;a<b.length;a++){const e=b[a];k.$isListItemNode(e)&&d.add(e)}d=Array.from(d)}return 0<d.length?("indent"===c?G(d):H(d),!0):!1}exports.$createListItemNode=D;exports.$createListNode=function(c,a=1){return new w(c,a)};exports.$isListItemNode=C;
-exports.$isListNode=y;exports.ListItemNode=z;exports.ListNode=w;exports.indentList=function(){return I("indent")};
-exports.insertList=function(c,a){c.update(()=>{f.$log("formatList");var b=f.$getSelection();if(null!==b){var d=b.getNodes();b=b.anchor.getNode();var e=b.getParent();if(0===d.length)d=k.$createListNode(a),f.$isRootNode(e)?(b.replace(d),b=k.$createListItemNode(),d.append(b)):k.$isListItemNode(b)&&(b=b.getParentOrThrow(),d.append(...b.getChildren()),b.replace(d));else for(b=new Set,e=0;e<d.length;e++){var g=d[e];if(f.$isElementNode(g)&&g.isEmpty()&&!b.has(g.getKey()))F(g,a);else if(f.$isLeafNode(g))for(g=
-g.getParent();null!=g;){const l=g.getKey();if(k.$isListNode(g)){if(!b.has(l)){var h=k.$createListNode(a);h.append(...g.getChildren());g.replace(h);b.add(l)}break}else{h=g.getParent();if(f.$isRootNode(h)&&!b.has(l)){b.add(l);F(g,a);break}g=h}}}}})};exports.outdentList=function(){return I("outdent")};
-exports.removeList=function(c){c.update(()=>{f.$log("removeList");var a=f.$getSelection();if(null!==a){const d=new Set,e=a.getNodes();a=a.anchor.getNode();if(0===e.length&&k.$isListItemNode(a))d.add(t(a));else for(a=0;a<e.length;a++){var b=e[a];f.$isLeafNode(b)&&(b=E(b,k.ListItemNode),null!=b&&d.add(t(b)))}d.forEach(g=>{let h=g;u(g).forEach(l=>{if(null!=l){const m=f.$createParagraphNode();m.append(...l.getChildren());h.insertAfter(m);h=m;l.remove()}});g.remove()})}})};
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict'
+const LexicalList = process.env.NODE_ENV === 'development' ? require('./LexicalList.dev.js') : require('./LexicalList.prod.js')
+module.exports = LexicalList;

package/LexicalList.prod.js

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+'use strict';var f=require("@lexical/list"),k=require("lexical");function n(c,a){for(;null!=c&&!(c instanceof a);)c=c.getParent();return c}function p(c){throw Error(`Minified Lexical error #${c}; see codes.json for the full message or `+"use the non-minified dev environment for full errors and additional helpful warnings.");}function r(c){c=c.getParent();f.$isListNode(c)||p(2);let a=c;for(;null!==a;)a=a.getParent(),f.$isListNode(a)&&(c=a);return c}
+function t(c){let a=[];c=c.getChildren().filter(f.$isListItemNode);for(let b=0;b<c.length;b++){const d=c[b],e=d.getFirstChild();f.$isListNode(e)?a=a.concat(t(e)):a.push(d)}return a}function u(c){return f.$isListItemNode(c)&&f.$isListNode(c.getFirstChild())}
+function v(c,a){if(f.$isListNode(c))return c;const b=c.getPreviousSibling(),d=c.getNextSibling(),e=f.$createListItemNode();if(f.$isListNode(b)&&a===b.getTag())return e.append(c),b.append(e),f.$isListNode(d)&&a===d.getTag()&&(b.append(...d.getChildren()),d.remove()),b;if(f.$isListNode(d)&&a===d.getTag())return e.append(c),d.getFirstChildOrThrow().insertBefore(e),d;a=f.$createListNode(a);a.append(e);c.replace(a);e.append(c);return a}
+function w(c){c.forEach(a=>{if(!u(a)){var b=a.getParent(),d=a.getNextSibling(),e=a.getPreviousSibling();if(u(d)&&u(e))e=e.getFirstChild(),f.$isListNode(e)&&(e.append(a),a=d.getFirstChild(),f.$isListNode(a)&&(d=a.getChildren(),e.append(...d),a.remove()),e.getChildren().forEach(g=>g.markDirty()));else if(u(d))d=d.getFirstChild(),f.$isListNode(d)&&(e=d.getFirstChild(),null!==e&&e.insertBefore(a),d.getChildren().forEach(g=>g.markDirty()));else if(u(e))d=e.getFirstChild(),f.$isListNode(d)&&(d.append(a),
+d.getChildren().forEach(g=>g.markDirty()));else if(f.$isListNode(b)){const g=f.$createListItemNode(),h=f.$createListNode(b.getTag());g.append(h);h.append(a);e?e.insertAfter(g):d?d.insertBefore(g):b.append(g)}f.$isListNode(b)&&b.getChildren().forEach(g=>g.markDirty())}})}
+function x(c){c.forEach(a=>{if(!u(a)){var b=a.getParent(),d=b?b.getParent():void 0,e=d?d.getParent():void 0;if(f.$isListNode(e)&&f.$isListItemNode(d)&&f.$isListNode(b)){var g=b?b.getFirstChild():void 0,h=b?b.getLastChild():void 0;if(a.is(g))d.insertBefore(a),b.isEmpty()&&d.remove();else if(a.is(h))d.insertAfter(a),b.isEmpty()&&d.remove();else{var l=b.getTag();g=f.$createListItemNode();const m=f.$createListNode(l);g.append(m);a.getPreviousSiblings().forEach(q=>m.append(q));h=f.$createListItemNode();
+l=f.$createListNode(l);h.append(l);l.append(...a.getNextSiblings());d.insertBefore(g);d.insertAfter(h);d.replace(a)}b.getChildren().forEach(m=>m.markDirty());e.getChildren().forEach(m=>m.markDirty())}}})}
+function y(c){var a=k.$getSelection();if(null===a)return!1;var b=a.getNodes(),d=[];0===b.length&&b.push(a.anchor.getNode());if(1===b.length){a:{for(b=b[0];null!==b;){if(f.$isListItemNode(b))break a;b=b.getParent()}b=null}null!==b&&(d=[b])}else{d=new Set;for(a=0;a<b.length;a++){const e=b[a];f.$isListItemNode(e)&&d.add(e)}d=Array.from(d)}return 0<d.length?("indent"===c?w(d):x(d),!0):!1}function z(c,...a){a.forEach(b=>{null!=b&&"string"===typeof b&&c.classList.add(...b.split(" "))})}
+function A(c,...a){a.forEach(b=>{c.classList.remove(...b.split(" "))})}
+class B extends k.ElementNode{static getType(){return"listitem"}static clone(c){return new B(c.__key)}constructor(c){super(c)}createDOM(c){const a=document.createElement("li");a.value=C(this);D(a,c.theme,this);return a}updateDOM(c,a,b){a.value=C(this);D(a,b.theme,this);return!1}append(...c){for(let a=0;a<c.length;a++){const b=c[a];if(k.$isElementNode(b)&&this.canMergeWith(b)){const d=b.getChildren();this.append(...d);b.remove()}else super.append(b)}return this}replace(c){if(E(c))return super.replace(c);const a=
+this.getParentOrThrow();if(f.$isListNode(a)){var b=a.__children;const e=b.length;var d=b.indexOf(this.__key);if(0===d)a.insertBefore(c);else if(d===e-1)a.insertAfter(c);else{b=f.$createListNode(a.__tag);const g=a.getChildren();for(d+=1;d<e;d++)b.append(g[d]);a.insertAfter(c);c.insertAfter(b)}this.remove();1===e&&a.remove()}return c}insertAfter(c){var a=this.getNextSiblings();if(E(c))return a.forEach(d=>d.markDirty()),super.insertAfter(c);var b=this.getParentOrThrow();f.$isListNode(b)||p(1);if(f.$isListNode(c)&&
+c.getTag()===b.getTag()){a=c;c=c.getChildren();for(b=c.length-1;0<=b;b--)a=c[b],this.insertAfter(a);return a}b.insertAfter(c);if(0!==a.length){const d=f.$createListNode(b.getTag());a.forEach(e=>d.append(e));c.insertAfter(d)}return c}insertNewAfter(){var c=this.getNextSibling(),a=this.getPreviousSibling(),b=r(this);var d=!0;var e=this.getFirstChild();if(f.$isListNode(e))d=!1;else for(e=this;null!==e;)f.$isListItemNode(e)&&0<e.getNextSiblings().length&&(d=!1),e=e.getParent();if(k.$isElementNode(b)&&
+""===this.getTextContent()&&(null===a||null===c)&&d){null===c?(c=k.$createParagraphNode(),b.insertAfter(c)):(c=k.$createParagraphNode(),b.insertBefore(c));for(b=this;null==b.getNextSibling()&&null==b.getPreviousSibling();){a=b.getParent();if(null==a||!E(b)&&!f.$isListNode(b))break;b=a}b.remove()}else c=F(),this.insertAfter(c);return c}collapseAtStart(c){const a=k.$createParagraphNode();this.getChildren().forEach(g=>a.append(g));var b=this.getParentOrThrow(),d=b.getParentOrThrow();const e=E(d);1===
+b.getChildrenSize()?e?(b.remove(),d.select()):(b.replace(a),b=c.anchor,c=c.focus,d=a.getKey(),"element"===b.type&&b.getNode().is(this)&&b.set(d,b.offset,"element"),"element"===c.type&&c.getNode().is(this)&&c.set(d,c.offset,"element")):(b.insertBefore(a),this.remove());return!0}getIndent(){let c=this.getParentOrThrow().getParentOrThrow(),a=0;for(;E(c);)c=c.getParentOrThrow().getParentOrThrow(),a++;return a}setIndent(c){let a=this.getIndent();for(;a!==c;)a<c?(w([this]),a++):(x([this]),a--);return this}insertBefore(c){const a=
+this.getNextSiblings();E(c)&&a.forEach(b=>b.markDirty());return super.insertBefore(c)}canInsertAfter(c){return E(c)}canReplaceWith(c){return E(c)}canMergeWith(c){return k.$isParagraphNode(c)||E(c)}}function C(c){var a=c.getParent();let b=1;null!=a&&(f.$isListNode(a)?b=a.__start:p(47));c=c.getPreviousSiblings();for(a=0;a<c.length;a++){const d=c[a];E(d)&&!f.$isListNode(d.getFirstChild())&&b++}return b}
+function D(c,a,b){const d=[],e=[],g=(a=a.list)?a.listitem:void 0;if(a&&a.nested)var h=a.nested.listitem;void 0!==g&&(a=g.split(" "),d.push(...a));void 0!==h&&(h=h.split(" "),b.getChildren().some(l=>f.$isListNode(l))?d.push(...h):e.push(...h));0<d.length&&z(c,...d);0<e.length&&A(c,...e)}function F(){return new B}function E(c){return c instanceof B}
+class G extends k.ElementNode{static getType(){return"list"}static clone(c){return new G(c.__tag,c.__start,c.__key)}constructor(c,a,b){super(b);this.__tag=c;this.__start=a}getTag(){return this.__tag}createDOM(c){const a=document.createElement(this.__tag);1!==this.__start&&a.setAttribute("start",String(this.__start));H(a,c.theme,this);return a}updateDOM(c,a,b){if(c.__tag!==this.__tag)return!0;H(a,b.theme,this);return!1}canBeEmpty(){return!1}append(...c){for(let b=0;b<c.length;b++){var a=c[b];if(f.$isListItemNode(a))super.append(a);
+else{const d=f.$createListItemNode();I(a)?d.append(a):(a=k.$createTextNode(a.getTextContent()),d.append(a));super.append(d)}}return this}}
+function H(c,a,b){const d=[],e=[];a=a.list;if(void 0!==a){a:{var g=1;for(var h=b.getParent();null!=h;){if(f.$isListItemNode(h)){h=h.getParent();if(f.$isListNode(h)){g++;h=h.getParent();continue}p(2)}break a}}h=g%5;const l=a[b.__tag+(0===h?5:h)],m=a[b.__tag];let q;a=a.nested;void 0!==a&&a.list&&(q=a.list);void 0!==m&&d.push(m);if(void 0!==l)for(a=l.split(" "),d.push(...a),a=1;6>a;a++)a!==h&&e.push(b.__tag+a);void 0!==q&&(b=q.split(" "),1<g?d.push(...b):e.push(...b))}0<d.length&&z(c,...d);0<e.length&&
+A(c,...e)}function I(c){return c instanceof G}exports.$createListItemNode=F;exports.$createListNode=function(c,a=1){return new G(c,a)};exports.$isListItemNode=E;exports.$isListNode=I;exports.ListItemNode=B;exports.ListNode=G;exports.indentList=function(){return y("indent")};
+exports.insertList=function(c,a){c.update(()=>{k.$log("formatList");var b=k.$getSelection();if(null!==b){var d=b.getNodes();b=b.anchor.getNode();var e=b.getParent();if(0===d.length)d=f.$createListNode(a),k.$isRootNode(e)?(b.replace(d),b=f.$createListItemNode(),d.append(b)):f.$isListItemNode(b)&&(b=b.getParentOrThrow(),d.append(...b.getChildren()),b.replace(d));else for(b=new Set,e=0;e<d.length;e++){var g=d[e];if(k.$isElementNode(g)&&g.isEmpty()&&!b.has(g.getKey()))v(g,a);else if(k.$isLeafNode(g))for(g=
+g.getParent();null!=g;){const l=g.getKey();if(f.$isListNode(g)){if(!b.has(l)){var h=f.$createListNode(a);h.append(...g.getChildren());g.replace(h);b.add(l)}break}else{h=g.getParent();if(k.$isRootNode(h)&&!b.has(l)){b.add(l);v(g,a);break}g=h}}}}})};exports.outdentList=function(){return y("outdent")};
+exports.removeList=function(c){c.update(()=>{k.$log("removeList");var a=k.$getSelection();if(null!==a){const d=new Set,e=a.getNodes();a=a.anchor.getNode();if(0===e.length&&f.$isListItemNode(a))d.add(r(a));else for(a=0;a<e.length;a++){var b=e[a];k.$isLeafNode(b)&&(b=n(b,f.ListItemNode),null!=b&&d.add(r(b)))}d.forEach(g=>{let h=g;t(g).forEach(l=>{if(null!=l){const m=k.$createParagraphNode();m.append(...l.getChildren());h.insertAfter(m);h=m;l.remove()}});g.remove()})}})};

package/package.json

@@ -1,25 +1,25 @@
 {
-    "name": "@lexical/list",
-    "author": {
-      "name": "Dominic Gannaway",
-      "email": "dg@domgan.com"
-    },
-    "description": "This package provides the list feature for Lexical.",
-    "keywords": [
-      "lexical",
-      "editor",
-      "rich-text",
-      "list"
-    ],
-    "license": "MIT",
-    "version": "0.1.7",
-    "main": "LexicalList.js",
-    "peerDependencies": {
-      "lexical": "0.1.7"
-    },
-    "repository": {
-      "type": "git",
-      "url": "https://github.com/facebook/lexical",
-      "directory": "packages/lexical-list"
-    }
+  "name": "@lexical/list",
+  "author": {
+    "name": "Dominic Gannaway",
+    "email": "dg@domgan.com"
+  },
+  "description": "This package provides the list feature for Lexical.",
+  "keywords": [
+    "lexical",
+    "editor",
+    "rich-text",
+    "list"
+  ],
+  "license": "MIT",
+  "version": "0.1.8",
+  "main": "LexicalList.js",
+  "peerDependencies": {
+    "lexical": "0.1.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/facebook/lexical",
+    "directory": "packages/lexical-list"
   }
+}