@webiny/lexical-nodes 5.43.3 → 6.0.0-alpha.1

package/ListItemNode.js

@@ -1,382 +1,306 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.$createListItemNode = $createListItemNode;
-exports.$isListItemNode = $isListItemNode;
-exports.ListItemNode = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _callSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/callSuper"));
-var _superPropGet2 = _interopRequireDefault(require("@babel/runtime/helpers/superPropGet"));
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
-var _lexical = require("lexical");
-var _ListNode = require("./ListNode");
-var _utils = require("@lexical/utils");
-var _formatList = require("./utils/formatList");
-var _ParagraphNode = require("./ParagraphNode");
-var _listNode = require("./utils/listNode");
+import { $isElementNode, $isRangeSelection, ElementNode } from "lexical";
+import { $createListNode, $isListNode } from "./ListNode";
+import { addClassNamesToElement, removeClassNamesFromElement } from "@lexical/utils";
+import { $handleIndent, $handleOutdent, mergeLists, updateChildrenListItemValue } from "./utils/formatList";
+import { $createParagraphNode, $isParagraphNode } from "./ParagraphNode";
+import { isNestedListNode } from "./utils/listNode";
+export const LIST_ITEM_TYPE = "wby-list-item";
 /** @noInheritDoc */
-var ListItemNode = exports.ListItemNode = /*#__PURE__*/function (_ElementNode) {
-  function ListItemNode(value, checked, key) {
-    var _this;
-    (0, _classCallCheck2.default)(this, ListItemNode);
-    _this = (0, _callSuper2.default)(this, ListItemNode, [key]);
-    _this.__value = value === undefined ? 1 : value;
-    _this.__checked = checked;
-    return _this;
-  }
-  (0, _inherits2.default)(ListItemNode, _ElementNode);
-  return (0, _createClass2.default)(ListItemNode, [{
-    key: "createDOM",
-    value: function createDOM(config) {
-      var element = document.createElement("li");
-      var parent = this.getParent();
-      if ((0, _ListNode.$isListNode)(parent) && parent.getListType() === "check") {
-        updateListItemChecked(element, this, null, parent);
-      }
-      element.value = this.__value;
-      $setListItemThemeClassNames(element, config.theme, this);
-      return element;
-    }
-  }, {
-    key: "updateDOM",
-    value: function updateDOM(prevNode, dom, config) {
-      var parent = this.getParent();
-      if ((0, _ListNode.$isListNode)(parent) && parent.getListType() === "check") {
-        updateListItemChecked(dom, this, prevNode, parent);
-      }
-      // @ts-expect-error - this is always HTMLListItemElement
-      dom.value = this.__value;
-      $setListItemThemeClassNames(dom, config.theme, this);
-      return false;
-    }
-  }, {
-    key: "exportJSON",
-    value: function exportJSON() {
-      return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, (0, _superPropGet2.default)(ListItemNode, "exportJSON", this, 3)([])), {}, {
-        checked: this.getChecked(),
-        type: "webiny-listitem",
-        value: this.getValue(),
-        version: 1
-      });
+export class ListItemNode extends ElementNode {
+  /** @internal */
+
+  /** @internal */
+
+  static getType() {
+    return LIST_ITEM_TYPE;
+  }
+  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, parent);
     }
-  }, {
-    key: "append",
-    value: function append() {
-      for (var i = 0; i < arguments.length; i++) {
-        var node = i < 0 || arguments.length <= i ? undefined : arguments[i];
-        if ((0, _lexical.$isElementNode)(node) && this.canMergeWith(node)) {
-          var children = node.getChildren();
-          this.append.apply(this, (0, _toConsumableArray2.default)(children));
-          node.remove();
-        } else {
-          (0, _superPropGet2.default)(ListItemNode, "append", this, 3)([node]);
-        }
-      }
-      return this;
+    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, parent);
     }
-  }, {
-    key: "replace",
-    value: function replace(replaceWithNode, includeChildren) {
-      if ($isListItemNode(replaceWithNode)) {
-        return (0, _superPropGet2.default)(ListItemNode, "replace", this, 3)([replaceWithNode]);
-      }
-      this.setIndent(0);
-      var list = this.getParentOrThrow();
-      if (!(0, _ListNode.$isListNode)(list)) {
-        return replaceWithNode;
-      }
-      if (list.__first === this.getKey()) {
-        list.insertBefore(replaceWithNode);
-      } else if (list.__last === this.getKey()) {
-        list.insertAfter(replaceWithNode);
+    // @ts-expect-error - this is always HTMLListItemElement
+    dom.value = this.__value;
+    $setListItemThemeClassNames(dom, config.theme, this);
+    return false;
+  }
+  static importDOM() {
+    return {
+      li: () => ({
+        conversion: convertListItemElement,
+        priority: 0
+      })
+    };
+  }
+  static importJSON(serializedNode) {
+    const node = new ListItemNode(serializedNode.value, serializedNode.checked);
+    node.setFormat(serializedNode.format);
+    node.setIndent(serializedNode.indent);
+    node.setDirection(serializedNode.direction);
+    return node;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      checked: this.getChecked(),
+      type: LIST_ITEM_TYPE,
+      value: this.getValue()
+    };
+  }
+  append(...nodes) {
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if ($isElementNode(node) && this.canMergeWith(node)) {
+        const children = node.getChildren();
+        this.append(...children);
+        node.remove();
       } else {
-        // Split the list
-        var newList = (0, _ListNode.$createListNode)(list.getListType());
-        var nextSibling = this.getNextSibling();
-        while (nextSibling) {
-          var nodeToAppend = nextSibling;
-          nextSibling = nextSibling.getNextSibling();
-          newList.append(nodeToAppend);
-        }
-        list.insertAfter(replaceWithNode);
-        replaceWithNode.insertAfter(newList);
-      }
-      if (includeChildren) {
-        if (!(0, _lexical.$isElementNode)(replaceWithNode)) {
-          throw Error("includeChildren should only be true for ElementNodes");
-        }
-        this.getChildren().forEach(function (child) {
-          replaceWithNode.append(child);
-        });
-      }
-      this.remove();
-      if (list.getChildrenSize() === 0) {
-        list.remove();
+        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;
     }
-  }, {
-    key: "insertAfter",
-    value: function insertAfter(node) {
-      var listNode = this.getParentOrThrow();
-      if (!(0, _ListNode.$isListNode)(listNode)) {
-        console.log("insertAfter: webiny list node is not parent of list item node");
-        return listNode;
-      }
-      var siblings = this.getNextSiblings();
-      if ($isListItemNode(node)) {
-        var after = (0, _superPropGet2.default)(ListItemNode, "insertAfter", this, 3)([node]);
-        var afterListNode = node.getParentOrThrow();
-        if ((0, _ListNode.$isListNode)(afterListNode)) {
-          (0, _formatList.updateChildrenListItemValue)(afterListNode);
-        }
-        return after;
-      }
-
-      // Attempt to merge if the list is of the same type.
-
-      if ((0, _ListNode.$isListNode)(node) && node.getListType() === listNode.getListType()) {
-        var child = node;
-        var children = node.getChildren();
-        for (var 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) {
-        var newListNode = (0, _ListNode.$createListNode)(listNode.getListType());
-        siblings.forEach(function (sibling) {
-          return newListNode.append(sibling);
-        });
-        node.insertAfter(newListNode);
+    if (list.__first === this.getKey()) {
+      list.insertBefore(replaceWithNode);
+    } else if (list.__last === this.getKey()) {
+      list.insertAfter(replaceWithNode);
+    } else {
+      // Split the list
+      const newList = $createListNode(list.getListType());
+      let nextSibling = this.getNextSibling();
+      while (nextSibling) {
+        const nodeToAppend = nextSibling;
+        nextSibling = nextSibling.getNextSibling();
+        newList.append(nodeToAppend);
       }
-      return node;
+      list.insertAfter(replaceWithNode);
+      replaceWithNode.insertAfter(newList);
     }
-  }, {
-    key: "remove",
-    value: function remove(preserveEmptyParent) {
-      var prevSibling = this.getPreviousSibling();
-      var nextSibling = this.getNextSibling();
-      (0, _superPropGet2.default)(ListItemNode, "remove", this, 3)([preserveEmptyParent]);
-      if (prevSibling && nextSibling && (0, _listNode.isNestedListNode)(prevSibling) && (0, _listNode.isNestedListNode)(nextSibling)) {
-        (0, _formatList.mergeLists)(prevSibling.getFirstChild(), nextSibling.getFirstChild());
-        nextSibling.remove();
-      } else if (nextSibling) {
-        var parent = nextSibling.getParent();
-        if ((0, _ListNode.$isListNode)(parent)) {
-          (0, _formatList.updateChildrenListItemValue)(parent);
-        }
+    if (includeChildren) {
+      if (!$isElementNode(replaceWithNode)) {
+        throw Error("includeChildren should only be true for ElementNodes");
       }
-    }
-  }, {
-    key: "insertNewAfter",
-    value: function insertNewAfter() {
-      var newElement = $createListItemNode(this.__checked == null ? undefined : false);
-      this.insertAfter(newElement);
-      return newElement;
-    }
-  }, {
-    key: "collapseAtStart",
-    value: function collapseAtStart(selection) {
-      var paragraph = (0, _ParagraphNode.$createParagraphNode)();
-      var children = this.getChildren();
-      children.forEach(function (child) {
-        return paragraph.append(child);
+      this.getChildren().forEach(child => {
+        replaceWithNode.append(child);
       });
-      var listNode = this.getParentOrThrow();
-      var listNodeParent = listNode.getParentOrThrow();
-      var 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
-          var anchor = selection.anchor;
-          var focus = selection.focus;
-          var 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;
-    }
-  }, {
-    key: "getValue",
-    value: function getValue() {
-      var self = this.getLatest();
-      return self.__value;
     }
-  }, {
-    key: "setValue",
-    value: function setValue(value) {
-      var self = this.getWritable();
-      self.__value = value;
+    this.remove();
+    if (list.getChildrenSize() === 0) {
+      list.remove();
     }
-  }, {
-    key: "getChecked",
-    value: function getChecked() {
-      var self = this.getLatest();
-      return self.__checked;
-    }
-  }, {
-    key: "setChecked",
-    value: function setChecked(checked) {
-      var self = this.getWritable();
-      self.__checked = checked;
+    return replaceWithNode;
+  }
+  insertAfter(node) {
+    const listNode = this.getParentOrThrow();
+    if (!$isListNode(listNode)) {
+      console.log("insertAfter: webiny list node is not parent of list item node");
+      return listNode;
     }
-  }, {
-    key: "getIndent",
-    value: function getIndent() {
-      // If we don't have a parent, we are likely serializing
-      var parent = this.getParent();
-      if (parent === null) {
-        return this.getLatest().__indent;
-      }
-      // ListItemNode should always have a ListNode for a parent.
-      var listNodeParent = parent.getParentOrThrow();
-      var indentLevel = 0;
-      while ($isListItemNode(listNodeParent)) {
-        listNodeParent = listNodeParent.getParentOrThrow().getParentOrThrow();
-        indentLevel++;
+    const siblings = this.getNextSiblings();
+    if ($isListItemNode(node)) {
+      const after = super.insertAfter(node);
+      const afterListNode = node.getParentOrThrow();
+      if ($isListNode(afterListNode)) {
+        updateChildrenListItemValue(afterListNode);
       }
-      return indentLevel;
+      return after;
     }
-  }, {
-    key: "setIndent",
-    value: function setIndent(indent) {
-      var currentIndent = this.getIndent();
-      while (currentIndent !== indent) {
-        if (currentIndent < indent) {
-          (0, _formatList.$handleIndent)([this]);
-          currentIndent++;
-        } else {
-          (0, _formatList.$handleOutdent)([this]);
-          currentIndent--;
-        }
+
+    // Attempt to merge if the list is of the same type.
+
+    if ($isListNode(node) && node.getListType() === listNode.getListType()) {
+      let child = node;
+      const children = node.getChildren();
+      for (let i = children.length - 1; i >= 0; i--) {
+        child = children[i];
+        this.insertAfter(child);
       }
-      return this;
+      return child;
     }
-  }, {
-    key: "canIndent",
-    value: function canIndent() {
-      // Indent/outdent is handled specifically in the RichText logic.
 
-      return false;
+    // Otherwise, split the list
+    // Split the lists and insert the node in between them
+    listNode.insertAfter(node);
+    if (siblings.length !== 0) {
+      const newListNode = $createListNode(listNode.getListType());
+      siblings.forEach(sibling => newListNode.append(sibling));
+      node.insertAfter(newListNode);
     }
-  }, {
-    key: "insertBefore",
-    value: function insertBefore(nodeToInsert) {
-      if ($isListItemNode(nodeToInsert)) {
-        var parent = this.getParentOrThrow();
-        if ((0, _ListNode.$isListNode)(parent)) {
-          var siblings = this.getNextSiblings();
-          (0, _formatList.updateChildrenListItemValue)(parent, siblings);
-        }
+    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);
       }
-      return (0, _superPropGet2.default)(ListItemNode, "insertBefore", this, 3)([nodeToInsert]);
     }
-  }, {
-    key: "canInsertAfter",
-    value: function canInsertAfter(node) {
-      return (0, _ListNode.$isListNode)(node);
+  }
+  insertNewAfter() {
+    const newElement = $createListItemNode(this.__checked == null ? undefined : false);
+    this.insertAfter(newElement);
+    return newElement;
+  }
+  collapseAtStart(selection) {
+    const paragraph = $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();
     }
-  }, {
-    key: "canReplaceWith",
-    value: function canReplaceWith(replacement) {
-      return $isListItemNode(replacement);
+    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;
+  }
+  getIndent() {
+    // If we don't have a parent, we are likely serializing
+    const parent = this.getParent();
+    if (parent === null) {
+      return this.getLatest().__indent;
     }
-  }, {
-    key: "canMergeWith",
-    value: function canMergeWith(node) {
-      return (0, _ParagraphNode.$isParagraphNode)(node) || $isListItemNode(node);
+    // ListItemNode should always have a ListNode for a parent.
+    let listNodeParent = parent.getParentOrThrow();
+    let indentLevel = 0;
+    while ($isListItemNode(listNodeParent)) {
+      listNodeParent = listNodeParent.getParentOrThrow().getParentOrThrow();
+      indentLevel++;
     }
-  }, {
-    key: "extractWithChild",
-    value: function extractWithChild(child, selection) {
-      if (!(0, _lexical.$isRangeSelection)(selection)) {
-        return false;
+    return indentLevel;
+  }
+  setIndent(indent) {
+    let currentIndent = this.getIndent();
+    while (currentIndent !== indent) {
+      if (currentIndent < indent) {
+        $handleIndent([this]);
+        currentIndent++;
+      } else {
+        $handleOutdent([this]);
+        currentIndent--;
       }
-      var anchorNode = selection.anchor.getNode();
-      var focusNode = selection.focus.getNode();
-      return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && this.getTextContent().length === selection.getTextContent().length;
     }
-  }], [{
-    key: "getType",
-    value: /** @internal */
-
-    /** @internal */
+    return this;
+  }
+  canIndent() {
+    // Indent/outdent is handled specifically in the RichText logic.
 
-    function getType() {
-      return "webiny-listitem";
-    }
-  }, {
-    key: "clone",
-    value: function clone(node) {
-      return new ListItemNode(node.__value, node.__checked, node.__key);
-    }
-  }, {
-    key: "importDOM",
-    value: function importDOM() {
-      return {
-        li: function li() {
-          return {
-            conversion: convertListItemElement,
-            priority: 0
-          };
-        }
-      };
+    return false;
+  }
+  insertBefore(nodeToInsert) {
+    if ($isListItemNode(nodeToInsert)) {
+      const parent = this.getParentOrThrow();
+      if ($isListNode(parent)) {
+        const siblings = this.getNextSiblings();
+        updateChildrenListItemValue(parent, siblings);
+      }
     }
-  }, {
-    key: "importJSON",
-    value: function importJSON(serializedNode) {
-      var node = new ListItemNode(serializedNode.value, serializedNode.checked);
-      node.setFormat(serializedNode.format);
-      node.setIndent(serializedNode.indent);
-      node.setDirection(serializedNode.direction);
-      return node;
+    return super.insertBefore(nodeToInsert);
+  }
+  canInsertAfter(node) {
+    return $isListNode(node);
+  }
+  canReplaceWith(replacement) {
+    return $isListItemNode(replacement);
+  }
+  canMergeWith(node) {
+    return $isParagraphNode(node) || $isListItemNode(node);
+  }
+  extractWithChild(child, selection) {
+    if (!$isRangeSelection(selection)) {
+      return false;
     }
-  }]);
-}(_lexical.ElementNode);
+    const anchorNode = selection.anchor.getNode();
+    const focusNode = selection.focus.getNode();
+    return this.isParentOf(anchorNode) && this.isParentOf(focusNode) && this.getTextContent().length === selection.getTextContent().length;
+  }
+}
 function $setListItemThemeClassNames(dom, editorThemeClasses, node) {
-  var classesToAdd = [];
-  var classesToRemove = [];
-  var listTheme = editorThemeClasses.list;
-  var listItemClassName = listTheme ? listTheme.listitem : undefined;
-  var nestedListItemClassName;
+  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) {
-    var listItemClasses = listItemClassName.split(" ");
-    classesToAdd.push.apply(classesToAdd, (0, _toConsumableArray2.default)(listItemClasses));
+    const listItemClasses = listItemClassName.split(" ");
+    classesToAdd.push(...listItemClasses);
   }
   if (listTheme) {
-    var parentNode = node.getParent();
-    var isCheckList = (0, _ListNode.$isListNode)(parentNode) && parentNode?.getListType() === "check";
-    var checked = node.getChecked();
+    const parentNode = node.getParent();
+    const isCheckList = $isListNode(parentNode) && parentNode?.getListType() === "check";
+    const checked = node.getChecked();
     if (!isCheckList || checked) {
       classesToRemove.push(listTheme.listitemUnchecked);
     }
@@ -388,27 +312,25 @@ function $setListItemThemeClassNames(dom, editorThemeClasses, node) {
     }
   }
   if (nestedListItemClassName !== undefined) {
-    var nestedListItemClasses = nestedListItemClassName.split(" ");
-    if (node.getChildren().some(function (child) {
-      return (0, _ListNode.$isListNode)(child);
-    })) {
-      classesToAdd.push.apply(classesToAdd, (0, _toConsumableArray2.default)(nestedListItemClasses));
+    const nestedListItemClasses = nestedListItemClassName.split(" ");
+    if (node.getChildren().some(child => $isListNode(child))) {
+      classesToAdd.push(...nestedListItemClasses);
     } else {
-      classesToRemove.push.apply(classesToRemove, (0, _toConsumableArray2.default)(nestedListItemClasses));
+      classesToRemove.push(...nestedListItemClasses);
     }
   }
   if (classesToRemove.length > 0) {
-    _utils.removeClassNamesFromElement.apply(void 0, [dom].concat(classesToRemove));
+    removeClassNamesFromElement(dom, ...classesToRemove);
   }
   if (classesToAdd.length > 0) {
-    _utils.addClassNamesToElement.apply(void 0, [dom].concat(classesToAdd));
+    addClassNamesToElement(dom, ...classesToAdd);
   }
 }
 function updateListItemChecked(dom, listItemNode, prevListItemNode, listNode) {
-  var isCheckList = listNode.getListType() === "check";
+  const isCheckList = listNode.getListType() === "check";
   if (isCheckList) {
     // Only add attributes for leaf list items
-    if ((0, _ListNode.$isListNode)(listItemNode.getFirstChild())) {
+    if ($isListNode(listItemNode.getFirstChild())) {
       dom.removeAttribute("role");
       dom.removeAttribute("tabIndex");
       dom.removeAttribute("aria-checked");
@@ -431,10 +353,10 @@ function convertListItemElement() {
     node: $createListItemNode()
   };
 }
-function $createListItemNode(checked) {
+export function $createListItemNode(checked) {
   return new ListItemNode(undefined, checked);
 }
-function $isListItemNode(node) {
+export function $isListItemNode(node) {
   return node instanceof ListItemNode;
 }