@mdxeditor/editor 0.9.0 → 0.10.0-alpha.1

package/dist/plugins/headings/LexicalHeadingVisitor.js

@@ -0,0 +1,11 @@
+import { $isHeadingNode } from "@lexical/rich-text";
+const LexicalHeadingVisitor = {
+  testLexicalNode: $isHeadingNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    const depth = parseInt(lexicalNode.getTag()[1], 10);
+    actions.addAndStepInto("heading", { depth });
+  }
+};
+export {
+  LexicalHeadingVisitor
+};

package/dist/plugins/headings/MdastHeadingVisitor.d.ts

@@ -0,0 +1,3 @@
+import * as Mdast from 'mdast';
+import { MdastImportVisitor } from '../../importMarkdownToLexical';
+export declare const MdastHeadingVisitor: MdastImportVisitor<Mdast.Heading>;

package/dist/plugins/headings/MdastHeadingVisitor.js

@@ -0,0 +1,10 @@
+import { $createHeadingNode } from "@lexical/rich-text";
+const MdastHeadingVisitor = {
+  testNode: "heading",
+  visitNode: function({ mdastNode, actions }) {
+    actions.addAndStepInto($createHeadingNode(`h${mdastNode.depth}`));
+  }
+};
+export {
+  MdastHeadingVisitor
+};

package/dist/plugins/headings/index.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="react" />
+/**
+ * @internal
+ */
+export declare const headingsSystem: import("../../gurx").SystemSpec<[import("../../gurx").SystemSpec<[], (r: import("../../gurx").Realm) => {
+    activeEditor: import("../../gurx").RealmNode<import("lexical").LexicalEditor | null>;
+    inFocus: import("../../gurx").RealmNode<boolean>;
+    historyState: import("../../gurx").RealmNode<import("@lexical/history").HistoryState>;
+    currentSelection: import("../../gurx").RealmNode<import("lexical").RangeSelection | null>;
+    jsxIsAvailable: import("../../gurx").RealmNode<boolean>;
+    jsxComponentDescriptors: import("../../gurx").RealmNode<import("../jsx").JsxComponentDescriptor[]>;
+    initialRootEditorState: import("../../gurx").RealmNode<import("@lexical/react/LexicalComposer").InitialEditorStateType>;
+    rootEditor: import("../../gurx").RealmNode<import("lexical").LexicalEditor | null>;
+    createRootEditorSubscription: import("../../gurx").RealmNode<import("../core").EditorSubscription>;
+    createActiveEditorSubscription: import("../../gurx").RealmNode<import("../core").EditorSubscription>;
+    importVisitors: import("../../gurx").RealmNode<import("../../importMarkdownToLexical").MdastImportVisitor<import("mdast").Content>[]>;
+    syntaxExtensions: import("../../gurx").RealmNode<import("micromark-util-types").Extension[]>;
+    mdastExtensions: import("../../gurx").RealmNode<(Partial<import("mdast-util-from-markdown/lib").Config> | Partial<import("mdast-util-from-markdown/lib").Config>[])[] | null | undefined>;
+    usedLexicalNodes: import("../../gurx").RealmNode<import("lexical").Klass<import("lexical").LexicalNode>[]>;
+    addImportVisitor: import("../../gurx").RealmNode<import("../../importMarkdownToLexical").MdastImportVisitor<import("mdast").Content>>;
+    addLexicalNode: import("../../gurx").RealmNode<import("lexical").Klass<import("lexical").LexicalNode>>;
+    addSyntaxExtension: import("../../gurx").RealmNode<import("micromark-util-types").Extension>;
+    addMdastExtension: import("../../gurx").RealmNode<Partial<import("mdast-util-from-markdown/lib").Config> | Partial<import("mdast-util-from-markdown/lib").Config>[]>;
+    toMarkdownExtensions: import("../../gurx").RealmNode<import("mdast-util-to-markdown").Options[]>;
+    toMarkdownOptions: import("../../gurx").RealmNode<import("mdast-util-to-markdown").Options>;
+    addToMarkdownExtension: import("../../gurx").RealmNode<import("mdast-util-to-markdown").Options>;
+    addExportVisitor: import("../../gurx").RealmNode<import("../../exportMarkdownFromLexical").LexicalVisitor>;
+    exportVisitors: import("../../gurx").RealmNode<import("../../exportMarkdownFromLexical").LexicalVisitor[]>;
+    initialMarkdown: import("../../gurx").RealmNode<string>;
+    setMarkdown: import("../../gurx").RealmNode<string>;
+    markdown: import("../../gurx").RealmNode<string>;
+    editorRootElementRef: import("../../gurx").RealmNode<import("react").RefObject<HTMLDivElement> | null>;
+    contentEditableClassName: import("../../gurx").RealmNode<string>;
+    composerChildren: import("../../gurx").RealmNode<import("react").ComponentType<{}>[]>;
+    addComposerChild: import("../../gurx").RealmNode<import("react").ComponentType<{}>>;
+    topAreaChildren: import("../../gurx").RealmNode<import("react").ComponentType<{}>[]>;
+    addTopAreaChild: import("../../gurx").RealmNode<import("react").ComponentType<{}>>;
+    nestedEditorChildren: import("../../gurx").RealmNode<import("react").ComponentType<{}>[]>;
+    addNestedEditorChild: import("../../gurx").RealmNode<import("react").ComponentType<{}>>;
+    editorWrappers: import("../../gurx").RealmNode<import("react").ComponentType<{
+        children: import("react").ReactNode;
+    }>[]>;
+    addEditorWrapper: import("../../gurx").RealmNode<import("react").ComponentType<{
+        children: import("react").ReactNode;
+    }>>;
+    currentFormat: import("../../gurx").RealmNode<number>;
+    editorInFocus: import("../../gurx").RealmNode<import("../core").EditorInFocus | null>;
+    applyFormat: import("../../gurx").RealmNode<import("lexical").TextFormatType>;
+    currentBlockType: import("../../gurx").RealmNode<import("../core").BlockType>;
+    applyBlockType: import("../../gurx").RealmNode<import("../core").BlockType>;
+    convertSelectionToNode: import("../../gurx").RealmNode<() => import("lexical").ElementNode>;
+    insertDecoratorNode: import("../../gurx").RealmNode<() => import("lexical").DecoratorNode<unknown>>;
+}>], (_: import("../../gurx").Realm) => {}>;
+/**
+ * @internal
+ */
+export declare const headingsPlugin: import("../../gurx").PluginConstructor<import("../../gurx").SystemSpec<[import("../../gurx").SystemSpec<[], (r: import("../../gurx").Realm) => {
+    activeEditor: import("../../gurx").RealmNode<import("lexical").LexicalEditor | null>;
+    inFocus: import("../../gurx").RealmNode<boolean>;
+    historyState: import("../../gurx").RealmNode<import("@lexical/history").HistoryState>;
+    currentSelection: import("../../gurx").RealmNode<import("lexical").RangeSelection | null>;
+    jsxIsAvailable: import("../../gurx").RealmNode<boolean>;
+    jsxComponentDescriptors: import("../../gurx").RealmNode<import("../jsx").JsxComponentDescriptor[]>;
+    initialRootEditorState: import("../../gurx").RealmNode<import("@lexical/react/LexicalComposer").InitialEditorStateType>;
+    rootEditor: import("../../gurx").RealmNode<import("lexical").LexicalEditor | null>;
+    createRootEditorSubscription: import("../../gurx").RealmNode<import("../core").EditorSubscription>;
+    createActiveEditorSubscription: import("../../gurx").RealmNode<import("../core").EditorSubscription>;
+    importVisitors: import("../../gurx").RealmNode<import("../../importMarkdownToLexical").MdastImportVisitor<import("mdast").Content>[]>;
+    syntaxExtensions: import("../../gurx").RealmNode<import("micromark-util-types").Extension[]>;
+    mdastExtensions: import("../../gurx").RealmNode<(Partial<import("mdast-util-from-markdown/lib").Config> | Partial<import("mdast-util-from-markdown/lib").Config>[])[] | null | undefined>;
+    usedLexicalNodes: import("../../gurx").RealmNode<import("lexical").Klass<import("lexical").LexicalNode>[]>;
+    addImportVisitor: import("../../gurx").RealmNode<import("../../importMarkdownToLexical").MdastImportVisitor<import("mdast").Content>>;
+    addLexicalNode: import("../../gurx").RealmNode<import("lexical").Klass<import("lexical").LexicalNode>>;
+    addSyntaxExtension: import("../../gurx").RealmNode<import("micromark-util-types").Extension>;
+    addMdastExtension: import("../../gurx").RealmNode<Partial<import("mdast-util-from-markdown/lib").Config> | Partial<import("mdast-util-from-markdown/lib").Config>[]>;
+    toMarkdownExtensions: import("../../gurx").RealmNode<import("mdast-util-to-markdown").Options[]>;
+    toMarkdownOptions: import("../../gurx").RealmNode<import("mdast-util-to-markdown").Options>;
+    addToMarkdownExtension: import("../../gurx").RealmNode<import("mdast-util-to-markdown").Options>;
+    addExportVisitor: import("../../gurx").RealmNode<import("../../exportMarkdownFromLexical").LexicalVisitor>;
+    exportVisitors: import("../../gurx").RealmNode<import("../../exportMarkdownFromLexical").LexicalVisitor[]>;
+    initialMarkdown: import("../../gurx").RealmNode<string>;
+    setMarkdown: import("../../gurx").RealmNode<string>;
+    markdown: import("../../gurx").RealmNode<string>;
+    editorRootElementRef: import("../../gurx").RealmNode<import("react").RefObject<HTMLDivElement> | null>;
+    contentEditableClassName: import("../../gurx").RealmNode<string>;
+    composerChildren: import("../../gurx").RealmNode<import("react").ComponentType<{}>[]>;
+    addComposerChild: import("../../gurx").RealmNode<import("react").ComponentType<{}>>;
+    topAreaChildren: import("../../gurx").RealmNode<import("react").ComponentType<{}>[]>;
+    addTopAreaChild: import("../../gurx").RealmNode<import("react").ComponentType<{}>>;
+    nestedEditorChildren: import("../../gurx").RealmNode<import("react").ComponentType<{}>[]>;
+    addNestedEditorChild: import("../../gurx").RealmNode<import("react").ComponentType<{}>>;
+    editorWrappers: import("../../gurx").RealmNode<import("react").ComponentType<{
+        children: import("react").ReactNode;
+    }>[]>;
+    addEditorWrapper: import("../../gurx").RealmNode<import("react").ComponentType<{
+        children: import("react").ReactNode;
+    }>>;
+    currentFormat: import("../../gurx").RealmNode<number>;
+    editorInFocus: import("../../gurx").RealmNode<import("../core").EditorInFocus | null>;
+    applyFormat: import("../../gurx").RealmNode<import("lexical").TextFormatType>;
+    currentBlockType: import("../../gurx").RealmNode<import("../core").BlockType>;
+    applyBlockType: import("../../gurx").RealmNode<import("../core").BlockType>;
+    convertSelectionToNode: import("../../gurx").RealmNode<() => import("lexical").ElementNode>;
+    insertDecoratorNode: import("../../gurx").RealmNode<() => import("lexical").DecoratorNode<unknown>>;
+}>], (_: import("../../gurx").Realm) => {}>, object>;

package/dist/plugins/headings/index.js

@@ -0,0 +1,20 @@
+import { coreSystem } from "../core/index.js";
+import { MdastHeadingVisitor } from "./MdastHeadingVisitor.js";
+import { HeadingNode } from "@lexical/rich-text";
+import { LexicalHeadingVisitor } from "./LexicalHeadingVisitor.js";
+import { system } from "../../gurx/realmFactory.js";
+import { realmPlugin } from "../../gurx/react.js";
+const headingsSystem = system((_) => ({}), [coreSystem]);
+const [headingsPlugin] = realmPlugin({
+  id: "headings",
+  systemSpec: headingsSystem,
+  init: (realm) => {
+    realm.pubKey("addImportVisitor", MdastHeadingVisitor);
+    realm.pubKey("addLexicalNode", HeadingNode);
+    realm.pubKey("addExportVisitor", LexicalHeadingVisitor);
+  }
+});
+export {
+  headingsPlugin,
+  headingsSystem
+};

package/dist/plugins/image/ImageEditor.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export interface ImageEditorProps {
+    nodeKey: string;
+    src: string;
+    title?: string;
+}
+export declare function ImageEditor({ src, title, nodeKey }: ImageEditorProps): JSX.Element;

package/dist/{ImageEditor-ad505654.js → plugins/image/ImageEditor.js}

@@ -1,46 +1,11 @@
-import React__default, { useRef, useState, useCallback, useEffect, Suspense } from "react";
+import React__default from "react";
 import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
 import { useLexicalNodeSelection } from "@lexical/react/useLexicalNodeSelection";
 import { mergeRegister } from "@lexical/utils";
 import { $isNodeSelection, $getSelection, $getNodeByKey, $setSelection, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_LOW, CLICK_COMMAND, DRAGSTART_COMMAND, KEY_DELETE_COMMAND, KEY_BACKSPACE_COMMAND, KEY_ENTER_COMMAND, KEY_ESCAPE_COMMAND } from "lexical";
-import { $ as $isImageNode, s as styles } from "./index-ce0832cc.js";
+import styles from "../../styles/ui.module.css.js";
 import classNames from "classnames";
-import "@lexical/react/LexicalComposer";
-import "@lexical/react/LexicalContentEditable";
-import "@lexical/react/LexicalErrorBoundary";
-import "@lexical/react/LexicalHorizontalRulePlugin";
-import "@lexical/react/LexicalLinkPlugin";
-import "@lexical/react/LexicalListPlugin";
-import "@lexical/react/LexicalRichTextPlugin";
-import "@lexical/react/LexicalTabIndentationPlugin";
-import "@lexical/code";
-import "@lexical/link";
-import "@lexical/list";
-import "@lexical/react/LexicalHorizontalRuleNode";
-import "@lexical/rich-text";
-import "mdast-util-directive";
-import "mdast-util-from-markdown";
-import "mdast-util-frontmatter";
-import "mdast-util-gfm-table";
-import "mdast-util-mdx";
-import "micromark-extension-directive";
-import "micromark-extension-frontmatter";
-import "micromark-extension-gfm-table";
-import "micromark-extension-mdxjs";
-import "@lexical/selection";
-import "@lexical/react/LexicalHistoryPlugin";
-import "mdast-util-to-markdown";
-import "@radix-ui/react-popover";
-import "@radix-ui/react-tooltip";
-import "downshift";
-import "@lexical/markdown";
-import "@lexical/react/LexicalMarkdownShortcutPlugin";
-import "react-diff-view";
-import "unidiff";
-import "@radix-ui/react-toolbar";
-import "@radix-ui/react-select";
-import "@radix-ui/react-dialog";
-import "@lexical/react/LexicalNestedComposer";
+import { $isImageNode } from "./ImageNode.js";
 const imageCache = /* @__PURE__ */ new Set();
 function useSuspenseImage(src) {
   if (!imageCache.has(src)) {
@@ -64,13 +29,13 @@ function LazyImage({
   return /* @__PURE__ */ React__default.createElement("img", { className: className || void 0, src, title, ref: imageRef, draggable: "false" });
 }
 function ImageEditor({ src, title, nodeKey }) {
-  const imageRef = useRef(null);
-  const buttonRef = useRef(null);
+  const imageRef = React__default.useRef(null);
+  const buttonRef = React__default.useRef(null);
   const [isSelected, setSelected, clearSelection] = useLexicalNodeSelection(nodeKey);
   const [editor] = useLexicalComposerContext();
-  const [selection, setSelection] = useState(null);
-  const activeEditorRef = useRef(null);
-  const onDelete = useCallback(
+  const [selection, setSelection] = React__default.useState(null);
+  const activeEditorRef = React__default.useRef(null);
+  const onDelete = React__default.useCallback(
     (payload) => {
       if (isSelected && $isNodeSelection($getSelection())) {
         const event = payload;
@@ -84,7 +49,7 @@ function ImageEditor({ src, title, nodeKey }) {
     },
     [isSelected, nodeKey]
   );
-  const onEnter = useCallback(
+  const onEnter = React__default.useCallback(
     (event) => {
       const latestSelection = $getSelection();
       const buttonElem = buttonRef.current;
@@ -99,7 +64,7 @@ function ImageEditor({ src, title, nodeKey }) {
     },
     [isSelected]
   );
-  const onEscape = useCallback(
+  const onEscape = React__default.useCallback(
     (event) => {
       if (buttonRef.current === event.target) {
         $setSelection(null);
@@ -116,7 +81,7 @@ function ImageEditor({ src, title, nodeKey }) {
     },
     [editor, setSelected]
   );
-  useEffect(() => {
+  React__default.useEffect(() => {
     let isMounted = true;
     const unregister = mergeRegister(
       editor.registerUpdateListener(({ editorState }) => {
@@ -172,7 +137,7 @@ function ImageEditor({ src, title, nodeKey }) {
   }, [clearSelection, editor, isSelected, nodeKey, onDelete, onEnter, onEscape, setSelected]);
   const draggable = $isNodeSelection(selection);
   const isFocused = isSelected;
-  return /* @__PURE__ */ React__default.createElement(Suspense, { fallback: null }, /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement("div", { draggable, className: styles.imageWrapper, "data-editor-block-type": "image" }, /* @__PURE__ */ React__default.createElement(
+  return /* @__PURE__ */ React__default.createElement(React__default.Suspense, { fallback: null }, /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement("div", { draggable, className: styles.imageWrapper, "data-editor-block-type": "image" }, /* @__PURE__ */ React__default.createElement(
     LazyImage,
     {
       className: classNames({

package/dist/plugins/image/ImageNode.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="react" />
+import type { DOMConversionMap, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, NodeKey, SerializedLexicalNode, Spread } from 'lexical';
+import { DecoratorNode } from 'lexical';
+/**
+ * A serialized representation of an {@link ImageNode}.
+ */
+export type SerializedImageNode = Spread<{
+    altText: string;
+    title?: string;
+    src: string;
+    type: 'image';
+    version: 1;
+}, SerializedLexicalNode>;
+/**
+ * A lexical node that represents an image. Use {@link "$createImageNode"} to construct one.
+ */
+export declare class ImageNode extends DecoratorNode<JSX.Element> {
+    __src: string;
+    __altText: string;
+    __title: string | undefined;
+    static getType(): string;
+    static clone(node: ImageNode): ImageNode;
+    static importJSON(serializedNode: SerializedImageNode): ImageNode;
+    exportDOM(): DOMExportOutput;
+    static importDOM(): DOMConversionMap | null;
+    constructor(src: string, altText: string, title: string | undefined, key?: NodeKey);
+    exportJSON(): SerializedImageNode;
+    createDOM(config: EditorConfig): HTMLElement;
+    updateDOM(): false;
+    getSrc(): string;
+    getAltText(): string;
+    getTitle(): string | undefined;
+    setTitle(title: string | undefined): void;
+    decorate(_parentEditor: LexicalEditor): JSX.Element;
+}
+/**
+ * The payload to create an {@link ImageNode}.
+ */
+export interface CreateImageNodeOptions {
+    altText: string;
+    title?: string;
+    key?: NodeKey;
+    src: string;
+}
+/**
+ * Creates an {@link ImageNode}.
+ * @param options - The payload to create an image. The keys map to the img tag attributes.
+ */
+export declare function $createImageNode(options: CreateImageNodeOptions): ImageNode;
+/**
+ * Retruns true if the node is an {@link ImageNode}.
+ */
+export declare function $isImageNode(node: LexicalNode | null | undefined): node is ImageNode;

package/dist/plugins/image/ImageNode.js

@@ -0,0 +1,108 @@
+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;
+};
+import React__default from "react";
+import { DecoratorNode } from "lexical";
+import { ImageEditor } from "./ImageEditor.js";
+function convertImageElement(domNode) {
+  if (domNode instanceof HTMLImageElement) {
+    const { alt: altText, src, title } = domNode;
+    const node = $createImageNode({ altText, src, title });
+    return { node };
+  }
+  return null;
+}
+class ImageNode extends DecoratorNode {
+  constructor(src, altText, title, key) {
+    super(key);
+    __publicField(this, "__src");
+    __publicField(this, "__altText");
+    __publicField(this, "__title");
+    this.__src = src;
+    this.__title = title;
+    this.__altText = altText;
+  }
+  static getType() {
+    return "image";
+  }
+  static clone(node) {
+    return new ImageNode(node.__src, node.__altText, node.__title, node.__key);
+  }
+  static importJSON(serializedNode) {
+    const { altText, title, src } = serializedNode;
+    const node = $createImageNode({
+      altText,
+      title,
+      src
+    });
+    return node;
+  }
+  exportDOM() {
+    const element = document.createElement("img");
+    element.setAttribute("src", this.__src);
+    element.setAttribute("alt", this.__altText);
+    if (this.__title) {
+      element.setAttribute("title", this.__title);
+    }
+    return { element };
+  }
+  static importDOM() {
+    return {
+      img: () => ({
+        conversion: convertImageElement,
+        priority: 0
+      })
+    };
+  }
+  exportJSON() {
+    return {
+      altText: this.getAltText(),
+      title: this.getTitle(),
+      src: this.getSrc(),
+      type: "image",
+      version: 1
+    };
+  }
+  createDOM(config) {
+    const span = document.createElement("span");
+    const theme = config.theme;
+    const className = theme.image;
+    if (className !== void 0) {
+      span.className = className;
+    }
+    return span;
+  }
+  updateDOM() {
+    return false;
+  }
+  getSrc() {
+    return this.__src;
+  }
+  getAltText() {
+    return this.__altText;
+  }
+  getTitle() {
+    return this.__title;
+  }
+  setTitle(title) {
+    this.getWritable().__title = title;
+  }
+  decorate(_parentEditor) {
+    return /* @__PURE__ */ React__default.createElement(ImageEditor, { src: this.getSrc(), title: this.getTitle(), nodeKey: this.getKey() });
+  }
+}
+function $createImageNode(options) {
+  const { altText, title, src, key } = options;
+  return new ImageNode(src, altText, title, key);
+}
+function $isImageNode(node) {
+  return node instanceof ImageNode;
+}
+export {
+  $createImageNode,
+  $isImageNode,
+  ImageNode
+};

package/dist/plugins/image/LexicalImageVisitor.d.ts

@@ -0,0 +1,4 @@
+import * as Mdast from 'mdast';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+import { ImageNode } from './ImageNode';
+export declare const LexicalImageVisitor: LexicalExportVisitor<ImageNode, Mdast.Image>;

package/dist/plugins/image/LexicalImageVisitor.js

@@ -0,0 +1,15 @@
+import { $isImageNode } from "./ImageNode.js";
+const LexicalImageVisitor = {
+  testLexicalNode: $isImageNode,
+  visitLexicalNode({ mdastParent, lexicalNode, actions }) {
+    actions.appendToParent(mdastParent, {
+      type: "image",
+      url: lexicalNode.getSrc(),
+      alt: lexicalNode.getAltText(),
+      title: lexicalNode.getTitle()
+    });
+  }
+};
+export {
+  LexicalImageVisitor
+};

package/dist/plugins/image/MdastImageVisitor.d.ts

@@ -0,0 +1,3 @@
+import * as Mdast from 'mdast';
+import { MdastImportVisitor } from '../../importMarkdownToLexical';
+export declare const MdastImageVisitor: MdastImportVisitor<Mdast.Image>;

package/dist/plugins/image/MdastImageVisitor.js

@@ -0,0 +1,16 @@
+import { $createImageNode } from "./ImageNode.js";
+const MdastImageVisitor = {
+  testNode: "image",
+  visitNode({ mdastNode, actions }) {
+    actions.addAndStepInto(
+      $createImageNode({
+        src: mdastNode.url,
+        altText: mdastNode.alt || "",
+        title: mdastNode.title || ""
+      })
+    );
+  }
+};
+export {
+  MdastImageVisitor
+};