@mdxeditor/editor 4.0.4 → 4.1.1

package/dist/plugins/core/index.js

@@ -1,10 +1,10 @@
 import { realmPlugin } from "../../RealmWithPlugins.js";
-import { createEmptyHistoryState } from "@lexical/react/LexicalHistoryPlugin.js";
+import { createEmptyHistoryState } from "@lexical/history";
 import { $isHeadingNode } from "@lexical/rich-text";
 import { $setBlocksType } from "@lexical/selection";
 import { $findMatchingParent, $wrapNodeInElement, $insertNodeToNearestRoot } from "@lexical/utils";
-import { Cell, Signal, withLatestFrom, filter, map, useCellValue, scan } from "@mdxeditor/gurx";
-import { createCommand, FORMAT_TEXT_COMMAND, $isRootOrShadowRoot, $getRoot, $setSelection, $getSelection, $insertNodes, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_CRITICAL, DecoratorNode, $createParagraphNode, FOCUS_COMMAND, BLUR_COMMAND, $isRangeSelection, createEditor, ParagraphNode, TextNode } from "lexical";
+import { Signal, Cell, withLatestFrom, map, filter, useCellValue, scan } from "@mdxeditor/gurx";
+import { createCommand, FORMAT_TEXT_COMMAND, $getSelection, $isRangeSelection, BLUR_COMMAND, COMMAND_PRIORITY_CRITICAL, SELECTION_CHANGE_COMMAND, $getRoot, DecoratorNode, $createParagraphNode, FOCUS_COMMAND, $isRootOrShadowRoot, $insertNodes, $setSelection, ParagraphNode, TextNode } from "lexical";
 import { gfmStrikethrough } from "micromark-extension-gfm-strikethrough";
 import { gfmStrikethroughToMarkdown, gfmStrikethroughFromMarkdown } from "mdast-util-gfm-strikethrough";
 import { highlightMarkToMarkdown, highlightMarkFromMarkdown } from "mdast-util-highlight-mark";
@@ -28,9 +28,10 @@ import { MdastHTMLVisitor } from "./MdastHTMLVisitor.js";
 import { MdastParagraphVisitor } from "./MdastParagraphVisitor.js";
 import { MdastRootVisitor } from "./MdastRootVisitor.js";
 import { MdastTextVisitor } from "./MdastTextVisitor.js";
-import { SharedHistoryPlugin } from "./SharedHistoryPlugin.js";
 import { comment, commentFromMarkdown } from "../../mdastUtilHtmlComment.js";
 import { lexicalTheme } from "../../styles/lexicalTheme.js";
+import { registerRealmCleanup } from "../../realmSession.js";
+import { createExtensionEditor } from "./lexicalExtensions.js";
 const NESTED_EDITOR_UPDATED_COMMAND = createCommand("NESTED_EDITOR_UPDATED_COMMAND");
 const rootEditor$ = Cell(null);
 const activeEditor$ = Cell(null);
@@ -536,6 +537,7 @@ const corePlugin = realmPlugin({
       [placeholder$]: params == null ? void 0 : params.placeholder,
       [readOnly$]: params == null ? void 0 : params.readOnly,
       [translation$]: params == null ? void 0 : params.translation,
+      [historyState$]: createEmptyHistoryState(),
       [addMdastExtension$]: [gfmStrikethroughFromMarkdown(), highlightMarkFromMarkdown],
       [addSyntaxExtension$]: [gfmStrikethrough(), highlightMark()],
       [addToMarkdownExtension$]: [mdxJsxToMarkdown(), gfmStrikethroughToMarkdown(), highlightMarkToMarkdown],
@@ -553,39 +555,33 @@ const corePlugin = realmPlugin({
         [addImportVisitor$]: MdastHTMLVisitor
       });
     }
-    if (!(params == null ? void 0 : params.suppressSharedHistory)) {
-      r.pub(addComposerChild$, SharedHistoryPlugin);
-    }
   },
   postInit(r, params) {
-    const newEditor = createEditor({
-      // ...(params?.editorState ? { editorState: params.editorState } : {}),
+    const newEditor = createExtensionEditor({
+      name: "@mdxeditor/root",
       editable: (params == null ? void 0 : params.readOnly) !== true,
       namespace: (params == null ? void 0 : params.lexicalEditorNamespace) ?? "MDXEditor",
       nodes: [...r.getValue(usedLexicalNodes$), ...(params == null ? void 0 : params.additionalLexicalNodes) ?? []],
-      onError: (error) => {
-        throw error;
-      },
-      theme: r.getValue(lexicalTheme$)
-    });
-    if ((params == null ? void 0 : params.editorState) !== null) {
-      newEditor.update(() => {
+      theme: r.getValue(lexicalTheme$),
+      historyMode: (params == null ? void 0 : params.suppressSharedHistory) ? "none" : "root-shared",
+      historyState: r.getValue(historyState$),
+      initialEditorState: (params == null ? void 0 : params.editorState) === null ? null : () => {
         const markdown = (params == null ? void 0 : params.initialMarkdown.trim()) ?? "";
         tryImportingMarkdown(r, $getRoot(), markdown);
-        const autoFocusValue = params == null ? void 0 : params.autoFocus;
-        if (autoFocusValue) {
-          if (autoFocusValue === true) {
-            setTimeout(() => {
-              newEditor.focus(noop, { defaultSelection: "rootStart" });
-            });
-            return;
-          }
-          setTimeout(() => {
-            newEditor.focus(noop, {
-              defaultSelection: autoFocusValue.defaultSelection ?? "rootStart"
-            });
-          });
-        }
+      }
+    });
+    registerRealmCleanup(r, () => {
+      newEditor.dispose();
+    });
+    const autoFocusValue = params == null ? void 0 : params.autoFocus;
+    if ((params == null ? void 0 : params.editorState) !== null && autoFocusValue) {
+      const autoFocusTimer = setTimeout(() => {
+        newEditor.focus(noop, {
+          defaultSelection: autoFocusValue === true ? "rootStart" : autoFocusValue.defaultSelection ?? "rootStart"
+        });
+      });
+      registerRealmCleanup(r, () => {
+        clearTimeout(autoFocusTimer);
       });
     }
     r.pub(rootEditor$, newEditor);

package/dist/plugins/core/lexicalExtensions.js

@@ -0,0 +1,143 @@
+import { InitialStateExtension, NestedEditorExtension, buildEditorFromExtensions, getPeerDependencyFromEditor } from "@lexical/extension";
+import { SharedHistoryExtension, HistoryExtension } from "@lexical/history";
+import { ReactExtension } from "@lexical/react/ReactExtension";
+import { ReactProviderExtension } from "@lexical/react/ReactProviderExtension";
+import { configExtension, HISTORIC_TAG, defineExtension, CAN_UNDO_COMMAND, CAN_REDO_COMMAND, FOCUS_COMMAND, COMMAND_PRIORITY_LOW, RootNode, TextNode, LineBreakNode, TabNode, ParagraphNode } from "lexical";
+const editorsWithSharedHistory = /* @__PURE__ */ new WeakSet();
+const editorHistoryStates = /* @__PURE__ */ new WeakMap();
+const extensionBuiltinNodes = /* @__PURE__ */ new Set([RootNode, TextNode, LineBreakNode, TabNode, ParagraphNode]);
+const meaningfulHistoryEntries = /* @__PURE__ */ new WeakMap();
+function externalHistoryExtension(historyState) {
+  return configExtension(HistoryExtension, {
+    createInitialHistoryState: () => historyState,
+    disabled: false
+  });
+}
+function createExtensionEditor({
+  name,
+  namespace,
+  nodes,
+  theme,
+  editable = true,
+  parentEditor,
+  historyMode,
+  historyState,
+  initialEditorState,
+  onError = (error) => {
+    throw error;
+  }
+}) {
+  const dependencies = [
+    ReactProviderExtension,
+    configExtension(ReactExtension, { contentEditable: null }),
+    configExtension(InitialStateExtension, {
+      setOptions: { tag: HISTORIC_TAG },
+      updateOptions: { tag: HISTORIC_TAG }
+    })
+  ];
+  if (parentEditor) {
+    dependencies.push(
+      configExtension(NestedEditorExtension, {
+        $getParentEditor: () => parentEditor,
+        inheritEditableFromParent: true
+      })
+    );
+  }
+  if (historyMode === "nested-shared") {
+    dependencies.push(SharedHistoryExtension);
+  } else if (historyMode === "root-shared" || historyMode === "nested-external") {
+    if (!historyState) {
+      throw new Error(`${historyMode} requires a historyState`);
+    }
+    dependencies.push(externalHistoryExtension(historyState));
+  } else if (historyMode === "table-local") {
+    dependencies.push(configExtension(HistoryExtension, { disabled: false }));
+  }
+  const editorExtension = defineExtension({
+    name,
+    namespace,
+    // InitialStateExtension already declares Lexical's built-ins. Filtering
+    // them here also prevents Vite's optimized extension bundle from seeing
+    // the same built-in constructor through two module facades.
+    nodes: nodes == null ? void 0 : nodes.filter((node) => !extensionBuiltinNodes.has(node)),
+    theme,
+    editable,
+    $initialEditorState: initialEditorState,
+    onError,
+    dependencies
+  });
+  const editor = buildEditorFromExtensions(editorExtension);
+  const historyDependency = getPeerDependencyFromEditor(editor, HistoryExtension.name);
+  const editorHistoryState = historyDependency == null ? void 0 : historyDependency.output.historyState.value;
+  if (editorHistoryState) {
+    editorHistoryStates.set(editor, editorHistoryState);
+  }
+  if (editorHistoryState) {
+    if (!meaningfulHistoryEntries.has(editorHistoryState)) {
+      meaningfulHistoryEntries.set(editorHistoryState, editorHistoryState.current);
+    }
+  }
+  const unregisterHistoryFocusGuard = editorHistoryState ? editor.registerUpdateListener(({ dirtyElements, dirtyLeaves, tags }) => {
+    const current = editorHistoryState.current;
+    if (tags.has(HISTORIC_TAG)) {
+      meaningfulHistoryEntries.set(editorHistoryState, current);
+      return;
+    }
+    if (dirtyElements.size > 0 || dirtyLeaves.size > 0) {
+      meaningfulHistoryEntries.set(editorHistoryState, current);
+      return;
+    }
+    const meaningfulEntry = meaningfulHistoryEntries.get(editorHistoryState);
+    if ((current == null ? void 0 : current.editor) === editor && meaningfulEntry && meaningfulEntry.editor !== editor) {
+      editorHistoryState.undoStack.push({ ...meaningfulEntry });
+      editorHistoryState.redoStack = [];
+      editor.dispatchCommand(CAN_UNDO_COMMAND, true);
+      editor.dispatchCommand(CAN_REDO_COMMAND, false);
+      meaningfulHistoryEntries.set(editorHistoryState, current);
+    } else {
+      meaningfulHistoryEntries.set(editorHistoryState, current);
+    }
+  }) : () => void 0;
+  const availabilityTimers = /* @__PURE__ */ new Set();
+  const unregisterHistoryAvailability = editorHistoryState ? editor.registerCommand(
+    FOCUS_COMMAND,
+    () => {
+      const timer = setTimeout(() => {
+        availabilityTimers.delete(timer);
+        editor.dispatchCommand(CAN_UNDO_COMMAND, editorHistoryState.undoStack.length > 0);
+        editor.dispatchCommand(CAN_REDO_COMMAND, editorHistoryState.redoStack.length > 0);
+      });
+      availabilityTimers.add(timer);
+      return false;
+    },
+    COMMAND_PRIORITY_LOW
+  ) : () => void 0;
+  const dispose = editor.dispose.bind(editor);
+  let disposed = false;
+  editor.dispose = () => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    availabilityTimers.forEach(clearTimeout);
+    availabilityTimers.clear();
+    unregisterHistoryAvailability();
+    unregisterHistoryFocusGuard();
+    dispose();
+  };
+  if (historyMode === "root-shared") {
+    editorsWithSharedHistory.add(editor);
+  }
+  return editor;
+}
+function editorHasSharedHistory(editor) {
+  return editorsWithSharedHistory.has(editor);
+}
+function editorUsesHistoryState(editor, historyState) {
+  return editorHistoryStates.get(editor) === historyState;
+}
+export {
+  createExtensionEditor,
+  editorHasSharedHistory,
+  editorUsesHistoryState
+};

package/dist/plugins/diff-source/SourceEditor.js

@@ -1,6 +1,6 @@
 import { markdown } from "@codemirror/lang-markdown";
 import { EditorState } from "@codemirror/state";
-import { lineNumbers, EditorView } from "@codemirror/view";
+import { EditorView, lineNumbers } from "@codemirror/view";
 import { basicLight } from "cm6-theme-basic-light";
 import { basicSetup } from "codemirror";
 import React__default from "react";

package/dist/plugins/directives/DirectiveNode.js

@@ -1,9 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import React__default from "react";
 import { DecoratorNode } from "lexical";
 import { NestedEditorsContext } from "../core/NestedLexicalEditor.js";

package/dist/plugins/frontmatter/FrontmatterNode.js

@@ -1,9 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { DecoratorNode } from "lexical";
 import React__default from "react";
 import { FrontmatterEditor } from "./FrontmatterEditor.js";

package/dist/plugins/frontmatter/index.js

@@ -1,5 +1,5 @@
 import { realmPlugin } from "../../RealmWithPlugins.js";
-import { rootEditor$, createRootEditorSubscription$, addToMarkdownExtension$, addExportVisitor$, addImportVisitor$, addLexicalNode$, addSyntaxExtension$, addMdastExtension$ } from "../core/index.js";
+import { createRootEditorSubscription$, rootEditor$, addToMarkdownExtension$, addExportVisitor$, addImportVisitor$, addLexicalNode$, addSyntaxExtension$, addMdastExtension$ } from "../core/index.js";
 import { Cell, Action, withLatestFrom } from "@mdxeditor/gurx";
 import { $getRoot, KEY_DOWN_COMMAND, $getSelection, $isRangeSelection, $isTextNode, COMMAND_PRIORITY_CRITICAL } from "lexical";
 import { frontmatterToMarkdown, frontmatterFromMarkdown } from "mdast-util-frontmatter";

package/dist/plugins/headings/index.js

@@ -44,13 +44,14 @@ const allowedHeadingLevels$ = Cell(ALL_HEADING_LEVELS, (r) => {
   });
 });
 const headingsPlugin = realmPlugin({
-  init(realm) {
+  init(realm, params) {
     realm.pubIn({
       [addActivePlugin$]: "headings",
       [addImportVisitor$]: MdastHeadingVisitor,
       [addLexicalNode$]: HeadingNode,
       [addExportVisitor$]: LexicalHeadingVisitor
     });
+    realm.pub(allowedHeadingLevels$, (params == null ? void 0 : params.allowedHeadingLevels) ?? ALL_HEADING_LEVELS);
   },
   update(realm, params) {
     realm.pub(allowedHeadingLevels$, (params == null ? void 0 : params.allowedHeadingLevels) ?? ALL_HEADING_LEVELS);

package/dist/plugins/image/ImageDialog.js

@@ -25,8 +25,7 @@ const ImageDialog = () => {
   const resetFormState = () => {
     reset({ src: "", title: "", altText: "", width: void 0, height: void 0 });
   };
-  if (state.type === "inactive")
-    return null;
+  if (state.type === "inactive") return null;
   return /* @__PURE__ */ React__default.createElement(
     Dialog.Root,
     {

package/dist/plugins/image/ImageEditor.js

@@ -132,8 +132,7 @@ function ImageEditor({ src, title, alt, nodeKey, width, height, rest }) {
   React__default.useEffect(() => {
     if (imagePreviewHandler) {
       const callPreviewHandler = async () => {
-        if (!initialImagePath)
-          setInitialImagePath(src);
+        if (!initialImagePath) setInitialImagePath(src);
         const updatedSrc = await imagePreviewHandler(src);
         setImageSource(updatedSrc);
       };

package/dist/plugins/image/ImageNode.js

@@ -1,9 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import React__default from "react";
 import { DecoratorNode } from "lexical";
 import { ImageEditor } from "./ImageEditor.js";

package/dist/plugins/image/index.js

@@ -1,13 +1,13 @@
 import { ImagePlaceholder } from "./ImagePlaceholder.js";
 import { mergeRegister, $wrapNodeInElement } from "@lexical/utils";
-import { Signal, Cell, Action, withLatestFrom, mapTo, map } from "@mdxeditor/gurx";
+import { Cell, Action, mapTo, withLatestFrom, Signal, map } from "@mdxeditor/gurx";
 import { createCommand, $getNodeByKey, $insertNodes, $isRootOrShadowRoot, $createParagraphNode, COMMAND_PRIORITY_EDITOR, DRAGSTART_COMMAND, COMMAND_PRIORITY_HIGH, DRAGOVER_COMMAND, COMMAND_PRIORITY_LOW, DROP_COMMAND, PASTE_COMMAND, COMMAND_PRIORITY_CRITICAL, $createRangeSelection, $setSelection, $getSelection, $isNodeSelection } from "lexical";
 import { realmPlugin } from "../../RealmWithPlugins.js";
 import { CAN_USE_DOM } from "../../utils/detectMac.js";
 import { activeEditor$, createActiveEditorSubscription$, addComposerChild$, addExportVisitor$, addLexicalNode$, addImportVisitor$ } from "../core/index.js";
 import { EditImageToolbar } from "./EditImageToolbar.js";
 import { ImageDialog } from "./ImageDialog.js";
-import { $createImageNode, ImageNode, $isImageNode } from "./ImageNode.js";
+import { $createImageNode, $isImageNode, ImageNode } from "./ImageNode.js";
 import { LexicalImageVisitor } from "./LexicalImageVisitor.js";
 import { MdastImageVisitor, MdastHtmlImageVisitor, MdastJsxImageVisitor } from "./MdastImageVisitor.js";
 const internalInsertImage$ = Signal((r) => {
@@ -129,8 +129,7 @@ const imageDialogState$ = Cell(
             }
             const cbPayload = Array.from(((_b = event.clipboardData) == null ? void 0 : _b.items) ?? []);
             const isMixedPayload = cbPayload.some((item) => !item.type.includes("image"));
-            if (isMixedPayload)
-              return false;
+            if (isMixedPayload) return false;
             if (!cbPayload.length || cbPayload.length === 0) {
               return false;
             }
@@ -173,8 +172,7 @@ const allowSetImageDimensions$ = Cell(false);
 const saveImage$ = Signal();
 const editImageToolbarComponent$ = Cell(EditImageToolbar);
 const parseImageDimension = (value) => {
-  if (typeof value === "undefined")
-    return void 0;
+  if (typeof value === "undefined") return void 0;
   const parsed = parseInt(String(value), 10);
   return Number.isNaN(parsed) ? void 0 : parsed;
 };

package/dist/plugins/jsx/LexicalJsxNode.js

@@ -1,9 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import { DecoratorNode } from "lexical";
 import React__default from "react";
 import { NestedEditorsContext } from "../core/NestedLexicalEditor.js";

package/dist/plugins/jsx/LexicalMdxExpressionNode.js

@@ -1,9 +1,6 @@
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 import React__default from "react";
 import { DecoratorNode, $applyNodeReplacement } from "lexical";
 import lexicalThemeStyles from "../../styles/lexical-theme.module.css.js";

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

@@ -128,8 +128,7 @@ const LinkDialog = () => {
   }, [activeEditor, publishWindowChange]);
   const [copyUrlTooltipOpen, setCopyUrlTooltipOpen] = React__default.useState(false);
   const t = useTranslation();
-  if (linkDialogState.type === "inactive")
-    return null;
+  if (linkDialogState.type === "inactive") return null;
   const theRect = linkDialogState.rectangle;
   const urlIsExternal = linkDialogState.type === "preview" && linkDialogState.url.startsWith("http");
   return /* @__PURE__ */ React__default.createElement(RadixPopover.Root, { open: true }, /* @__PURE__ */ React__default.createElement(
@@ -171,7 +170,8 @@ const LinkDialog = () => {
       "a",
       {
         className: styles.linkDialogPreviewAnchor,
-        href: linkDialogState.url,
+        "data-testid": "link-dialog-preview",
+        href: linkDialogState.href ?? "about:blank",
         ...urlIsExternal ? { target: "_blank", rel: "noreferrer" } : {},
         onClick: (e) => {
           if (onClickLinkCallback !== null) {

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

@@ -1,5 +1,5 @@
 import { $isLinkNode, $createLinkNode, $isAutoLinkNode, TOGGLE_LINK_COMMAND, LinkNode } from "@lexical/link";
-import { Signal, Cell, Action, withLatestFrom, map, filter } from "@mdxeditor/gurx";
+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";
@@ -23,6 +23,16 @@ function getLinkNodeInSelection(selection) {
   }
   return null;
 }
+function getPreviewHref(editor, linkNodeKey, url) {
+  if (!editor) return "about:blank";
+  return editor.getEditorState().read(() => {
+    const keyedNode = linkNodeKey === "" ? null : $getNodeByKey(linkNodeKey);
+    const selection = $getSelection();
+    const selectedNode = $isRangeSelection(selection) ? getLinkNodeInSelection(selection) : null;
+    const linkNode = $isLinkNode(keyedNode) ? keyedNode : selectedNode;
+    return (linkNode == null ? void 0 : linkNode.sanitizeUrl(url)) ?? "about:blank";
+  });
+}
 const onWindowChange$ = Signal();
 const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
   r.pub(createActiveEditorSubscription$, (editor) => {
@@ -129,7 +139,8 @@ const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
         linkNodeKey: state.linkNodeKey,
         rectangle: state.rectangle,
         title,
-        url
+        url,
+        href: getPreviewHref(editor, state.linkNodeKey ?? "", url)
       });
     } else {
       if (state.type === "edit" && state.initialUrl !== "") {
@@ -155,6 +166,7 @@ const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
             return {
               type: "preview",
               url: state.initialUrl,
+              href: getPreviewHref(editor, state.linkNodeKey, state.initialUrl),
               linkNodeKey: state.linkNodeKey,
               rectangle: state.rectangle
             };
@@ -173,8 +185,7 @@ const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
       map(([[selection], activeEditor, _, readOnly]) => {
         if ($isRangeSelection(selection) && activeEditor && !readOnly) {
           const node = getLinkNodeInSelection(selection);
-          if (!selection.isCollapsed())
-            return { type: "inactive" };
+          if (!selection.isCollapsed()) return { type: "inactive" };
           if (node) {
             const rect = getSelectionRectangle(activeEditor);
             if (!rect) {
@@ -183,6 +194,7 @@ const linkDialogState$ = Cell({ type: "inactive" }, (r) => {
             return {
               type: "preview",
               url: node.getURL(),
+              href: node.sanitizeUrl(node.getURL()),
               linkNodeKey: node.getKey(),
               title: node.getTitle(),
               rectangle: rect

package/dist/plugins/lists/index.js

@@ -1,9 +1,9 @@
-import { currentSelection$, activeEditor$, rootEditor$, addNestedEditorChild$, addComposerChild$, addToMarkdownExtension$, addExportVisitor$, addLexicalNode$, addImportVisitor$, addSyntaxExtension$, addMdastExtension$, addActivePlugin$ } from "../core/index.js";
+import { activeEditor$, currentSelection$, rootEditor$, addNestedEditorChild$, addComposerChild$, addToMarkdownExtension$, addExportVisitor$, addLexicalNode$, addImportVisitor$, addSyntaxExtension$, addMdastExtension$, addActivePlugin$ } from "../core/index.js";
 import { MdastListVisitor } from "./MdastListVisitor.js";
 import { MdastListItemVisitor } from "./MdastListItemVisitor.js";
 import { LexicalListVisitor } from "./LexicalListVisitor.js";
 import { LexicalListItemVisitor } from "./LexicalListItemVisitor.js";
-import { $isListNode, ListNode, ListItemNode, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, INSERT_CHECK_LIST_COMMAND, REMOVE_LIST_COMMAND, $getListDepth, $isListItemNode } from "@lexical/list";
+import { $isListNode, ListNode, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, INSERT_CHECK_LIST_COMMAND, REMOVE_LIST_COMMAND, ListItemNode, $getListDepth, $isListItemNode } from "@lexical/list";
 import { $isRootOrShadowRoot, INDENT_CONTENT_COMMAND, COMMAND_PRIORITY_CRITICAL, $getSelection, $isRangeSelection, $isElementNode } from "lexical";
 import { TabIndentationPlugin } from "@lexical/react/LexicalTabIndentationPlugin.js";
 import { CheckListPlugin } from "@lexical/react/LexicalCheckListPlugin.js";
@@ -11,7 +11,7 @@ import { ListPlugin } from "@lexical/react/LexicalListPlugin.js";
 import { $findMatchingParent, $getNearestNodeOfType } from "@lexical/utils";
 import { gfmTaskListItem } from "micromark-extension-gfm-task-list-item";
 import { gfmTaskListItemToMarkdown, gfmTaskListItemFromMarkdown } from "mdast-util-gfm-task-list-item";
-import { Cell, Signal, withLatestFrom } from "@mdxeditor/gurx";
+import { Signal, withLatestFrom, Cell } from "@mdxeditor/gurx";
 import { realmPlugin } from "../../RealmWithPlugins.js";
 const ListTypeCommandMap = /* @__PURE__ */ new Map([
   ["number", INSERT_ORDERED_LIST_COMMAND],

package/dist/plugins/markdown-shortcut/index.js

@@ -1,5 +1,5 @@
 import React__default from "react";
-import { BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, QUOTE, LINK, ORDERED_LIST, UNORDERED_LIST, CHECK_LIST, CODE } from "@lexical/markdown";
+import { ORDERED_LIST, UNORDERED_LIST, CHECK_LIST, BOLD_ITALIC_STAR, BOLD_ITALIC_UNDERSCORE, BOLD_STAR, BOLD_UNDERSCORE, INLINE_CODE, ITALIC_STAR, ITALIC_UNDERSCORE, QUOTE, LINK, CODE } from "@lexical/markdown";
 import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
 import { HeadingNode, $isHeadingNode, $createHeadingNode } from "@lexical/rich-text";
 import { realmPlugin } from "../../RealmWithPlugins.js";