@nkzw/mdx-editor 0.1.0

package/dist/plugins/link-dialog/index.js

@@ -0,0 +1,304 @@
+import { $isLinkNode, $createLinkNode, $isAutoLinkNode, TOGGLE_LINK_COMMAND, LinkNode } from "@lexical/link";
+import { Action, Cell, withLatestFrom, map, Signal, filter } from "@mdxeditor/gurx";
+import { KEY_ESCAPE_COMMAND, COMMAND_PRIORITY_LOW, KEY_DOWN_COMMAND, $getSelection, $isRangeSelection, COMMAND_PRIORITY_HIGH, $getNodeByKey, $createTextNode, $insertNodes, $isTextNode, $getNearestNodeFromDOMNode } from "lexical";
+import { realmPlugin } from "../../RealmWithPlugins.js";
+import { IS_APPLE } from "../../utils/detectMac.js";
+import { getSelectionRectangle, getSelectedNode } from "../../utils/lexicalHelpers.js";
+import { createActiveEditorSubscription$, viewMode$, readOnly$, activeEditor$, currentSelection$, addComposerChild$ } from "../core/index.js";
+import { LinkDialog } from "./LinkDialog.js";
+import { $findMatchingParent } from "@lexical/utils";
+function getLinkNodeInSelection(selection) {
+  if (!selection) {
+    return null;
+  }
+  const node = getSelectedNode(selection);
+  if (node === null) {
+    return null;
+  }
+  const parent = node.getParent();
+  if ($isLinkNode(parent)) {
+    return parent;
+  } else if ($isLinkNode(node)) {
+    return node;
+  }
+  return null;
+}
+const onWindowChange$ = Signal();
+const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
+  r.pub(createActiveEditorSubscription$, (editor) => {
+    return editor.registerCommand(
+      KEY_ESCAPE_COMMAND,
+      () => {
+        const state = r.getValue(linkDialogState$);
+        if (state.type === "preview") {
+          r.pub(linkDialogState$, { type: "inactive" });
+          return true;
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_LOW
+    );
+  });
+  r.sub(r.pipe(viewMode$), (viewMode) => {
+    if (viewMode !== "rich-text") {
+      r.pub(linkDialogState$, { type: "inactive" });
+    }
+  });
+  r.pub(createActiveEditorSubscription$, (editor) => {
+    return editor.registerCommand(
+      KEY_DOWN_COMMAND,
+      (event) => {
+        if (event.key === "k" && (IS_APPLE ? event.metaKey : event.ctrlKey) && !r.getValue(readOnly$)) {
+          const selection = $getSelection();
+          if ($isRangeSelection(selection)) {
+            r.pub(openLinkEditDialog$);
+            event.stopPropagation();
+            event.preventDefault();
+            return true;
+          } else {
+            return false;
+          }
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_HIGH
+    );
+  });
+  r.sub(r.pipe(switchFromPreviewToLinkEdit$, withLatestFrom(linkDialogState$, activeEditor$)), ([, state, editor]) => {
+    if (state.type === "preview") {
+      setTimeout(() => {
+        editor?.getEditorState().read(() => {
+          const node = $getNodeByKey(state.linkNodeKey);
+          const withAnchorText = $isLinkNode(node) ? node.getTextContent().length > 0 && node.getChildrenSize() <= 1 : false;
+          const text = withAnchorText && node ? node.getTextContent() : "";
+          r.pub(linkDialogState$, {
+            type: "edit",
+            initialUrl: state.url,
+            url: state.url,
+            title: state.title,
+            text,
+            withAnchorText,
+            linkNodeKey: state.linkNodeKey,
+            rectangle: state.rectangle
+          });
+        });
+      });
+    } else {
+      throw new Error("Cannot switch to edit mode when not in preview mode");
+    }
+  });
+  r.sub(r.pipe(updateLink$, withLatestFrom(activeEditor$, linkDialogState$, currentSelection$)), ([payload, editor, state, selection]) => {
+    const text = payload.text?.trim() ?? "";
+    const url = payload.url?.trim() ?? "";
+    const title = payload.title?.trim() ?? "";
+    if (url !== "") {
+      if (selection?.isCollapsed()) {
+        const linkContent = text || title || url;
+        editor?.update(
+          () => {
+            const linkNode = getLinkNodeInSelection(selection);
+            if (!linkNode) {
+              const node = $createLinkNode(url, { title });
+              node.append($createTextNode(linkContent));
+              $insertNodes([node]);
+              node.select();
+            } else {
+              if ($isAutoLinkNode(linkNode)) {
+                const newLinkNode = $createLinkNode(url, { title });
+                newLinkNode.append($createTextNode(text));
+                linkNode.replace(newLinkNode);
+                newLinkNode.select();
+              } else {
+                linkNode.setURL(url);
+                linkNode.setTitle(title);
+                updateLinkText(linkNode.getFirstChild(), text);
+              }
+            }
+          },
+          { discrete: true }
+        );
+      } else {
+        editor?.update(() => {
+          updateLinkText(selection?.anchor.getNode(), text);
+        });
+        editor?.dispatchCommand(TOGGLE_LINK_COMMAND, { url, title });
+      }
+      r.pub(linkDialogState$, {
+        type: "preview",
+        linkNodeKey: state.linkNodeKey,
+        rectangle: state.rectangle,
+        title,
+        url
+      });
+    } else {
+      if (state.type === "edit" && state.initialUrl !== "") {
+        editor?.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+      }
+      r.pub(linkDialogState$, {
+        type: "inactive"
+      });
+    }
+  });
+  r.link(
+    r.pipe(
+      cancelLinkEdit$,
+      withLatestFrom(linkDialogState$, activeEditor$),
+      map(([, state, editor]) => {
+        if (state.type === "edit") {
+          editor?.focus();
+          if (state.initialUrl === "") {
+            return {
+              type: "inactive"
+            };
+          } else {
+            return {
+              type: "preview",
+              url: state.initialUrl,
+              linkNodeKey: state.linkNodeKey,
+              rectangle: state.rectangle
+            };
+          }
+        } else {
+          throw new Error("Cannot cancel edit when not in edit mode");
+        }
+      })
+    ),
+    linkDialogState$
+  );
+  r.link(
+    r.pipe(
+      r.combine(currentSelection$, onWindowChange$),
+      withLatestFrom(activeEditor$, linkDialogState$, readOnly$),
+      map(([[selection], activeEditor, _, readOnly]) => {
+        if ($isRangeSelection(selection) && activeEditor && !readOnly) {
+          const node = getLinkNodeInSelection(selection);
+          if (!selection.isCollapsed()) return { type: "inactive" };
+          if (node) {
+            const rect = getSelectionRectangle(activeEditor);
+            if (!rect) {
+              return { type: "inactive" };
+            }
+            return {
+              type: "preview",
+              url: node.getURL(),
+              linkNodeKey: node.getKey(),
+              title: node.getTitle(),
+              rectangle: rect
+            };
+          } else {
+            return { type: "inactive" };
+          }
+        } else {
+          return { type: "inactive" };
+        }
+      })
+    ),
+    linkDialogState$
+  );
+});
+const updateLink$ = Signal();
+const cancelLinkEdit$ = Action();
+const applyLinkChanges$ = Action();
+const switchFromPreviewToLinkEdit$ = Action();
+const removeLink$ = Action((r) => {
+  r.sub(r.pipe(removeLink$, withLatestFrom(activeEditor$)), ([, editor]) => {
+    editor?.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+  });
+});
+const openLinkEditDialog$ = Action((r) => {
+  r.sub(
+    r.pipe(
+      openLinkEditDialog$,
+      withLatestFrom(currentSelection$, activeEditor$),
+      filter(([, selection]) => $isRangeSelection(selection))
+    ),
+    ([, selection, editor]) => {
+      editor?.focus(() => {
+        setTimeout(() => {
+          editor.getEditorState().read(() => {
+            const linkNode = getLinkNodeInSelection(selection);
+            const rectangle = getSelectionRectangle(editor);
+            const initialUrl = linkNode?.getURL() ?? "";
+            const url = linkNode?.getURL() ?? "";
+            const title = linkNode?.getTitle() ?? "";
+            const linkNodeKey = linkNode?.getKey() ?? "";
+            const withAnchorText = linkNode ? linkNode.getTextContent().length > 0 && linkNode.getChildrenSize() <= 1 : Boolean(selection?.isCollapsed());
+            const text = withAnchorText && linkNode ? linkNode.getTextContent() : "";
+            r.pub(linkDialogState$, {
+              type: "edit",
+              initialUrl,
+              url,
+              title,
+              text,
+              withAnchorText,
+              linkNodeKey,
+              rectangle
+            });
+          });
+        });
+      });
+    }
+  );
+});
+const linkAutocompleteSuggestions$ = Cell([]);
+const onClickLinkCallback$ = Cell(null);
+const onReadOnlyClickLinkCallback$ = Cell(null, (r) => {
+  r.pub(createActiveEditorSubscription$, (editor) => {
+    function onClick(event) {
+      const [readOnly, callback] = r.getValues([readOnly$, onReadOnlyClickLinkCallback$]);
+      if (!readOnly || callback === null) {
+        return;
+      }
+      editor.update(() => {
+        const nearestNode = $getNearestNodeFromDOMNode(event.target);
+        if (nearestNode !== null) {
+          const targetNode = $findMatchingParent(nearestNode, (node) => node instanceof LinkNode);
+          if (targetNode !== null) {
+            callback(event, targetNode, targetNode.getURL());
+          }
+        }
+      });
+    }
+    return editor.registerRootListener((rootElement, prevRoot) => {
+      if (rootElement) {
+        rootElement.addEventListener("click", onClick);
+      }
+      if (prevRoot) {
+        prevRoot.removeEventListener("click", onClick);
+      }
+    });
+  });
+});
+function updateLinkText(node, text) {
+  if ($isTextNode(node) && text) {
+    node.setTextContent(text);
+    node.selectStart();
+  }
+}
+const showLinkTitleField$ = Cell(true);
+const linkDialogPlugin = realmPlugin({
+  init(r, params) {
+    r.pub(addComposerChild$, params?.LinkDialog ?? LinkDialog);
+    r.pub(onClickLinkCallback$, params?.onClickLinkCallback ?? null);
+    r.pub(onReadOnlyClickLinkCallback$, params?.onReadOnlyClickLinkCallback ?? null);
+    r.pub(showLinkTitleField$, params?.showLinkTitleField ?? true);
+  },
+  update(r, params = {}) {
+    r.pub(linkAutocompleteSuggestions$, params.linkAutocompleteSuggestions ?? []);
+  }
+});
+export {
+  applyLinkChanges$,
+  cancelLinkEdit$,
+  linkAutocompleteSuggestions$,
+  linkDialogPlugin,
+  linkDialogState$,
+  onClickLinkCallback$,
+  onReadOnlyClickLinkCallback$,
+  onWindowChange$,
+  openLinkEditDialog$,
+  removeLink$,
+  showLinkTitleField$,
+  switchFromPreviewToLinkEdit$,
+  updateLink$
+};

package/dist/plugins/lists/CheckListPlugin.js

@@ -0,0 +1,270 @@
+import { INSERT_CHECK_LIST_COMMAND, $insertList, $isListItemNode, $isListNode } from "@lexical/list";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { mergeRegister, $findMatchingParent, isHTMLElement, calculateZoomLevel } from "@lexical/utils";
+import { COMMAND_PRIORITY_LOW, KEY_ARROW_DOWN_COMMAND, KEY_ARROW_UP_COMMAND, KEY_ESCAPE_COMMAND, KEY_SPACE_COMMAND, $getNearestNodeFromDOMNode, KEY_ARROW_LEFT_COMMAND, $getSelection, $isRangeSelection, $isElementNode, getNearestEditorFromDOMNode, $addUpdateTag, SKIP_SELECTION_FOCUS_TAG, SKIP_DOM_SELECTION_TAG } from "lexical";
+import { useEffect } from "react";
+const TOUCH_CLICK_DEDUP_WINDOW_MS = 500;
+const lastTouchToggleByTarget = /* @__PURE__ */ new WeakMap();
+function CheckListPlugin({
+  disableTakeFocusOnClick = false
+}) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(
+    () => registerCheckList(editor, disableTakeFocusOnClick),
+    [editor, disableTakeFocusOnClick]
+  );
+  return null;
+}
+function registerCheckList(editor, disableTakeFocusOnClick) {
+  const handleMouseClick = (event) => {
+    const target = event.target;
+    if (isHTMLElement(target)) {
+      const lastTouchToggle = lastTouchToggleByTarget.get(target);
+      lastTouchToggleByTarget.delete(target);
+      if (lastTouchToggle !== void 0 && performance.now() - lastTouchToggle < TOUCH_CLICK_DEDUP_WINDOW_MS) {
+        return;
+      }
+    }
+    handleClick(event, disableTakeFocusOnClick);
+  };
+  const handlePointerUp = (event) => {
+    if (event.pointerType !== "touch") {
+      return;
+    }
+    if (handleClick(event, disableTakeFocusOnClick) && isHTMLElement(event.target)) {
+      lastTouchToggleByTarget.set(event.target, performance.now());
+    }
+  };
+  const handleSelect = (event) => {
+    handleSelectDefaults(event, disableTakeFocusOnClick);
+  };
+  return mergeRegister(
+    editor.registerCommand(
+      INSERT_CHECK_LIST_COMMAND,
+      () => {
+        $insertList("check");
+        return true;
+      },
+      COMMAND_PRIORITY_LOW
+    ),
+    editor.registerCommand(
+      KEY_ARROW_DOWN_COMMAND,
+      (event) => handleArrowUpOrDown(event, editor, false),
+      COMMAND_PRIORITY_LOW
+    ),
+    editor.registerCommand(
+      KEY_ARROW_UP_COMMAND,
+      (event) => handleArrowUpOrDown(event, editor, true),
+      COMMAND_PRIORITY_LOW
+    ),
+    editor.registerCommand(
+      KEY_ESCAPE_COMMAND,
+      () => {
+        const activeItem = getActiveCheckListItem();
+        if (activeItem === null) {
+          return false;
+        }
+        editor.getRootElement()?.focus();
+        return true;
+      },
+      COMMAND_PRIORITY_LOW
+    ),
+    editor.registerCommand(
+      KEY_SPACE_COMMAND,
+      (event) => {
+        const activeItem = getActiveCheckListItem();
+        if (activeItem === null || !editor.isEditable()) {
+          return false;
+        }
+        editor.update(() => {
+          const listItemNode = $getNearestNodeFromDOMNode(activeItem);
+          if ($isListItemNode(listItemNode)) {
+            event.preventDefault();
+            listItemNode.toggleChecked();
+          }
+        });
+        return true;
+      },
+      COMMAND_PRIORITY_LOW
+    ),
+    editor.registerCommand(
+      KEY_ARROW_LEFT_COMMAND,
+      (event) => editor.getEditorState().read(() => {
+        const selection = $getSelection();
+        if (!$isRangeSelection(selection) || !selection.isCollapsed()) {
+          return false;
+        }
+        const { anchor } = selection;
+        const isElement = anchor.type === "element";
+        if (!isElement && anchor.offset !== 0) {
+          return false;
+        }
+        const anchorNode = anchor.getNode();
+        const elementNode = $findMatchingParent(
+          anchorNode,
+          (node) => $isElementNode(node) && !node.isInline()
+        );
+        if (!$isListItemNode(elementNode)) {
+          return false;
+        }
+        const parent = elementNode.getParent();
+        if (!$isListNode(parent) || parent.getListType() !== "check" || !isElement && elementNode.getFirstDescendant() !== anchorNode) {
+          return false;
+        }
+        const domNode = editor.getElementByKey(elementNode.getKey());
+        if (domNode === null || document.activeElement === domNode) {
+          return false;
+        }
+        domNode.focus();
+        event.preventDefault();
+        return true;
+      }),
+      COMMAND_PRIORITY_LOW
+    ),
+    editor.registerRootListener((rootElement) => {
+      if (rootElement === null) {
+        return;
+      }
+      rootElement.addEventListener("click", handleMouseClick);
+      rootElement.addEventListener("pointerup", handlePointerUp);
+      rootElement.addEventListener("pointerdown", handleSelect, {
+        capture: true
+      });
+      rootElement.addEventListener("mousedown", handleSelect, {
+        capture: true
+      });
+      rootElement.addEventListener("touchstart", handleSelect, {
+        capture: true,
+        passive: false
+      });
+      return () => {
+        rootElement.removeEventListener("click", handleMouseClick);
+        rootElement.removeEventListener("pointerup", handlePointerUp);
+        rootElement.removeEventListener("pointerdown", handleSelect, {
+          capture: true
+        });
+        rootElement.removeEventListener("mousedown", handleSelect, {
+          capture: true
+        });
+        rootElement.removeEventListener("touchstart", handleSelect, {
+          capture: true
+        });
+      };
+    })
+  );
+}
+function handleCheckItemEvent(event, callback) {
+  const target = event.target;
+  if (!isHTMLElement(target)) {
+    return false;
+  }
+  const firstChild = target.firstChild;
+  if (isHTMLElement(firstChild) && (firstChild.tagName === "UL" || firstChild.tagName === "OL")) {
+    return false;
+  }
+  const parentNode = target.parentNode;
+  if (!parentNode || parentNode.__lexicalListType !== "check") {
+    return false;
+  }
+  let clientX = null;
+  let pointerType = null;
+  if ("clientX" in event) {
+    clientX = event.clientX;
+  } else if ("touches" in event && event.touches.length > 0) {
+    clientX = event.touches[0].clientX;
+    pointerType = "touch";
+  }
+  if (clientX === null) {
+    return false;
+  }
+  const rect = target.getBoundingClientRect();
+  const clientXInPixels = clientX / calculateZoomLevel(target);
+  const beforeStyles = window.getComputedStyle ? window.getComputedStyle(target, "::before") : { width: "0px" };
+  const beforeWidthInPixels = parseFloat(beforeStyles.width);
+  const isTouchEvent = pointerType === "touch" || "pointerType" in event && event.pointerType === "touch";
+  const clickAreaPadding = isTouchEvent ? 32 : 0;
+  const isMarkerHit = target.dir === "rtl" ? clientXInPixels < rect.right + clickAreaPadding && clientXInPixels > rect.right - beforeWidthInPixels - clickAreaPadding : clientXInPixels > rect.left - clickAreaPadding && clientXInPixels < rect.left + beforeWidthInPixels + clickAreaPadding;
+  if (!isMarkerHit) {
+    return false;
+  }
+  return callback() !== false;
+}
+function handleClick(event, disableFocusOnClick) {
+  return handleCheckItemEvent(event, () => {
+    if (!isHTMLElement(event.target)) {
+      return false;
+    }
+    const domNode = event.target;
+    const editor = getNearestEditorFromDOMNode(domNode);
+    if (editor === null || !editor.isEditable()) {
+      return false;
+    }
+    editor.update(() => {
+      const node = $getNearestNodeFromDOMNode(domNode);
+      if ($isListItemNode(node)) {
+        if (disableFocusOnClick) {
+          $addUpdateTag(SKIP_SELECTION_FOCUS_TAG);
+          $addUpdateTag(SKIP_DOM_SELECTION_TAG);
+        } else {
+          domNode.focus();
+        }
+        node.toggleChecked();
+      }
+    });
+    return true;
+  });
+}
+function handleSelectDefaults(event, disableTakeFocusOnClick) {
+  handleCheckItemEvent(event, () => {
+    event.preventDefault();
+    if (disableTakeFocusOnClick) {
+      event.stopPropagation();
+    }
+  });
+}
+function getActiveCheckListItem() {
+  const activeElement = document.activeElement;
+  return isHTMLElement(activeElement) && activeElement.tagName === "LI" && activeElement.parentNode !== null && activeElement.parentNode.__lexicalListType === "check" ? activeElement : null;
+}
+function findCheckListItemSibling(node, backward) {
+  let sibling = backward ? node.getPreviousSibling() : node.getNextSibling();
+  let parent = node;
+  while (sibling === null && $isListItemNode(parent)) {
+    parent = parent.getParentOrThrow().getParent();
+    if (parent !== null) {
+      sibling = backward ? parent.getPreviousSibling() : parent.getNextSibling();
+    }
+  }
+  while ($isListItemNode(sibling)) {
+    const firstChild = backward ? sibling.getLastChild() : sibling.getFirstChild();
+    if (!$isListNode(firstChild)) {
+      return sibling;
+    }
+    sibling = backward ? firstChild.getLastChild() : firstChild.getFirstChild();
+  }
+  return null;
+}
+function handleArrowUpOrDown(event, editor, backward) {
+  const activeItem = getActiveCheckListItem();
+  if (activeItem !== null) {
+    editor.update(() => {
+      const listItem = $getNearestNodeFromDOMNode(activeItem);
+      if (!$isListItemNode(listItem)) {
+        return;
+      }
+      const nextListItem = findCheckListItemSibling(listItem, backward);
+      if (nextListItem !== null) {
+        nextListItem.selectStart();
+        const dom = editor.getElementByKey(nextListItem.getKey());
+        if (dom !== null) {
+          event.preventDefault();
+          setTimeout(() => dom.focus(), 0);
+        }
+      }
+    });
+  }
+  return false;
+}
+export {
+  CheckListPlugin
+};

package/dist/plugins/lists/LexicalListItemVisitor.js

@@ -0,0 +1,41 @@
+import { $isListItemNode, $isListNode } from "@lexical/list";
+import { $isTextNode, $isLineBreakNode, $isElementNode, $isDecoratorNode } from "lexical";
+const LexicalListItemVisitor = {
+  testLexicalNode: $isListItemNode,
+  visitLexicalNode: ({ lexicalNode, mdastParent, actions }) => {
+    const children = lexicalNode.getChildren();
+    const firstChild = children[0];
+    if (children.length === 1 && $isListNode(firstChild)) {
+      const prevListItemNode = mdastParent.children.at(-1);
+      if (!prevListItemNode) {
+        actions.visitChildren(firstChild, mdastParent);
+      } else {
+        actions.visitChildren(lexicalNode, prevListItemNode);
+      }
+    } else {
+      const parentList = lexicalNode.getParent();
+      const listItem = actions.appendToParent(mdastParent, {
+        type: "listItem",
+        checked: parentList.getListType() === "check" ? Boolean(lexicalNode.getChecked()) : void 0,
+        spread: false,
+        children: []
+      });
+      let surroundingParagraph = null;
+      for (const child of lexicalNode.getChildren()) {
+        if ($isTextNode(child) || $isLineBreakNode(child) || child.isInline() && ($isElementNode(child) || $isDecoratorNode(child))) {
+          surroundingParagraph ??= actions.appendToParent(listItem, {
+            type: "paragraph",
+            children: []
+          });
+          actions.visit(child, surroundingParagraph);
+        } else {
+          surroundingParagraph = null;
+          actions.visit(child, listItem);
+        }
+      }
+    }
+  }
+};
+export {
+  LexicalListItemVisitor
+};

package/dist/plugins/lists/LexicalListVisitor.js

@@ -0,0 +1,13 @@
+import { $isListNode } from "@lexical/list";
+const LexicalListVisitor = {
+  testLexicalNode: $isListNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    actions.addAndStepInto("list", {
+      ordered: lexicalNode.getListType() === "number",
+      spread: false
+    });
+  }
+};
+export {
+  LexicalListVisitor
+};

package/dist/plugins/lists/MdastListItemVisitor.js

@@ -0,0 +1,11 @@
+import { $createListItemNode } from "@lexical/list";
+const MdastListItemVisitor = {
+  testNode: "listItem",
+  visitNode({ mdastNode, actions, lexicalParent }) {
+    const isChecked = lexicalParent.getListType() === "check" ? mdastNode.checked ?? false : void 0;
+    actions.addAndStepInto($createListItemNode(isChecked));
+  }
+};
+export {
+  MdastListItemVisitor
+};

package/dist/plugins/lists/MdastListVisitor.js

@@ -0,0 +1,19 @@
+import { $createListNode, $isListItemNode, $createListItemNode } from "@lexical/list";
+const MdastListVisitor = {
+  testNode: "list",
+  visitNode: function({ mdastNode, lexicalParent, actions }) {
+    const listType = mdastNode.children.some((e) => typeof e.checked === "boolean") ? "check" : mdastNode.ordered ? "number" : "bullet";
+    const lexicalNode = $createListNode(listType);
+    if ($isListItemNode(lexicalParent)) {
+      const dedicatedParent = $createListItemNode();
+      dedicatedParent.append(lexicalNode);
+      lexicalParent.insertAfter(dedicatedParent);
+    } else {
+      lexicalParent.append(lexicalNode);
+    }
+    actions.visitChildren(mdastNode, lexicalNode);
+  }
+};
+export {
+  MdastListVisitor
+};

package/dist/plugins/lists/NotesListItemNode.js

@@ -0,0 +1,22 @@
+import { ListItemNode, $isListNode } from "@lexical/list";
+import { $isParagraphNode } from "lexical";
+class NotesListItemNode extends ListItemNode {
+  $config() {
+    return this.config("notes-listitem", { extends: ListItemNode });
+  }
+  collapseAtStart(selection) {
+    const list = this.getParent();
+    const shouldRestoreSelection = this.isEmpty() && $isListNode(list) && list.getChildrenSize() > 1;
+    const result = super.collapseAtStart(selection);
+    if (shouldRestoreSelection) {
+      const paragraph = list.getPreviousSibling();
+      if ($isParagraphNode(paragraph)) {
+        paragraph.selectStart();
+      }
+    }
+    return result;
+  }
+}
+export {
+  NotesListItemNode
+};