@mdxeditor/editor 0.4.1 → 0.5.0

package/dist/index-11db5fbf.js

@@ -0,0 +1,3884 @@
+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 { LexicalComposer } from "@lexical/react/LexicalComposer";
+import { ContentEditable } from "@lexical/react/LexicalContentEditable";
+import LexicalErrorBoundary from "@lexical/react/LexicalErrorBoundary";
+import { HorizontalRulePlugin } from "@lexical/react/LexicalHorizontalRulePlugin";
+import { LinkPlugin } from "@lexical/react/LexicalLinkPlugin";
+import { ListPlugin } from "@lexical/react/LexicalListPlugin";
+import { RichTextPlugin } from "@lexical/react/LexicalRichTextPlugin";
+import { TabIndentationPlugin } from "@lexical/react/LexicalTabIndentationPlugin";
+import classNames from "classnames";
+import { ElementNode, $createParagraphNode, $applyNodeReplacement, DecoratorNode, createEditor, $getRoot, $isRootNode, $isParagraphNode, $isLineBreakNode, $isTextNode, $isElementNode, ParagraphNode, $createTextNode, $getSelection, $isRangeSelection, DEPRECATED_$isGridSelection, FORMAT_TEXT_COMMAND, $isRootOrShadowRoot, SELECTION_CHANGE_COMMAND, COMMAND_PRIORITY_CRITICAL, BLUR_COMMAND, COMMAND_PRIORITY_LOW, FOCUS_COMMAND, KEY_ESCAPE_COMMAND, KEY_MODIFIER_COMMAND, COMMAND_PRIORITY_HIGH, createCommand, INDENT_CONTENT_COMMAND, $getNodeByKey } from "lexical";
+import * as React from "react";
+import React__default, { createContext, forwardRef, useMemo, useImperativeHandle, createElement, useCallback, useContext, useState, useEffect } from "react";
+import { CodeNode } from "@lexical/code";
+import { $isLinkNode, LinkNode, $createLinkNode, TOGGLE_LINK_COMMAND } from "@lexical/link";
+import { $isListNode, $isListItemNode, ListNode, ListItemNode, $createListNode, $createListItemNode, INSERT_ORDERED_LIST_COMMAND, INSERT_UNORDERED_LIST_COMMAND, REMOVE_LIST_COMMAND, $getListDepth } from "@lexical/list";
+import { $isHorizontalRuleNode, HorizontalRuleNode, $createHorizontalRuleNode, INSERT_HORIZONTAL_RULE_COMMAND } from "@lexical/react/LexicalHorizontalRuleNode";
+import { $isHeadingNode, $isQuoteNode, HeadingNode, QuoteNode, $createHeadingNode, $createQuoteNode } from "@lexical/rich-text";
+import { directiveToMarkdown, directiveFromMarkdown } from "mdast-util-directive";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { frontmatterToMarkdown, frontmatterFromMarkdown } from "mdast-util-frontmatter";
+import { gfmTableToMarkdown, gfmTableFromMarkdown } from "mdast-util-gfm-table";
+import { mdxToMarkdown, mdxFromMarkdown } from "mdast-util-mdx";
+import { directive } from "micromark-extension-directive";
+import { frontmatter } from "micromark-extension-frontmatter";
+import { gfmTable } from "micromark-extension-gfm-table";
+import { mdxjs } from "micromark-extension-mdxjs";
+import { addClassNamesToElement, $insertNodeToNearestRoot, $findMatchingParent, $getNearestNodeOfType } from "@lexical/utils";
+import { useLexicalComposerContext } from "@lexical/react/LexicalComposerContext";
+import { $setBlocksType, $isAtNodeEnd } from "@lexical/selection";
+import { createEmptyHistoryState, HistoryPlugin } from "@lexical/react/LexicalHistoryPlugin";
+import { toMarkdown } from "mdast-util-to-markdown";
+import * as RadixPopover from "@radix-ui/react-popover";
+import * as Tooltip from "@radix-ui/react-tooltip";
+import { useCombobox } from "downshift";
+import { CODE, TRANSFORMERS } from "@lexical/markdown";
+import { MarkdownShortcutPlugin } from "@lexical/react/LexicalMarkdownShortcutPlugin";
+import { markdown } from "@codemirror/lang-markdown";
+import { SandpackProvider, CodeEditor } from "@codesandbox/sandpack-react";
+import { parseDiff, Diff, Hunk } from "react-diff-view";
+import { formatLines, diffLines } from "unidiff";
+import * as RadixToolbar from "@radix-ui/react-toolbar";
+import * as Select from "@radix-ui/react-select";
+import * as Dialog from "@radix-ui/react-dialog";
+class AdmonitionNode extends ElementNode {
+  constructor(kind, key) {
+    super(key);
+    __publicField(this, "__kind");
+    this.__kind = kind || "note";
+  }
+  static getType() {
+    return "admonition";
+  }
+  getKind() {
+    return this.getLatest().__kind;
+  }
+  setKind(kind) {
+    if (kind !== this.getKind()) {
+      this.getWritable().__kind = kind;
+    }
+  }
+  static clone(node) {
+    return new AdmonitionNode(node.__kind, node.__key);
+  }
+  // View
+  createDOM(config) {
+    const element = document.createElement("div");
+    addClassNamesToElement(element, config.theme.admonition[this.__kind]);
+    return element;
+  }
+  updateDOM(_prevNode, _dom) {
+    return false;
+  }
+  // TODO:
+  // static importDOM(): DOMConversionMap | null {
+  //   return {
+  //     blockquote: (node: Node) => ({
+  //       conversion: convertBlockquoteElement,
+  //       priority: 0,
+  //     }),
+  //   }
+  // }
+  static importJSON(serializedNode) {
+    const node = $createAdmonitionNode(serializedNode.kind);
+    return node;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      type: "admonition"
+    };
+  }
+  // Mutation
+  insertNewAfter(_, restoreSelection) {
+    const newBlock = $createAdmonitionNode();
+    this.insertAfter(newBlock, restoreSelection);
+    return newBlock;
+  }
+  collapseAtStart() {
+    const paragraph = $createParagraphNode();
+    const children = this.getChildren();
+    children.forEach((child) => paragraph.append(child));
+    this.replace(paragraph);
+    return true;
+  }
+}
+function $createAdmonitionNode(kind) {
+  return $applyNodeReplacement(new AdmonitionNode(kind));
+}
+function $isAdmonitionNode(node) {
+  return node instanceof AdmonitionNode;
+}
+function tap(arg, proc) {
+  proc(arg);
+  return arg;
+}
+function always(value) {
+  return () => value;
+}
+function noop() {
+}
+function voidEmitter$1() {
+  let subscription = noop;
+  return {
+    publish: () => {
+      subscription();
+    },
+    subscribe: (cb) => {
+      subscription = cb;
+    }
+  };
+}
+class CodeBlockNode extends DecoratorNode {
+  constructor(code2, language, meta, key) {
+    super(key);
+    __publicField(this, "__code");
+    __publicField(this, "__meta");
+    __publicField(this, "__language");
+    __publicField(this, "__focusEmitter", voidEmitter$1());
+    this.__code = code2;
+    this.__meta = meta;
+    this.__language = language;
+  }
+  static getType() {
+    return "codeblock";
+  }
+  static clone(node) {
+    return new CodeBlockNode(node.__code, node.__language, node.__meta, node.__key);
+  }
+  static importJSON(serializedNode) {
+    const { code: code2, meta, language } = serializedNode;
+    return $createCodeBlockNode({
+      code: code2,
+      language,
+      meta
+    });
+  }
+  exportJSON() {
+    return {
+      code: this.getCode(),
+      language: this.getLanguage(),
+      meta: this.getMeta(),
+      type: "codeblock",
+      version: 1
+    };
+  }
+  // View
+  createDOM(_config) {
+    return document.createElement("div");
+  }
+  updateDOM() {
+    return false;
+  }
+  getCode() {
+    return this.getLatest().__code;
+  }
+  getMeta() {
+    return this.getLatest().__meta;
+  }
+  getLanguage() {
+    return this.getLatest().__language;
+  }
+  setCode(code2) {
+    if (code2 !== this.__code) {
+      this.getWritable().__code = code2;
+    }
+  }
+  setMeta(meta) {
+    if (meta !== this.__meta) {
+      this.getWritable().__meta = meta;
+    }
+  }
+  setLanguage(language) {
+    if (language !== this.__language) {
+      this.getWritable().__language = language;
+    }
+  }
+  select() {
+    this.__focusEmitter.publish();
+  }
+  decorate(_editor, {
+    theme: {
+      nodeDecoratorComponents: { CodeBlockEditor }
+    }
+  }) {
+    return /* @__PURE__ */ React__default.createElement(
+      CodeBlockEditor,
+      {
+        nodeKey: this.getKey(),
+        code: this.getCode(),
+        meta: this.getMeta(),
+        language: this.getLanguage(),
+        onChange: (code2) => this.setCode(code2),
+        focusEmitter: this.__focusEmitter
+      }
+    );
+  }
+}
+function $createCodeBlockNode(options) {
+  const { code: code2, language, meta } = options;
+  return new CodeBlockNode(code2, language, meta);
+}
+function $isCodeBlockNode(node) {
+  return node instanceof CodeBlockNode;
+}
+class FrontmatterNode extends DecoratorNode {
+  constructor(code2, key) {
+    super(key);
+    __publicField(this, "__yaml");
+    this.__yaml = code2;
+  }
+  static getType() {
+    return "frontmatter";
+  }
+  static clone(node) {
+    return new FrontmatterNode(node.__yaml, node.__key);
+  }
+  static importJSON(serializedNode) {
+    const { yaml } = serializedNode;
+    const node = $createFrontmatterNode(yaml);
+    return node;
+  }
+  exportJSON() {
+    return {
+      yaml: this.getYaml(),
+      type: "frontmatter",
+      version: 1
+    };
+  }
+  // View
+  createDOM(_config) {
+    return document.createElement("div");
+  }
+  updateDOM() {
+    return false;
+  }
+  getYaml() {
+    return this.getLatest().__yaml;
+  }
+  setYaml(yaml) {
+    if (yaml !== this.__yaml) {
+      this.getWritable().__yaml = yaml;
+    }
+  }
+  decorate(editor, {
+    theme: {
+      nodeDecoratorComponents: { FrontmatterEditor }
+    }
+  }) {
+    return /* @__PURE__ */ React__default.createElement(
+      FrontmatterEditor,
+      {
+        yaml: this.getYaml(),
+        onChange: (yaml) => editor == null ? void 0 : editor.update(() => {
+          this.setYaml(yaml);
+        })
+      }
+    );
+  }
+}
+function $createFrontmatterNode(yaml) {
+  return new FrontmatterNode(yaml);
+}
+function $isFrontmatterNode(node) {
+  return node instanceof FrontmatterNode;
+}
+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 theme2 = config.theme;
+    const className = theme2.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() {
+    return /* @__PURE__ */ React__default.createElement("img", { title: this.__title, src: this.__src, alt: this.__altText });
+  }
+}
+function $createImageNode(options) {
+  const { altText, title, src, key } = options;
+  return new ImageNode(src, altText, title, key);
+}
+function $isImageNode(node) {
+  return node instanceof ImageNode;
+}
+const darkTheme = "_dark-theme_13nbk_1";
+const bold = "_bold_13nbk_10";
+const italic = "_italic_13nbk_14";
+const underline = "_underline_13nbk_18";
+const strikethrough = "_strikethrough_13nbk_34";
+const underlineStrikethrough = "_underlineStrikethrough_13nbk_38";
+const subscript = "_subscript_13nbk_42";
+const superscript = "_superscript_13nbk_47";
+const code = "_code_13nbk_52";
+const nestedListItem$1 = "_nestedListItem_13nbk_59";
+const admonitionDanger = "_admonitionDanger_13nbk_63";
+const admonitionInfo = "_admonitionInfo_13nbk_63";
+const admonitionNote = "_admonitionNote_13nbk_63";
+const admonitionTip = "_admonitionTip_13nbk_63";
+const admonitionCaution = "_admonitionCaution_13nbk_63";
+const styles$1 = {
+  darkTheme,
+  bold,
+  italic,
+  underline,
+  strikethrough,
+  underlineStrikethrough,
+  subscript,
+  superscript,
+  code,
+  nestedListItem: nestedListItem$1,
+  admonitionDanger,
+  admonitionInfo,
+  admonitionNote,
+  admonitionTip,
+  admonitionCaution
+};
+const theme = {
+  text: {
+    bold: styles$1.bold,
+    italic: styles$1.italic,
+    underline: styles$1.underline,
+    code: styles$1.code,
+    strikethrough: styles$1.strikethrough,
+    subscript: styles$1.subscript,
+    superscript: styles$1.superscript,
+    underlineStrikethrough: styles$1.underlineStrikethrough
+  },
+  list: {
+    nested: {
+      listitem: styles$1.nestedListItem
+    }
+  },
+  admonition: {
+    danger: styles$1.admonitionDanger,
+    info: styles$1.admonitionInfo,
+    note: styles$1.admonitionNote,
+    tip: styles$1.admonitionTip,
+    caution: styles$1.admonitionCaution
+  }
+};
+const EmptySerializedTextEditorState = {
+  type: "root",
+  format: "left",
+  indent: 0,
+  direction: "ltr",
+  version: 1,
+  children: [
+    {
+      type: "paragraph",
+      version: 1,
+      direction: "ltr",
+      format: "left",
+      indent: 0,
+      children: []
+    }
+  ]
+};
+const EmptySerializedFlowEditorState = {
+  type: "root",
+  format: "left",
+  indent: 0,
+  direction: "ltr",
+  version: 1,
+  children: []
+};
+class JsxNode extends DecoratorNode {
+  constructor({ name, kind, attributes, state, updateFn, key }) {
+    super(key);
+    __publicField(this, "__kind");
+    __publicField(this, "__name");
+    __publicField(this, "__attributes");
+    __publicField(this, "__editor");
+    if (!attributes) {
+      debugger;
+    }
+    this.__name = name;
+    this.__kind = kind;
+    this.__attributes = attributes;
+    this.__editor = createEditor();
+    if (state) {
+      const parsedState = this.__editor.parseEditorState(state);
+      if (!parsedState.isEmpty()) {
+        this.__editor.setEditorState(parsedState);
+      }
+    } else if (updateFn) {
+      const parsedState = this.__editor.parseEditorState(
+        { root: this.getKind() === "text" ? EmptySerializedTextEditorState : EmptySerializedFlowEditorState },
+        () => {
+          if (this.getKind() === "text") {
+            const rootParagraph = $getRoot().getFirstChildOrThrow();
+            updateFn(rootParagraph);
+          } else {
+            updateFn($getRoot());
+          }
+        }
+      );
+      if (!parsedState.isEmpty()) {
+        this.__editor.setEditorState(parsedState);
+      }
+    }
+  }
+  static getType() {
+    return "jsx";
+  }
+  static clone(node) {
+    return new JsxNode({
+      name: node.__name,
+      kind: node.__kind,
+      attributes: node.__attributes,
+      state: node.__editor.getEditorState().toJSON()
+    });
+  }
+  static importJSON(serializedNode) {
+    const { name, kind, attributes, state } = serializedNode;
+    return $createJsxNode({
+      kind,
+      name,
+      attributes,
+      state
+    });
+  }
+  exportJSON() {
+    return {
+      name: this.getName(),
+      kind: this.getKind(),
+      attributes: this.getAttributes(),
+      state: this.__editor.getEditorState().toJSON(),
+      type: "jsx",
+      version: 1
+    };
+  }
+  inNestedEditor(callback) {
+    this.__editor.getEditorState().read(callback);
+  }
+  getChildren() {
+    if (this.getKey() === "flow") {
+      return $getRoot().getChildren() || [];
+    } else {
+      const firstChild = $getRoot().getFirstChild();
+      if (!firstChild) {
+        return [];
+      }
+      return firstChild.getChildren() || [];
+    }
+  }
+  createDOM() {
+    if (this.getKey() === "flow") {
+      return document.createElement("div");
+    } else {
+      return document.createElement("span");
+    }
+  }
+  updateDOM() {
+    return false;
+  }
+  getName() {
+    return this.__name;
+  }
+  getKind() {
+    return this.__kind;
+  }
+  getAttributes() {
+    return this.__attributes;
+  }
+  updateAttributes(attributeValues) {
+    this.getWritable().__attributes = Object.entries(attributeValues).map(([name, value]) => {
+      return { name, value };
+    });
+  }
+  decorate(_parentEditor, {
+    theme: {
+      nodeDecoratorComponents: { JsxEditor }
+    }
+  }) {
+    return /* @__PURE__ */ React__default.createElement(
+      JsxEditor,
+      {
+        attributes: this.getAttributes(),
+        componentName: this.getName(),
+        kind: this.getKind(),
+        editor: this.__editor,
+        onSubmit: (attributeValues) => this.updateAttributes(attributeValues),
+        theme
+      }
+    );
+  }
+}
+function $createJsxNode(options) {
+  return new JsxNode(options);
+}
+function $isJsxNode(node) {
+  return node instanceof JsxNode;
+}
+function voidEmitter() {
+  let subscription = noop;
+  return {
+    publish: () => {
+      subscription();
+    },
+    subscribe: (cb) => {
+      subscription = cb;
+    }
+  };
+}
+class SandpackNode extends DecoratorNode {
+  constructor(code2, language, meta, key) {
+    super(key);
+    __publicField(this, "__code");
+    __publicField(this, "__meta");
+    __publicField(this, "__language");
+    __publicField(this, "__focusEmitter", voidEmitter());
+    this.__code = code2;
+    this.__meta = meta;
+    this.__language = language;
+  }
+  static getType() {
+    return "sandpack";
+  }
+  static clone(node) {
+    return new SandpackNode(node.__code, node.__language, node.__meta, node.__key);
+  }
+  static importJSON(serializedNode) {
+    const { code: code2, meta, language } = serializedNode;
+    return $createSandpackNode({
+      code: code2,
+      language,
+      meta
+    });
+  }
+  exportJSON() {
+    return {
+      code: this.getCode(),
+      language: this.getLanguage(),
+      meta: this.getMeta(),
+      type: "sandpack",
+      version: 1
+    };
+  }
+  // View
+  createDOM(_config) {
+    return document.createElement("div");
+  }
+  updateDOM() {
+    return false;
+  }
+  getCode() {
+    return this.getLatest().__code;
+  }
+  getMeta() {
+    return this.getLatest().__meta;
+  }
+  getLanguage() {
+    return this.getLatest().__language;
+  }
+  setCode(code2) {
+    if (code2 !== this.__code) {
+      this.getWritable().__code = code2;
+    }
+  }
+  setMeta(meta) {
+    if (meta !== this.__meta) {
+      this.getWritable().__meta = meta;
+    }
+  }
+  setLanguage(language) {
+    if (language !== this.__language) {
+      this.getWritable().__language = language;
+    }
+  }
+  select() {
+    this.__focusEmitter.publish();
+  }
+  decorate(_parentEditor, {
+    theme: {
+      nodeDecoratorComponents: { SandpackEditor }
+    }
+  }) {
+    return /* @__PURE__ */ React__default.createElement(
+      SandpackEditor,
+      {
+        nodeKey: this.getKey(),
+        code: this.getCode(),
+        meta: this.getMeta(),
+        onChange: (code2) => this.setCode(code2),
+        focusEmitter: this.__focusEmitter
+      }
+    );
+  }
+}
+function $createSandpackNode(options) {
+  const { code: code2, language, meta } = options;
+  return new SandpackNode(code2, language, meta);
+}
+function $isSandpackNode(node) {
+  return node instanceof SandpackNode;
+}
+const EMPTY_CELL = { type: "tableCell", children: [] };
+function coordinatesEmitter() {
+  let subscription = noop;
+  return {
+    publish: (coords) => {
+      subscription(coords);
+    },
+    subscribe: (cb) => {
+      subscription = cb;
+    }
+  };
+}
+class TableNode extends DecoratorNode {
+  constructor(mdastNode, key) {
+    super(key);
+    __publicField(this, "__mdastNode");
+    __publicField(this, "focusEmitter", coordinatesEmitter());
+    this.__mdastNode = mdastNode || { type: "table", children: [] };
+  }
+  static getType() {
+    return "table";
+  }
+  static clone(node) {
+    return new TableNode(structuredClone(node.__mdastNode), node.__key);
+  }
+  static importJSON(serializedNode) {
+    return $createTableNode(serializedNode.mdastNode);
+  }
+  exportJSON() {
+    return {
+      mdastNode: structuredClone(this.__mdastNode),
+      type: "table",
+      version: 1
+    };
+  }
+  getMdastNode() {
+    return this.__mdastNode;
+  }
+  getRowCount() {
+    return this.__mdastNode.children.length;
+  }
+  getColCount() {
+    var _a;
+    return ((_a = this.__mdastNode.children[0]) == null ? void 0 : _a.children.length) || 0;
+  }
+  createDOM() {
+    return document.createElement("div");
+  }
+  updateDOM() {
+    return false;
+  }
+  updateCellContents(colIndex, rowIndex, children) {
+    const self = this.getWritable();
+    const table = self.__mdastNode;
+    const row = table.children[rowIndex];
+    const cells = row.children;
+    const cell = cells[colIndex];
+    const cellsClone = Array.from(cells);
+    const cellClone = { ...cell, children };
+    const rowClone = { ...row, children: cellsClone };
+    cellsClone[colIndex] = cellClone;
+    table.children[rowIndex] = rowClone;
+  }
+  insertColumnAt(colIndex) {
+    const self = this.getWritable();
+    const table = self.__mdastNode;
+    for (let rowIndex = 0; rowIndex < table.children.length; rowIndex++) {
+      const row = table.children[rowIndex];
+      const cells = row.children;
+      const cellsClone = Array.from(cells);
+      const rowClone = { ...row, children: cellsClone };
+      cellsClone.splice(colIndex, 0, structuredClone(EMPTY_CELL));
+      table.children[rowIndex] = rowClone;
+    }
+    if (table.align && table.align.length > 0) {
+      table.align.splice(colIndex, 0, "left");
+    }
+  }
+  deleteColumnAt(colIndex) {
+    const self = this.getWritable();
+    const table = self.__mdastNode;
+    for (let rowIndex = 0; rowIndex < table.children.length; rowIndex++) {
+      const row = table.children[rowIndex];
+      const cells = row.children;
+      const cellsClone = Array.from(cells);
+      const rowClone = { ...row, children: cellsClone };
+      cellsClone.splice(colIndex, 1);
+      table.children[rowIndex] = rowClone;
+    }
+  }
+  insertRowAt(y) {
+    const self = this.getWritable();
+    const table = self.__mdastNode;
+    const newRow = {
+      type: "tableRow",
+      children: Array.from({ length: this.getColCount() }, () => structuredClone(EMPTY_CELL))
+    };
+    table.children.splice(y, 0, newRow);
+  }
+  deleteRowAt(rowIndex) {
+    this.getWritable().__mdastNode.children.splice(rowIndex, 1);
+  }
+  addRowToBottom() {
+    this.insertRowAt(this.getRowCount());
+  }
+  addColumnToRight() {
+    this.insertColumnAt(this.getColCount());
+  }
+  setColumnAlign(colIndex, align) {
+    const self = this.getWritable();
+    const table = self.__mdastNode;
+    if (table.align == null) {
+      table.align = [];
+    }
+    table.align[colIndex] = align;
+  }
+  decorate(parentEditor, {
+    theme: {
+      nodeDecoratorComponents: { TableEditor }
+    }
+  }) {
+    return /* @__PURE__ */ React__default.createElement(TableEditor, { lexicalTable: this, mdastNode: this.__mdastNode, parentEditor });
+  }
+  select(coords) {
+    this.focusEmitter.publish(coords);
+  }
+  isInline() {
+    return false;
+  }
+}
+function $isTableNode(node) {
+  return node instanceof TableNode;
+}
+function $createTableNode(mdastNode) {
+  return new TableNode(mdastNode);
+}
+const IS_BOLD = 1;
+const IS_ITALIC = 2;
+const IS_UNDERLINE = 8;
+const IS_CODE = 16;
+const LexicalRootVisitor = {
+  testLexicalNode: $isRootNode,
+  visitLexicalNode: ({ actions }) => {
+    actions.addAndStepInto("root");
+  }
+};
+const LexicalParagraphVisitor = {
+  testLexicalNode: $isParagraphNode,
+  visitLexicalNode: ({ actions }) => {
+    actions.addAndStepInto("paragraph");
+  }
+};
+const LexicalFrontmatterVisitor = {
+  testLexicalNode: $isFrontmatterNode,
+  visitLexicalNode: ({ actions, lexicalNode }) => {
+    actions.addAndStepInto("yaml", { value: lexicalNode.getYaml() });
+  }
+};
+const LexicalLinkVisitor = {
+  testLexicalNode: $isLinkNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    actions.addAndStepInto("link", { url: lexicalNode.getURL(), title: lexicalNode.getTitle() });
+  }
+};
+const LexicalHeadingVisitor = {
+  testLexicalNode: $isHeadingNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    const depth = parseInt(lexicalNode.getTag()[1], 10);
+    actions.addAndStepInto("heading", { depth });
+  }
+};
+const LexicalListVisitor = {
+  testLexicalNode: $isListNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    actions.addAndStepInto("list", {
+      ordered: lexicalNode.getListType() === "number",
+      //TODO: figure out when spread can be true
+      spread: false
+    });
+  }
+};
+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);
+      actions.visitChildren(lexicalNode, prevListItemNode);
+    } else {
+      const listItem = actions.appendToParent(mdastParent, {
+        type: "listItem",
+        spread: false,
+        children: [{ type: "paragraph", children: [] }]
+      });
+      actions.visitChildren(lexicalNode, listItem.children[0]);
+    }
+  }
+};
+const LexicalQuoteVisitor = {
+  testLexicalNode: $isQuoteNode,
+  visitLexicalNode: ({ lexicalNode, mdastParent, actions }) => {
+    const blockquote = actions.appendToParent(mdastParent, {
+      type: "blockquote",
+      children: [{ type: "paragraph", children: [] }]
+    });
+    actions.visitChildren(lexicalNode, blockquote.children[0]);
+  }
+};
+const AdmonitionVisitor = {
+  testLexicalNode: $isAdmonitionNode,
+  visitLexicalNode: ({ mdastParent, lexicalNode, actions }) => {
+    const admonition = actions.appendToParent(mdastParent, {
+      type: "containerDirective",
+      name: lexicalNode.getKind(),
+      children: [{ type: "paragraph", children: [] }]
+    });
+    actions.visitChildren(lexicalNode, admonition.children[0]);
+  }
+};
+const SandpackNodeVisitor = {
+  testLexicalNode: $isSandpackNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    actions.addAndStepInto("code", {
+      value: lexicalNode.getCode(),
+      lang: lexicalNode.getLanguage(),
+      meta: lexicalNode.getMeta()
+    });
+  }
+};
+const CodeBlockVisitor = {
+  testLexicalNode: $isCodeBlockNode,
+  visitLexicalNode: ({ lexicalNode, actions }) => {
+    actions.addAndStepInto("code", {
+      value: lexicalNode.getCode(),
+      lang: lexicalNode.getLanguage(),
+      meta: lexicalNode.getMeta()
+    });
+  }
+};
+function isMdastText(mdastNode) {
+  return mdastNode.type === "text";
+}
+const LexicalLinebreakVisitor = {
+  testLexicalNode: $isLineBreakNode,
+  visitLexicalNode: ({ mdastParent, actions }) => {
+    actions.appendToParent(mdastParent, { type: "text", value: "\n" });
+  }
+};
+const LexicalTextVisitor = {
+  shouldJoin: (prevNode, currentNode) => {
+    return ["text", "emphasis", "strong", "mdxJsxTextElement"].includes(prevNode.type) && prevNode.type === currentNode.type;
+  },
+  join(prevNode, currentNode) {
+    if (isMdastText(prevNode) && isMdastText(currentNode)) {
+      return {
+        type: "text",
+        value: prevNode.value + currentNode.value
+      };
+    } else {
+      return {
+        ...prevNode,
+        children: [...prevNode.children, ...currentNode.children]
+      };
+    }
+  },
+  testLexicalNode: $isTextNode,
+  visitLexicalNode: ({ lexicalNode, mdastParent, actions }) => {
+    const previousSibling = lexicalNode.getPreviousSibling();
+    const prevFormat = $isTextNode(previousSibling) ? previousSibling.getFormat() : 0;
+    const textContent = lexicalNode.getTextContent();
+    const format = lexicalNode.getFormat() ?? 0;
+    if (format & IS_CODE) {
+      actions.addAndStepInto("inlineCode", {
+        value: textContent
+      });
+      return;
+    }
+    let localParentNode = mdastParent;
+    if (prevFormat & format & IS_ITALIC) {
+      localParentNode = actions.appendToParent(localParentNode, {
+        type: "emphasis",
+        children: []
+      });
+    }
+    if (prevFormat & format & IS_BOLD) {
+      localParentNode = actions.appendToParent(localParentNode, {
+        type: "strong",
+        children: []
+      });
+    }
+    if (prevFormat & format & IS_UNDERLINE) {
+      localParentNode = actions.appendToParent(localParentNode, {
+        type: "mdxJsxTextElement",
+        name: "u",
+        children: [],
+        attributes: []
+      });
+    }
+    if (format & IS_ITALIC && !(prevFormat & IS_ITALIC)) {
+      localParentNode = actions.appendToParent(localParentNode, {
+        type: "emphasis",
+        children: []
+      });
+    }
+    if (format & IS_BOLD && !(prevFormat & IS_BOLD)) {
+      localParentNode = actions.appendToParent(localParentNode, {
+        type: "strong",
+        children: []
+      });
+    }
+    if (format & IS_UNDERLINE && !(prevFormat & IS_UNDERLINE)) {
+      localParentNode = actions.appendToParent(localParentNode, {
+        type: "mdxJsxTextElement",
+        name: "u",
+        children: [],
+        attributes: []
+      });
+    }
+    actions.appendToParent(localParentNode, {
+      type: "text",
+      value: textContent
+    });
+  }
+};
+const LexicalThematicBreakVisitor = {
+  testLexicalNode: $isHorizontalRuleNode,
+  visitLexicalNode({ actions }) {
+    actions.addAndStepInto("thematicBreak");
+  }
+};
+const LexicalImageVisitor = {
+  testLexicalNode: $isImageNode,
+  visitLexicalNode({ lexicalNode, actions }) {
+    actions.addAndStepInto("image", {
+      url: lexicalNode.getSrc(),
+      alt: lexicalNode.getAltText(),
+      title: lexicalNode.getTitle()
+    });
+  }
+};
+const LexicalTableVisitor = {
+  testLexicalNode: $isTableNode,
+  visitLexicalNode({ actions, mdastParent, lexicalNode }) {
+    actions.appendToParent(mdastParent, lexicalNode.getMdastNode());
+  }
+};
+const JsxVisitor = {
+  testLexicalNode: $isJsxNode,
+  visitLexicalNode({ mdastParent, lexicalNode, actions }) {
+    const nodeType = lexicalNode.getKind() === "text" ? "mdxJsxTextElement" : "mdxJsxFlowElement";
+    actions.registerReferredComponent(lexicalNode.getName());
+    const node = {
+      type: nodeType,
+      name: lexicalNode.getName(),
+      attributes: lexicalNode.getAttributes(),
+      children: []
+    };
+    actions.appendToParent(mdastParent, node);
+    lexicalNode.inNestedEditor(() => {
+      actions.visitChildren(lexicalNode, node);
+    });
+  }
+};
+const defaultLexicalVisitors = {
+  LexicalRootVisitor,
+  LexicalParagraphVisitor,
+  LexicalFrontmatterVisitor,
+  LexicalTextVisitor,
+  LexicalLinebreakVisitor,
+  LexicalLinkVisitor,
+  LexicalHeadingVisitor,
+  LexicalListVisitor,
+  LexicalListItemVisitor,
+  LexicalQuoteVisitor,
+  SandpackNodeVisitor,
+  CodeBlockVisitor,
+  LexicalThematicBreakVisitor,
+  AdmonitionVisitor,
+  LexicalImageVisitor,
+  JsxVisitor,
+  LexicalTableVisitor
+};
+function isParent$1(node) {
+  return node.children instanceof Array;
+}
+function exportLexicalTreeToMdast({ root, visitors, jsxComponentDescriptors }) {
+  let unistRoot = null;
+  const referredComponents = /* @__PURE__ */ new Set();
+  visit(root, null);
+  function registerReferredComponent(componentName) {
+    referredComponents.add(componentName);
+  }
+  function appendToParent(parentNode, node) {
+    if (unistRoot === null) {
+      unistRoot = node;
+      return unistRoot;
+    }
+    if (!isParent$1(parentNode)) {
+      throw new Error("Attempting to append children to a non-parent");
+    }
+    const siblings = parentNode.children;
+    const prevSibling = siblings.at(-1);
+    if (prevSibling) {
+      const joinVisitor = visitors.find((visitor) => {
+        var _a;
+        return (_a = visitor.shouldJoin) == null ? void 0 : _a.call(visitor, prevSibling, node);
+      });
+      if (joinVisitor) {
+        const joinedNode = joinVisitor.join(prevSibling, node);
+        siblings.splice(siblings.length - 1, 1, joinedNode);
+        return joinedNode;
+      }
+    }
+    siblings.push(node);
+    return node;
+  }
+  function visitChildren(lexicalNode, parentNode) {
+    lexicalNode.getChildren().forEach((lexicalChild) => {
+      visit(lexicalChild, parentNode);
+    });
+  }
+  function visit(lexicalNode, mdastParent) {
+    var _a;
+    const visitor = visitors.find((visitor2) => {
+      var _a2;
+      return (_a2 = visitor2.testLexicalNode) == null ? void 0 : _a2.call(visitor2, lexicalNode);
+    });
+    if (!visitor) {
+      throw new Error(`no lexical visitor found for ${lexicalNode.getType()}`, {
+        cause: lexicalNode
+      });
+    }
+    (_a = visitor.visitLexicalNode) == null ? void 0 : _a.call(visitor, {
+      lexicalNode,
+      mdastParent,
+      actions: {
+        addAndStepInto(type, props = {}, hasChildren = true) {
+          const newNode = {
+            type,
+            ...props,
+            ...hasChildren ? { children: [] } : {}
+          };
+          appendToParent(mdastParent, newNode);
+          if ($isElementNode(lexicalNode) && hasChildren) {
+            visitChildren(lexicalNode, newNode);
+          }
+        },
+        appendToParent,
+        visitChildren,
+        registerReferredComponent
+      }
+    });
+  }
+  if (unistRoot === null) {
+    throw new Error("traversal ended with no root element");
+  }
+  const importsMap = /* @__PURE__ */ new Map();
+  const defaultImportsMap = /* @__PURE__ */ new Map();
+  for (const componentName of referredComponents) {
+    const descriptor = jsxComponentDescriptors.find((descriptor2) => descriptor2.name === componentName);
+    if (!descriptor) {
+      throw new Error(`Component ${componentName} is used but not imported`);
+    }
+    if (descriptor.defaultExport) {
+      defaultImportsMap.set(componentName, descriptor.source);
+    } else {
+      const { source } = descriptor;
+      const existing = importsMap.get(source);
+      if (existing) {
+        existing.push(componentName);
+      } else {
+        importsMap.set(source, [componentName]);
+      }
+    }
+  }
+  const imports = Array.from(importsMap).map(([source, componentNames]) => {
+    return {
+      type: "mdxjsEsm",
+      value: `import { ${componentNames.join(", ")} } from '${source}'`
+    };
+  });
+  imports.push(
+    ...Array.from(defaultImportsMap).map(([componentName, source]) => {
+      return {
+        type: "mdxjsEsm",
+        value: `import ${componentName} from '${source}'`
+      };
+    })
+  );
+  const typedRoot = unistRoot;
+  const frontmatter2 = typedRoot.children.find((child) => child.type === "yaml");
+  if (frontmatter2) {
+    typedRoot.children.splice(typedRoot.children.indexOf(frontmatter2) + 1, 0, ...imports);
+  } else {
+    typedRoot.children.unshift(...imports);
+  }
+  fixWrappingWhitespace(typedRoot, []);
+  return typedRoot;
+}
+const TRAILING_WHITESPACE_REGEXP = /\s+$/;
+const LEADING_WHITESPACE_REGEXP = /^\s+/;
+function fixWrappingWhitespace(node, parentChain) {
+  if (node.type === "strong" || node.type === "emphasis") {
+    const lastChild = node.children.at(-1);
+    if ((lastChild == null ? void 0 : lastChild.type) === "text") {
+      const trailingWhitespace = lastChild.value.match(TRAILING_WHITESPACE_REGEXP);
+      if (trailingWhitespace) {
+        lastChild.value = lastChild.value.replace(TRAILING_WHITESPACE_REGEXP, "");
+        const parent = parentChain.at(-1);
+        if (parent) {
+          parent.children.splice(parent.children.indexOf(node) + 1, 0, {
+            type: "text",
+            value: trailingWhitespace[0]
+          });
+          fixWrappingWhitespace(parent, parentChain.slice(0, -1));
+        }
+      }
+    }
+    const firstChild = node.children.at(0);
+    if ((firstChild == null ? void 0 : firstChild.type) === "text") {
+      const leadingWhitespace = firstChild.value.match(LEADING_WHITESPACE_REGEXP);
+      if (leadingWhitespace) {
+        firstChild.value = firstChild.value.replace(LEADING_WHITESPACE_REGEXP, "");
+        const parent = parentChain.at(-1);
+        if (parent) {
+          parent.children.splice(parent.children.indexOf(node), 0, {
+            type: "text",
+            value: leadingWhitespace[0]
+          });
+          fixWrappingWhitespace(parent, parentChain.slice(0, -1));
+        }
+      }
+    }
+  }
+  if (Object.hasOwn(node, "children")) {
+    const nodeAsParent = node;
+    nodeAsParent.children.forEach((child) => fixWrappingWhitespace(child, [...parentChain, nodeAsParent]));
+  }
+}
+const defaultExtensions = {
+  mdxToMarkdown: mdxToMarkdown(),
+  frontmatterToMarkdown: frontmatterToMarkdown("yaml"),
+  directiveToMarkdown,
+  gfmTableToMarkdown: gfmTableToMarkdown({ tableCellPadding: true, tablePipeAlign: true })
+};
+const defaultToMarkdownOptions = {
+  listItemIndent: "one"
+};
+function exportMarkdownFromLexical({
+  root,
+  toMarkdownOptions,
+  toMarkdownExtensions,
+  visitors,
+  jsxComponentDescriptors
+}) {
+  return toMarkdown(exportLexicalTreeToMdast({ root, visitors, jsxComponentDescriptors }), {
+    extensions: toMarkdownExtensions,
+    ...toMarkdownOptions
+  });
+}
+const MdastRootVisitor = {
+  testNode: "root",
+  visitNode({ actions, mdastNode, lexicalParent }) {
+    actions.visitChildren(mdastNode, lexicalParent);
+  }
+};
+const MdastParagraphVisitor = {
+  testNode: "paragraph",
+  visitNode: function({ mdastNode, lexicalParent, actions }) {
+    if ($isListItemNode(lexicalParent) || $isQuoteNode(lexicalParent) || $isAdmonitionNode(lexicalParent)) {
+      actions.visitChildren(mdastNode, lexicalParent);
+    } else {
+      actions.addAndStepInto($createParagraphNode());
+    }
+  }
+};
+const MdastLinkVisitor = {
+  testNode: "link",
+  visitNode({ mdastNode, actions }) {
+    actions.addAndStepInto(
+      $createLinkNode(mdastNode.url, {
+        title: mdastNode.title
+      })
+    );
+  }
+};
+const MdastAdmonitionVisitor = {
+  testNode: "containerDirective",
+  visitNode({ mdastNode, actions }) {
+    actions.addAndStepInto($createAdmonitionNode(mdastNode.name));
+  }
+};
+const MdastHeadingVisitor = {
+  testNode: "heading",
+  visitNode: function({ mdastNode, actions }) {
+    actions.addAndStepInto($createHeadingNode(`h${mdastNode.depth}`));
+  }
+};
+const MdastListVisitor = {
+  testNode: "list",
+  visitNode: function({ mdastNode, lexicalParent, actions }) {
+    const lexicalNode = $createListNode(mdastNode.ordered ? "number" : "bullet");
+    if ($isListItemNode(lexicalParent)) {
+      const dedicatedParent = $createListItemNode();
+      dedicatedParent.append(lexicalNode);
+      lexicalParent.insertAfter(dedicatedParent);
+    } else {
+      lexicalParent.append(lexicalNode);
+    }
+    actions.visitChildren(mdastNode, lexicalNode);
+  }
+};
+const MdastListItemVisitor = {
+  testNode: "listItem",
+  visitNode({ actions }) {
+    actions.addAndStepInto($createListItemNode());
+  }
+};
+const MdastBlockQuoteVisitor = {
+  testNode: "blockquote",
+  visitNode({ actions }) {
+    actions.addAndStepInto($createQuoteNode());
+  }
+};
+const MdastTableVisitor = {
+  testNode: "table",
+  visitNode({ mdastNode, lexicalParent }) {
+    lexicalParent.append($createTableNode(mdastNode));
+  }
+};
+const MdastFormattingVisitor = {
+  testNode(mdastNode) {
+    return mdastNode.type === "emphasis" || mdastNode.type === "strong" || mdastNode.type === "mdxJsxTextElement" && (mdastNode == null ? void 0 : mdastNode.name) === "u";
+  },
+  visitNode({ mdastNode, lexicalParent, actions }) {
+    if (mdastNode.type === "emphasis") {
+      actions.addFormatting(IS_ITALIC);
+    } else if (mdastNode.type === "strong") {
+      actions.addFormatting(IS_BOLD);
+    } else if (mdastNode.type === "mdxJsxTextElement" && mdastNode.name === "u") {
+      actions.addFormatting(IS_UNDERLINE);
+    }
+    actions.visitChildren(mdastNode, lexicalParent);
+  }
+};
+const MdastInlineCodeVisitor = {
+  testNode: "inlineCode",
+  visitNode({ mdastNode, actions }) {
+    actions.addAndStepInto($createTextNode(mdastNode.value).setFormat(IS_CODE));
+  }
+};
+const MdastCodeVisitor = {
+  testNode: "code",
+  visitNode({ mdastNode, actions }) {
+    var _a;
+    const constructor = ((_a = mdastNode.meta) == null ? void 0 : _a.startsWith("live")) ? $createSandpackNode : $createCodeBlockNode;
+    actions.addAndStepInto(
+      constructor({
+        code: mdastNode.value,
+        language: mdastNode.lang,
+        meta: mdastNode.meta
+      })
+    );
+  }
+};
+const MdastTextVisitor = {
+  testNode: "text",
+  visitNode({ mdastNode, actions }) {
+    actions.addAndStepInto($createTextNode(mdastNode.value).setFormat(actions.getParentFormatting()));
+  }
+};
+const MdastThematicBreakVisitor = {
+  testNode: "thematicBreak",
+  visitNode({ actions }) {
+    actions.addAndStepInto($createHorizontalRuleNode());
+  }
+};
+const MdastImageVisitor = {
+  testNode: "image",
+  visitNode({ mdastNode, actions }) {
+    actions.addAndStepInto(
+      $createImageNode({
+        src: mdastNode.url,
+        altText: mdastNode.alt || "",
+        title: mdastNode.title || ""
+      })
+    );
+  }
+};
+const MdastFrontmatterVisitor = {
+  testNode: "yaml",
+  visitNode({ mdastNode, actions }) {
+    actions.addAndStepInto($createFrontmatterNode(mdastNode.value));
+  }
+};
+const MdastMdxJsEsmVisitor = {
+  testNode: "mdxjsEsm",
+  visitNode() {
+  }
+};
+const MdastMdxJsxElementVisitor = {
+  testNode: (node) => {
+    return node.type === "mdxJsxTextElement" || node.type === "mdxJsxFlowElement";
+  },
+  visitNode({ lexicalParent, mdastNode, actions }) {
+    lexicalParent.append(
+      $createJsxNode({
+        name: mdastNode.name,
+        kind: mdastNode.type === "mdxJsxTextElement" ? "text" : "flow",
+        //TODO: expressions are not supported yet
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        attributes: mdastNode.attributes,
+        updateFn: (lexicalParent2) => {
+          actions.visitChildren(mdastNode, lexicalParent2);
+        }
+      })
+    );
+  }
+};
+const defaultMdastVisitors = {
+  MdastRootVisitor,
+  MdastParagraphVisitor,
+  MdastTextVisitor,
+  MdastFormattingVisitor,
+  MdastInlineCodeVisitor,
+  MdastLinkVisitor,
+  MdastHeadingVisitor,
+  MdastListVisitor,
+  MdastListItemVisitor,
+  MdastBlockQuoteVisitor,
+  MdastCodeVisitor,
+  MdastThematicBreakVisitor,
+  MdastImageVisitor,
+  MdastFrontmatterVisitor,
+  MdastAdmonitionVisitor,
+  MdastMdxJsEsmVisitor,
+  MdastMdxJsxElementVisitor,
+  MdastTableVisitor
+};
+function isParent(node) {
+  return node.children instanceof Array;
+}
+const defaultMdastExtensions = {
+  mdxFromMarkdown: mdxFromMarkdown(),
+  frontmatterFromMarkdown: frontmatterFromMarkdown("yaml"),
+  directiveFromMarkdown,
+  gfmTableFromMarkdown
+};
+const defaultSyntaxExtensions = {
+  mdxjs: mdxjs(),
+  frontmatter: frontmatter(),
+  directive: directive(),
+  gfmTable
+};
+function importMarkdownToLexical({ root, markdown: markdown2, visitors, syntaxExtensions, mdastExtensions }) {
+  const mdastRoot = fromMarkdown(markdown2, {
+    extensions: syntaxExtensions,
+    mdastExtensions
+  });
+  if (mdastRoot.children.length === 0) {
+    mdastRoot.children.push({ type: "paragraph", children: [] });
+  }
+  importMdastTreeToLexical({ root, mdastRoot, visitors });
+}
+function importMdastTreeToLexical({ root, mdastRoot, visitors }) {
+  const formattingMap = /* @__PURE__ */ new WeakMap();
+  function visitChildren(mdastNode, lexicalParent) {
+    if (!isParent(mdastNode)) {
+      throw new Error("Attempting to visit children of a non-parent");
+    }
+    mdastNode.children.forEach((child) => visit(child, lexicalParent, mdastNode));
+  }
+  function visit(mdastNode, lexicalParent, mdastParent) {
+    const visitor = visitors.find((visitor2) => {
+      if (typeof visitor2.testNode === "string") {
+        return visitor2.testNode === mdastNode.type;
+      }
+      return visitor2.testNode(mdastNode);
+    });
+    if (!visitor) {
+      throw new Error(`no unist visitor found for ${mdastNode.type}`, {
+        cause: mdastNode
+      });
+    }
+    visitor.visitNode({
+      //@ts-expect-error root type is glitching
+      mdastNode,
+      lexicalParent,
+      actions: {
+        visitChildren,
+        addAndStepInto(lexicalNode) {
+          lexicalParent.append(lexicalNode);
+          if (isParent(mdastNode)) {
+            visitChildren(mdastNode, lexicalNode);
+          }
+        },
+        addFormatting(format) {
+          formattingMap.set(mdastNode, format | (formattingMap.get(mdastParent) ?? 0));
+        },
+        getParentFormatting() {
+          return formattingMap.get(mdastParent) ?? 0;
+        }
+      }
+    });
+  }
+  visit(mdastRoot, root, null);
+}
+const defaultLexicalNodes = {
+  ParagraphNode,
+  LinkNode,
+  HeadingNode,
+  QuoteNode,
+  ListNode,
+  ListItemNode,
+  HorizontalRuleNode,
+  ImageNode,
+  SandpackNode,
+  CodeBlockNode,
+  FrontmatterNode,
+  AdmonitionNode,
+  JsxNode,
+  CodeNode,
+  // this one should not be used, but markdown shortcuts complain about it
+  TableNode
+};
+function uuidv4() {
+  const hex = [...Array(256).keys()].map((index2) => index2.toString(16).padStart(2, "0"));
+  const r = crypto.getRandomValues(new Uint8Array(16));
+  r[6] = r[6] & 15 | 64;
+  r[8] = r[8] & 63 | 128;
+  return [...r.entries()].map(([index2, int]) => [4, 6, 8, 10].includes(index2) ? `-${hex[int]}` : hex[int]).join("");
+}
+function defaultComparator(current, next) {
+  return current === next;
+}
+class SetMap {
+  constructor() {
+    __publicField(this, "map", /* @__PURE__ */ new Map());
+  }
+  getOrCreate(key) {
+    let record = this.map.get(key);
+    if (!record) {
+      record = /* @__PURE__ */ new Set();
+      this.map.set(key, record);
+    }
+    return record;
+  }
+  get(key) {
+    return this.map.get(key);
+  }
+  use(key, cb) {
+    const set = this.get(key);
+    if (set !== void 0) {
+      cb(set);
+    }
+  }
+  delete(key) {
+    return this.map.delete(key);
+  }
+}
+class RefCount {
+  constructor(map = /* @__PURE__ */ new Map()) {
+    __publicField(this, "map");
+    this.map = map;
+  }
+  clone() {
+    return new RefCount(new Map(this.map));
+  }
+  increment(key) {
+    const counter = this.map.get(key) ?? 0;
+    this.map.set(key, counter + 1);
+  }
+  decrement(key, ifZero) {
+    let counter = this.map.get(key);
+    if (counter !== void 0) {
+      counter -= 1;
+      this.map.set(key, counter);
+      if (counter === 0) {
+        ifZero();
+      }
+    }
+  }
+}
+const NO_VALUE = Symbol("NO_VALUE");
+function realm() {
+  const subscriptions = new SetMap();
+  const singletonSubscriptions = /* @__PURE__ */ new Map();
+  const graph = new SetMap();
+  const state = /* @__PURE__ */ new Map();
+  const distinctNodes = /* @__PURE__ */ new Map();
+  const labels = {};
+  function node(value = NO_VALUE, distinct = false) {
+    const key = uuidv4();
+    if (value !== NO_VALUE) {
+      state.set(key, value);
+    }
+    if (distinct !== false) {
+      distinctNodes.set(key, distinct === true ? defaultComparator : distinct);
+    }
+    return { key, toString: () => key };
+  }
+  function subSingle({ key }, subscription) {
+    const nodeSubscriptions = subscriptions.getOrCreate(key);
+    nodeSubscriptions.add(subscription);
+    return () => nodeSubscriptions.delete(subscription);
+  }
+  function singletonSub({ key }, subscription) {
+    singletonSubscriptions.set(key, subscription);
+    return () => singletonSubscriptions.delete(key);
+  }
+  function singletonSubKey(key, subscription) {
+    return singletonSub(labels[key], subscription);
+  }
+  function resetSingletonSubs() {
+    singletonSubscriptions.clear();
+  }
+  function subMultiple(sources, cb) {
+    const sink = node();
+    connect({
+      map: (done) => (...args) => {
+        done(args);
+      },
+      sink,
+      sources
+    });
+    return subSingle(sink, cb);
+  }
+  function sub(...args) {
+    const [subscription] = args.slice(-1);
+    const nodes = args.slice(0, -1);
+    if (nodes.length === 1) {
+      return subSingle(nodes[0], subscription);
+    } else {
+      return subMultiple(nodes, subscription);
+    }
+  }
+  function calculateExecutionMap(keys) {
+    const participatingNodeKeys = [];
+    const visitedNodes = /* @__PURE__ */ new Set();
+    const pendingPulls = new SetMap();
+    const refCount = new RefCount();
+    const projections = new SetMap();
+    function visit(key, insertIndex = 0) {
+      refCount.increment(key);
+      if (visitedNodes.has(key)) {
+        return;
+      }
+      pendingPulls.use(key, (pulls) => {
+        insertIndex = Math.max(...Array.from(pulls).map((key2) => participatingNodeKeys.indexOf(key2))) + 1;
+      });
+      graph.use(key, (sinkProjections) => {
+        sinkProjections.forEach((projection) => {
+          if (projection.sources.has(key)) {
+            projections.getOrCreate(projection.sink).add(projection);
+            visit(projection.sink, insertIndex);
+          } else {
+            pendingPulls.getOrCreate(projection.sink).add(key);
+          }
+        });
+      });
+      visitedNodes.add(key);
+      participatingNodeKeys.splice(insertIndex, 0, key);
+    }
+    keys.forEach((key) => visit(key));
+    return { participatingNodeKeys, pendingPulls, projections, refCount };
+  }
+  const executionMaps = /* @__PURE__ */ new Map();
+  function pubIn(values) {
+    var _a;
+    const keys = Object.keys(values);
+    const executionMapKey = keys.join(",");
+    if (!executionMaps.has(executionMapKey)) {
+      executionMaps.set(executionMapKey, calculateExecutionMap(keys));
+    }
+    const map2 = executionMaps.get(executionMapKey);
+    const refCount = map2.refCount.clone();
+    const participatingNodeKeys = map2.participatingNodeKeys.slice();
+    const transientState = new Map(state);
+    function nodeWillNotEmit(key) {
+      graph.use(key, (projections) => {
+        projections.forEach(({ sources, sink }) => {
+          if (sources.has(key)) {
+            refCount.decrement(sink, () => {
+              participatingNodeKeys.splice(participatingNodeKeys.indexOf(sink), 1);
+              nodeWillNotEmit(sink);
+            });
+          }
+        });
+      });
+    }
+    let nodeKey;
+    while (nodeKey = participatingNodeKeys.shift()) {
+      let resolved = false;
+      const done = (value) => {
+        if (distinctNodes.has(nodeKey) && distinctNodes.get(nodeKey)(state.get(nodeKey), value)) {
+          resolved = false;
+          return;
+        }
+        resolved = true;
+        transientState.set(nodeKey, value);
+        if (state.has(nodeKey)) {
+          state.set(nodeKey, value);
+        }
+      };
+      if (Object.prototype.hasOwnProperty.call(values, nodeKey)) {
+        done(values[nodeKey]);
+      } else {
+        map2.projections.use(nodeKey, (nodeProjections) => {
+          nodeProjections.forEach((projection) => {
+            const args = [...Array.from(projection.sources), ...Array.from(projection.pulls)].map((id) => transientState.get(id));
+            projection.map(done)(...args);
+          });
+        });
+      }
+      if (resolved) {
+        const value = transientState.get(nodeKey);
+        subscriptions.use(nodeKey, (nodeSubscriptions) => {
+          nodeSubscriptions.forEach((subscription) => subscription(value));
+        });
+        (_a = singletonSubscriptions.get(nodeKey)) == null ? void 0 : _a(value);
+      } else {
+        nodeWillNotEmit(nodeKey);
+      }
+    }
+  }
+  function nodesToKeySet(nodes) {
+    return new Set(nodes.map((s) => s.key));
+  }
+  function connect({ sources, pulls = [], map: map2, sink: { key: sink } }) {
+    const dependency = {
+      map: map2,
+      pulls: nodesToKeySet(pulls),
+      sink,
+      sources: nodesToKeySet(sources)
+    };
+    [...sources, ...pulls].forEach(({ key: sourceKey }) => {
+      graph.getOrCreate(sourceKey).add(dependency);
+    });
+    executionMaps.clear();
+  }
+  function debug() {
+    Object.entries(labels).forEach(([name, value]) => {
+      state.get(value.key);
+    });
+  }
+  function pub(...args) {
+    const map2 = {};
+    for (let index2 = 0; index2 < args.length; index2 += 2) {
+      const node2 = args[index2];
+      map2[node2.key] = args[index2 + 1];
+    }
+    pubIn(map2);
+  }
+  function label(newLabels) {
+    Object.assign(labels, newLabels);
+  }
+  function pipe(source, ...operators) {
+    for (const operator of operators) {
+      source = operator(source);
+    }
+    return source;
+  }
+  function spread(source, initialValues) {
+    return initialValues.map((initialValue, index2) => {
+      return tap(node(initialValue, true), (sink) => {
+        connect({
+          map: (done) => (sourceValue) => {
+            done(sourceValue[index2]);
+          },
+          sink,
+          sources: [source]
+        });
+      });
+    });
+  }
+  function link(source, sink) {
+    connect({ map: (done) => (value) => done(value), sink, sources: [source] });
+  }
+  function derive(source, initial) {
+    return tap(node(initial, true), (sink) => {
+      connect({ map: (done) => (value) => done(value), sink, sources: [source] });
+    });
+  }
+  function map(mapFunction) {
+    return (source) => {
+      const sink = node();
+      connect({
+        map: (done) => (value) => {
+          done(mapFunction(value));
+        },
+        sink,
+        sources: [source]
+      });
+      return sink;
+    };
+  }
+  function mapTo(value) {
+    return (source) => {
+      const sink = node();
+      connect({ map: (done) => () => done(value), sink, sources: [source] });
+      return sink;
+    };
+  }
+  function filter(predicate) {
+    return (source) => {
+      const sink = node();
+      connect({ map: (done) => (value) => predicate(value) && done(value), sink, sources: [source] });
+      return sink;
+    };
+  }
+  function once() {
+    return (source) => {
+      const sink = node();
+      let passed = false;
+      connect({
+        map: (done) => (value) => {
+          if (!passed) {
+            passed = true;
+            done(value);
+          }
+        },
+        sink,
+        sources: [source]
+      });
+      return sink;
+    };
+  }
+  function scan(accumulator, seed) {
+    return (source) => {
+      const sink = node();
+      connect({ map: (done) => (value) => done(seed = accumulator(seed, value)), sink, sources: [source] });
+      return sink;
+    };
+  }
+  function throttleTime(delay) {
+    return (source) => {
+      const sink = node();
+      let currentValue;
+      let timeout;
+      sub(source, (value) => {
+        currentValue = value;
+        if (timeout) {
+          return;
+        }
+        timeout = setTimeout(() => {
+          timeout = void 0;
+          pub(sink, currentValue);
+        }, delay);
+      });
+      return sink;
+    };
+  }
+  function delayWithMicrotask() {
+    return (source) => {
+      const sink = node();
+      sub(source, (value) => queueMicrotask(() => pub(sink, value)));
+      return sink;
+    };
+  }
+  function debounceTime(delay) {
+    return (source) => {
+      const sink = node();
+      let currentValue;
+      let timeout;
+      sub(source, (value) => {
+        currentValue = value;
+        if (timeout) {
+          clearTimeout(timeout);
+        }
+        timeout = setTimeout(() => {
+          pub(sink, currentValue);
+        }, delay);
+      });
+      return sink;
+    };
+  }
+  function onNext(bufNode) {
+    return (source) => {
+      const sink = node();
+      let pendingValue = NO_VALUE;
+      sub(source, (value) => pendingValue = value);
+      connect({
+        map: (done) => (value) => {
+          if (pendingValue !== NO_VALUE) {
+            done([pendingValue, value]);
+            pendingValue = NO_VALUE;
+          }
+        },
+        sink,
+        sources: [bufNode]
+      });
+      return sink;
+    };
+  }
+  function passOnlyAfterNodeHasEmittedBefore(starterNode, durationNode) {
+    return (source) => {
+      const sink = node();
+      let startTime = 0;
+      sub(starterNode, () => startTime = Date.now());
+      connect({
+        map: (done) => (value) => {
+          if (Date.now() < startTime + state.get(durationNode.key)) {
+            done(value);
+          }
+        },
+        sink,
+        sources: [source]
+      });
+      return sink;
+    };
+  }
+  function withLatestFrom(...nodes) {
+    return (source) => {
+      const sink = node();
+      connect({
+        map: (done) => (...args) => done(args),
+        pulls: nodes,
+        sink,
+        sources: [source]
+      });
+      return sink;
+    };
+  }
+  function combine(...nodes) {
+    const sink = node();
+    connect({
+      map: (done) => (...args) => done(args),
+      sink,
+      sources: nodes
+    });
+    return sink;
+  }
+  function subKey(key, subscription) {
+    return sub(labels[key], subscription);
+  }
+  function subKeys(keys, subscription) {
+    const nodes = keys.map((key) => labels[key]);
+    return sub(...nodes.concat(subscription));
+  }
+  function pubKey(key, value) {
+    pubKeys({ [key]: value });
+  }
+  function pubKeys(values) {
+    const valuesWithInternalKeys = Object.entries(values).reduce(
+      (acc, [key, value]) => tap(acc, (acc2) => acc2[labels[key].key] = value),
+      {}
+    );
+    pubIn(valuesWithInternalKeys);
+  }
+  function getKeyValue(key) {
+    return state.get(labels[key].key);
+  }
+  function getValue(node2) {
+    return state.get(node2.key);
+  }
+  function getKeyValues(keys) {
+    return keys.map((key) => state.get(labels[key].key));
+  }
+  return {
+    combine,
+    connect,
+    debug,
+    derive,
+    getKeyValue,
+    getValue,
+    getKeyValues,
+    label,
+    labels,
+    link,
+    node,
+    o: {
+      delayWithMicrotask,
+      debounceTime,
+      filter,
+      map,
+      mapTo,
+      onNext,
+      scan,
+      throttleTime,
+      withLatestFrom,
+      once,
+      passOnlyAfterNodeHasEmittedBefore
+    },
+    pipe,
+    pub,
+    pubIn,
+    pubKey,
+    pubKeys,
+    resetSingletonSubs,
+    singletonSub,
+    singletonSubKey,
+    spread,
+    sub,
+    subKey,
+    subKeys
+  };
+}
+function omit(keys, obj) {
+  const result = {};
+  const index2 = {};
+  let idx = 0;
+  const len = keys.length;
+  while (idx < len) {
+    index2[keys[idx]] = 1;
+    idx += 1;
+  }
+  for (const prop in obj) {
+    if (!Object.prototype.hasOwnProperty.call(index2, prop)) {
+      result[prop] = obj[prop];
+    }
+  }
+  return result;
+}
+const useIsomorphicLayoutEffect = typeof document !== "undefined" ? React.useLayoutEffect : React.useEffect;
+const GurxContext = createContext(void 0);
+function realmFactoryToComponent(realmFactory2, map, Root) {
+  const requiredPropNames = Object.keys(map.required || {});
+  const optionalPropNames = Object.keys(map.optional || {});
+  const methodNames = Object.keys(map.methods || {});
+  const eventNames = Object.keys(map.events || {});
+  const Context = GurxContext;
+  function applyPropsToRealm(realm2, props) {
+    const toBePublished = {};
+    for (const requiredPropName of requiredPropNames) {
+      const nodeName = map.required[requiredPropName];
+      toBePublished[nodeName] = props[requiredPropName];
+    }
+    for (const optionalPropName of optionalPropNames) {
+      const value = props[optionalPropName];
+      if (value !== void 0) {
+        const nodeName = map.optional[optionalPropName];
+        toBePublished[nodeName] = value;
+      }
+    }
+    realm2.suppressFlushSync = true;
+    realm2.pubKeys(toBePublished);
+    realm2.suppressFlushSync = false;
+  }
+  function buildMethods(realm2) {
+    return methodNames.reduce((acc, methodName) => {
+      const nodeName = map.methods[methodName];
+      acc[methodName] = (value) => {
+        realm2.pubKey(nodeName, value);
+      };
+      return acc;
+    }, {});
+  }
+  const Component = forwardRef((props, ref) => {
+    const realm2 = useMemo(() => {
+      return tap(realmFactory2(), (realm22) => applyPropsToRealm(realm22, props));
+    }, []);
+    useIsomorphicLayoutEffect(() => {
+      applyPropsToRealm(realm2, props);
+      realm2.resetSingletonSubs();
+      for (const eventName of eventNames) {
+        if (eventName in props) {
+          realm2.singletonSubKey(map.events[eventName], props[eventName]);
+        }
+      }
+      return () => {
+        realm2.resetSingletonSubs();
+      };
+    }, [props]);
+    useImperativeHandle(ref, always(buildMethods(realm2)));
+    const children = props.children;
+    return createElement(
+      Context.Provider,
+      { value: realm2 },
+      Root ? createElement(
+        Root,
+        omit([...requiredPropNames, ...optionalPropNames, ...eventNames], props),
+        children
+      ) : children
+    );
+  });
+  Component.displayName = "Gurx Component";
+  const usePublisher2 = (key) => {
+    const realm2 = React.useContext(Context);
+    return useCallback(
+      (value) => {
+        realm2.pubKey(key, value);
+      },
+      // eslint-disable-next-line react-hooks/exhaustive-deps
+      [key, realm2]
+    );
+  };
+  const useEmitterValues2 = (...keys) => {
+    const realm2 = useContext(Context);
+    const [values, setValues] = useState(() => realm2.getKeyValues(keys));
+    useIsomorphicLayoutEffect(
+      () => realm2 == null ? void 0 : realm2.subKeys(keys, (newValues) => {
+        const setter = () => {
+          setValues(keys.length === 1 ? [newValues] : newValues);
+        };
+        if (realm2.suppressFlushSync) {
+          setter();
+        } else {
+          setter();
+        }
+      }),
+      [keys]
+    );
+    return values;
+  };
+  const usePubKeys = () => {
+    return useContext(Context).pubKeys;
+  };
+  const useEmitter = (key, callback) => {
+    const realm2 = useContext(Context);
+    useIsomorphicLayoutEffect(() => realm2.subKey(key, callback), [callback]);
+  };
+  return {
+    Component,
+    useEmitter,
+    useEmitterValues: useEmitterValues2,
+    usePubKeys,
+    usePublisher: usePublisher2
+  };
+}
+function system(constructor, dependencies = [], id = uuidv4()) {
+  return [
+    {
+      constructor,
+      dependencies,
+      id
+    },
+    { id }
+  ];
+}
+function realmFactory(...specs) {
+  const singletons = /* @__PURE__ */ new Map();
+  const r = realm();
+  const _init = ({ id, constructor, dependencies }) => {
+    if (singletons.has(id)) {
+      return singletons.get(id);
+    }
+    const system2 = constructor(
+      r,
+      dependencies.map((t) => _init(specs.find((spec) => spec.id === t.id)))
+    );
+    r.label(system2);
+    singletons.set(id, system2);
+    return system2;
+  };
+  specs.forEach(_init);
+  return r;
+}
+function getRealmFactory(...specs) {
+  return () => realmFactory(...specs);
+}
+const formatParagraph = (editor) => {
+  editor.update(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection) || DEPRECATED_$isGridSelection(selection))
+      $setBlocksType(selection, () => $createParagraphNode());
+  });
+};
+const formatHeading = (editor, headingType) => {
+  editor.update(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection) || DEPRECATED_$isGridSelection(selection)) {
+      $setBlocksType(selection, () => $createHeadingNode(headingType));
+    }
+  });
+};
+const formatQuote = (editor) => {
+  editor.update(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection) || DEPRECATED_$isGridSelection(selection)) {
+      $setBlocksType(selection, () => $createQuoteNode());
+    }
+  });
+};
+const formatAdmonition = (editor, kind) => {
+  editor.update(() => {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection) || DEPRECATED_$isGridSelection(selection)) {
+      $setBlocksType(selection, () => {
+        return $createAdmonitionNode(kind);
+      });
+    }
+  });
+};
+const ListTypeCommandMap = /* @__PURE__ */ new Map([
+  ["number", INSERT_ORDERED_LIST_COMMAND],
+  ["bullet", INSERT_UNORDERED_LIST_COMMAND],
+  ["", REMOVE_LIST_COMMAND]
+]);
+function seedTable() {
+  return {
+    type: "table",
+    children: [
+      {
+        type: "tableRow",
+        children: [{ type: "tableCell", children: [] }]
+      }
+    ]
+  };
+}
+const [EditorSystem, EditorSystemType] = system((r) => {
+  const editor = r.node(null, true);
+  const markdownSource = r.node("");
+  const historyState = r.node(createEmptyHistoryState());
+  const activeEditor = r.derive(editor, null);
+  const currentFormat = r.node(0, true);
+  const currentSelection = r.node(null);
+  const currentListType = r.node(null);
+  const currentBlockType = r.node(null);
+  const applyFormat = r.node();
+  const applyListType = r.node();
+  const applyBlockType = r.node();
+  const insertHorizontalRule = r.node();
+  const insertTable = r.node();
+  const insertFrontmatter = r.node();
+  const insertImage = r.node();
+  const createEditorSubscription = r.node();
+  const editorSubscriptions = r.node([]);
+  const inFocus = r.node(false, true);
+  const activeEditorType = r.node({ type: "lexical" });
+  const editorRootElementRef = r.node(null);
+  const markdownParseOptions = r.node(null);
+  const lexicalConvertOptions = r.node(null);
+  const lexicalNodes = r.node([]);
+  const imageAutocompleteSuggestions = r.node([]);
+  r.link(
+    r.pipe(
+      createEditorSubscription,
+      r.o.withLatestFrom(editorSubscriptions),
+      r.o.map(([createSubscription, subscriptions]) => {
+        return [...subscriptions, createSubscription];
+      })
+    ),
+    editorSubscriptions
+  );
+  r.sub(r.pipe(applyListType, r.o.withLatestFrom(activeEditor)), ([listType, theEditor]) => {
+    theEditor == null ? void 0 : theEditor.dispatchCommand(ListTypeCommandMap.get(listType), void 0);
+  });
+  r.sub(r.pipe(applyFormat, r.o.withLatestFrom(activeEditor)), ([format, theEditor]) => {
+    theEditor == null ? void 0 : theEditor.dispatchCommand(FORMAT_TEXT_COMMAND, format);
+  });
+  r.sub(r.pipe(insertHorizontalRule, r.o.withLatestFrom(activeEditor)), ([, theEditor]) => {
+    theEditor == null ? void 0 : theEditor.dispatchCommand(INSERT_HORIZONTAL_RULE_COMMAND, void 0);
+  });
+  r.sub(r.pipe(insertImage, r.o.withLatestFrom(activeEditor)), ([src, theEditor]) => {
+    theEditor == null ? void 0 : theEditor.getEditorState().read(() => {
+      const selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        const focusNode = selection.focus.getNode();
+        if (focusNode !== null) {
+          theEditor.update(() => {
+            const imageNode = $createImageNode({ altText: "", src, title: "" });
+            $insertNodeToNearestRoot(imageNode);
+          });
+        }
+      }
+    });
+  });
+  r.sub(r.pipe(insertFrontmatter, r.o.withLatestFrom(activeEditor)), ([, theEditor]) => {
+    theEditor == null ? void 0 : theEditor.update(() => {
+      const firstItem = $getRoot().getFirstChild();
+      if (!$isFrontmatterNode(firstItem)) {
+        const fmNode = $createFrontmatterNode('"": ""');
+        if (firstItem) {
+          firstItem.insertBefore(fmNode);
+        } else {
+          $getRoot().append(fmNode);
+        }
+      }
+    });
+  });
+  r.sub(r.pipe(insertTable, r.o.withLatestFrom(activeEditor)), ([, theEditor]) => {
+    theEditor == null ? void 0 : theEditor.getEditorState().read(() => {
+      const selection = $getSelection();
+      if ($isRangeSelection(selection)) {
+        const focusNode = selection.focus.getNode();
+        if (focusNode !== null) {
+          theEditor.update(() => {
+            const tableNode = $createTableNode(seedTable());
+            $insertNodeToNearestRoot(tableNode);
+            setTimeout(() => {
+              tableNode.select([0, 0]);
+            }, 50);
+          });
+        }
+      }
+    });
+  });
+  r.sub(r.pipe(applyBlockType, r.o.withLatestFrom(activeEditor)), ([type, theEditor]) => {
+    if (theEditor) {
+      switch (type) {
+        case "paragraph": {
+          formatParagraph(theEditor);
+          break;
+        }
+        case "quote": {
+          formatQuote(theEditor);
+          break;
+        }
+        case "note":
+        case "tip":
+        case "danger":
+        case "caution":
+        case "info": {
+          formatAdmonition(theEditor, type);
+          break;
+        }
+        default: {
+          formatHeading(theEditor, type);
+        }
+      }
+    }
+  });
+  r.sub(r.pipe(currentSelection, r.o.withLatestFrom(activeEditor)), ([selection, theEditor]) => {
+    if (!selection || !theEditor) {
+      return;
+    }
+    const anchorNode = selection.anchor.getNode();
+    let element = anchorNode.getKey() === "root" ? anchorNode : $findMatchingParent(anchorNode, (e) => {
+      const parent = e.getParent();
+      return parent !== null && $isRootOrShadowRoot(parent);
+    });
+    if (element === null) {
+      element = anchorNode.getTopLevelElementOrThrow();
+    }
+    const elementKey = element.getKey();
+    const elementDOM = theEditor.getElementByKey(elementKey);
+    if (elementDOM !== null) {
+      if ($isListNode(element)) {
+        const parentList = $getNearestNodeOfType(anchorNode, ListNode);
+        const type = parentList ? parentList.getListType() : element.getListType();
+        r.pubIn({
+          [currentListType.key]: type,
+          [currentBlockType.key]: ""
+        });
+      } else {
+        r.pub(currentListType, null);
+        const blockType = $isHeadingNode(element) ? element.getTag() : $isAdmonitionNode(element) ? element.getKind() : element.getType();
+        r.pubIn({
+          [currentListType.key]: null,
+          [currentBlockType.key]: blockType
+        });
+      }
+    }
+  });
+  function handleSelectionChange() {
+    const selection = $getSelection();
+    if ($isRangeSelection(selection)) {
+      r.pubKeys({
+        currentSelection: selection,
+        currentFormat: selection.format
+      });
+    }
+  }
+  r.sub(editor, (theEditor) => {
+    if (theEditor) {
+      theEditor.registerCommand(
+        SELECTION_CHANGE_COMMAND,
+        (_, editor2) => {
+          r.pubIn({
+            [activeEditor.key]: editor2,
+            [inFocus.key]: true
+          });
+          handleSelectionChange();
+          return false;
+        },
+        COMMAND_PRIORITY_CRITICAL
+      );
+    }
+  });
+  r.pipe(
+    r.combine(editorSubscriptions, activeEditor),
+    r.o.scan((teardowns, [editorSubscriptions2, activeEditorValue]) => {
+      teardowns.forEach((u) => u());
+      return activeEditorValue ? editorSubscriptions2.map((s) => s(activeEditorValue, r.getValue(editor))) : [];
+    }, [])
+  );
+  r.pub(createEditorSubscription, (editor2) => {
+    return editor2.registerUpdateListener(({ editorState }) => {
+      editorState.read(() => {
+        handleSelectionChange();
+      });
+    });
+  });
+  r.pub(createEditorSubscription, (theEditor) => {
+    return theEditor.registerCommand(
+      BLUR_COMMAND,
+      (payload) => {
+        var _a;
+        const rootEditor = r.getValue(editor);
+        const movingOutside = !((_a = rootEditor.getRootElement()) == null ? void 0 : _a.contains(payload.relatedTarget));
+        if (movingOutside) {
+          r.pub(inFocus, false);
+        }
+        return false;
+      },
+      COMMAND_PRIORITY_LOW
+    );
+  });
+  return {
+    editor,
+    activeEditor,
+    currentFormat,
+    currentSelection,
+    currentListType,
+    currentBlockType,
+    applyFormat,
+    applyListType,
+    applyBlockType,
+    insertHorizontalRule,
+    insertFrontmatter,
+    insertImage,
+    insertTable,
+    createEditorSubscription,
+    editorSubscriptions,
+    activeEditorType,
+    inFocus,
+    historyState,
+    editorRootElementRef,
+    markdownParseOptions,
+    lexicalConvertOptions,
+    lexicalNodes,
+    imageAutocompleteSuggestions,
+    markdownSource
+  };
+}, []);
+const [JsxSystem, JsxSystemType] = system((r) => {
+  const jsxComponentDescriptors = r.node([]);
+  return {
+    jsxComponentDescriptors
+  };
+}, []);
+const [ViewModeSystem] = system(
+  (r, [{ editor, markdownParseOptions, markdownSource }, {}]) => {
+    const viewMode = r.node("editor");
+    const headMarkdown = r.node("");
+    r.sub(
+      r.pipe(
+        viewMode,
+        r.o.scan(
+          (prev, next) => {
+            return {
+              current: prev.next,
+              next
+            };
+          },
+          { current: "editor", next: "editor" }
+        ),
+        r.o.withLatestFrom(editor, markdownSource, markdownParseOptions)
+      ),
+      ([{ current }, editor2, markdownSource2, markdownParseOptions2]) => {
+        if (current === "markdown") {
+          editor2 == null ? void 0 : editor2.update(() => {
+            $getRoot().clear();
+            importMarkdownToLexical({
+              root: $getRoot(),
+              markdown: markdownSource2,
+              ...markdownParseOptions2
+            });
+          });
+        }
+      }
+    );
+    return {
+      viewMode,
+      headMarkdown
+    };
+  },
+  [EditorSystemType, JsxSystemType]
+);
+const defaultSnippetContent = `
+export default function App() {
+  return (
+    <div className="App">
+      <h1>Hello CodeSandbox</h1>
+      <h2>Start editing to see some magic happen!</h2>
+    </div>
+  );
+}
+`;
+const defaultSandpackConfig$1 = {
+  defaultPreset: "react",
+  presets: [
+    {
+      name: "react",
+      meta: "live react",
+      label: "React",
+      sandpackTemplate: "react",
+      sandpackTheme: "light",
+      snippetFileName: "/App.js",
+      snippetLanguage: "jsx",
+      initialSnippetContent: defaultSnippetContent
+    }
+  ]
+};
+const defaultCodeBlockLanguages = {
+  js: "JavaScript",
+  ts: "TypeScript",
+  tsx: "TypeScript (React)",
+  jsx: "JavaScript (React)",
+  css: "CSS"
+};
+const [SandpackSystem] = system(
+  (r, [{ activeEditor, activeEditorType, createEditorSubscription }]) => {
+    const sandpackConfig = r.node(defaultSandpackConfig$1);
+    const codeBlockLanguages = r.node(defaultCodeBlockLanguages);
+    const insertSandpack = r.node();
+    const insertCodeBlock = r.node();
+    r.pub(createEditorSubscription, (editor) => {
+      return editor.registerCommand(
+        FOCUS_COMMAND,
+        () => {
+          r.pub(activeEditorType, { type: "lexical" });
+          return false;
+        },
+        COMMAND_PRIORITY_LOW
+      );
+    });
+    r.sub(r.pipe(insertSandpack, r.o.withLatestFrom(activeEditor, sandpackConfig)), ([meta, theEditor, sandpackConfig2]) => {
+      theEditor == null ? void 0 : theEditor.getEditorState().read(() => {
+        const selection = $getSelection();
+        if ($isRangeSelection(selection)) {
+          const focusNode = selection.focus.getNode();
+          const preset = meta ? sandpackConfig2.presets.find((preset2) => preset2.meta === meta) : sandpackConfig2.presets.find((preset2) => preset2.name == sandpackConfig2.defaultPreset);
+          if (!preset) {
+            throw new Error(`No sandpack preset found with ${meta}`);
+          }
+          if (focusNode !== null) {
+            theEditor.update(() => {
+              const sandpackNode = $createSandpackNode({
+                code: preset.initialSnippetContent || "",
+                language: preset.snippetLanguage || "jsx",
+                meta: preset.meta
+              });
+              $insertNodeToNearestRoot(sandpackNode);
+              setTimeout(() => sandpackNode.select(), 80);
+            });
+          }
+        }
+      });
+    });
+    r.sub(r.pipe(insertCodeBlock, r.o.withLatestFrom(activeEditor)), ([, theEditor]) => {
+      theEditor == null ? void 0 : theEditor.getEditorState().read(() => {
+        const selection = $getSelection();
+        if ($isRangeSelection(selection)) {
+          const focusNode = selection.focus.getNode();
+          if (focusNode !== null) {
+            theEditor.update(() => {
+              const codeBlockNode = $createCodeBlockNode({
+                code: "",
+                language: "jsx",
+                meta: ""
+              });
+              $insertNodeToNearestRoot(codeBlockNode);
+              setTimeout(() => codeBlockNode.select(), 80);
+            });
+          }
+        }
+      });
+    });
+    return {
+      codeBlockLanguages,
+      insertSandpack,
+      insertCodeBlock,
+      sandpackConfig
+    };
+  },
+  [EditorSystemType]
+);
+function getSelectedNode(selection) {
+  const anchor = selection.anchor;
+  const focus = selection.focus;
+  const anchorNode = selection.anchor.getNode();
+  const focusNode = selection.focus.getNode();
+  if (anchorNode === focusNode) {
+    return anchorNode;
+  }
+  const isBackward = selection.isBackward();
+  if (isBackward) {
+    return $isAtNodeEnd(focus) ? anchorNode : focusNode;
+  } else {
+    return $isAtNodeEnd(anchor) ? anchorNode : focusNode;
+  }
+}
+function getSelectionRectangle(editor) {
+  const selection = $getSelection();
+  const nativeSelection = window.getSelection();
+  const activeElement = document.activeElement;
+  const rootElement = editor.getRootElement();
+  if (selection !== null && nativeSelection !== null && rootElement !== null && rootElement.contains(nativeSelection.anchorNode) && editor.isEditable()) {
+    const domRange = nativeSelection.getRangeAt(0);
+    let rect;
+    if (nativeSelection.anchorNode === rootElement) {
+      let inner = rootElement;
+      while (inner.firstElementChild != null) {
+        inner = inner.firstElementChild;
+      }
+      rect = inner.getBoundingClientRect();
+    } else {
+      rect = domRange.getBoundingClientRect();
+    }
+    return {
+      top: rect.top + window.scrollY,
+      left: rect.left + window.scrollX,
+      width: rect.width,
+      height: rect.height
+    };
+  } else if (!activeElement || activeElement.className !== "link-input") {
+    return null;
+  }
+  return null;
+}
+function getStateAsMarkdown(editor, exportParams) {
+  return tap({ markdown: "" }, (result) => {
+    editor.getEditorState().read(() => {
+      result.markdown = exportMarkdownFromLexical({ root: $getRoot(), ...exportParams });
+    });
+  }).markdown;
+}
+const CAN_USE_DOM = typeof window !== "undefined" && typeof window.document !== "undefined" && typeof window.document.createElement !== "undefined";
+const IS_APPLE = CAN_USE_DOM && /Mac|iPod|iPhone|iPad/.test(navigator.platform);
+function getLinkNodeInSelection(selection) {
+  const node = getSelectedNode(selection);
+  const parent = node.getParent();
+  if ($isLinkNode(parent)) {
+    return parent;
+  } else if ($isLinkNode(node)) {
+    return node;
+  }
+  return null;
+}
+const [LinkDialogSystem, LinkDialogSystemType] = system(
+  (r, [{ activeEditor, currentSelection, createEditorSubscription }]) => {
+    const dialogState = r.node(false);
+    const onWindowChange = r.node();
+    const linkDialogState = r.node({ type: "inactive" }, true);
+    const updateLinkUrl = r.node();
+    const cancelLinkEdit = r.node();
+    const applyLinkChanges = r.node();
+    const switchFromPreviewToLinkEdit = r.node();
+    const removeLink = r.node();
+    const openLinkEditDialog = r.node();
+    const linkAutocompleteSuggestions = r.node([]);
+    r.sub(
+      r.pipe(
+        openLinkEditDialog,
+        r.o.withLatestFrom(currentSelection, activeEditor),
+        r.o.filter(([, selection]) => $isRangeSelection(selection))
+      ),
+      ([, selection, editor]) => {
+        editor == null ? void 0 : editor.getEditorState().read(() => {
+          const node = getLinkNodeInSelection(selection);
+          const rectangle = getSelectionRectangle(editor);
+          if (node) {
+            r.pub(linkDialogState, {
+              type: "edit",
+              initialUrl: node.getURL(),
+              url: node.getURL(),
+              linkNodeKey: node.getKey(),
+              rectangle
+            });
+          } else {
+            r.pub(linkDialogState, {
+              type: "edit",
+              initialUrl: "",
+              url: "",
+              linkNodeKey: "",
+              rectangle
+            });
+          }
+        });
+      }
+    );
+    r.sub(r.pipe(removeLink, r.o.withLatestFrom(activeEditor)), ([, editor]) => {
+      editor == null ? void 0 : editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+    });
+    r.pub(createEditorSubscription, (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.pub(createEditorSubscription, (editor) => {
+      return editor.registerCommand(
+        KEY_MODIFIER_COMMAND,
+        (event) => {
+          if (event.key === "k" && IS_APPLE ? event.metaKey : event.ctrlKey) {
+            r.pub(openLinkEditDialog, true);
+            return true;
+          }
+          return false;
+        },
+        COMMAND_PRIORITY_HIGH
+      );
+    });
+    r.link(
+      r.pipe(
+        switchFromPreviewToLinkEdit,
+        r.o.withLatestFrom(linkDialogState),
+        r.o.map(([, state]) => {
+          if (state.type === "preview") {
+            return {
+              type: "edit",
+              initialUrl: state.url,
+              url: state.url,
+              linkNodeKey: state.linkNodeKey,
+              rectangle: state.rectangle
+            };
+          } else {
+            throw new Error("Cannot switch to edit mode when not in preview mode");
+          }
+        })
+      ),
+      linkDialogState
+    );
+    r.sub(r.pipe(applyLinkChanges, r.o.withLatestFrom(linkDialogState, activeEditor)), ([, state, editor]) => {
+      if (state.type === "edit") {
+        const url = state.url.trim();
+        if (url.trim() !== "") {
+          editor == null ? void 0 : editor.dispatchCommand(TOGGLE_LINK_COMMAND, url);
+          r.pub(linkDialogState, {
+            type: "preview",
+            linkNodeKey: state.linkNodeKey,
+            rectangle: state.rectangle,
+            url
+          });
+        } else {
+          if (state.initialUrl !== "") {
+            editor == null ? void 0 : editor.dispatchCommand(TOGGLE_LINK_COMMAND, null);
+          }
+          r.pub(linkDialogState, {
+            type: "inactive"
+          });
+        }
+      } else {
+        throw new Error("Cannot apply link edit when not in edit mode");
+      }
+    });
+    r.link(
+      r.pipe(
+        updateLinkUrl,
+        r.o.withLatestFrom(linkDialogState),
+        r.o.map(([url, state]) => {
+          if (state.type === "edit") {
+            return {
+              ...state,
+              url
+            };
+          } else {
+            throw new Error("Cannot update link url when not in edit mode");
+          }
+        })
+      ),
+      linkDialogState
+    );
+    r.link(
+      r.pipe(
+        cancelLinkEdit,
+        r.o.withLatestFrom(linkDialogState, activeEditor),
+        r.o.map(([, state, editor]) => {
+          if (state.type === "edit") {
+            editor == null ? void 0 : 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),
+        r.o.withLatestFrom(activeEditor, linkDialogState),
+        r.o.map(([[selection], activeEditor2]) => {
+          if ($isRangeSelection(selection) && activeEditor2) {
+            const node = getLinkNodeInSelection(selection);
+            if (node) {
+              return {
+                type: "preview",
+                url: node.getURL(),
+                linkNodeKey: node.getKey(),
+                rectangle: getSelectionRectangle(activeEditor2)
+              };
+            } else {
+              return {
+                type: "inactive"
+              };
+            }
+          } else {
+            return {
+              type: "inactive"
+            };
+          }
+        })
+      ),
+      linkDialogState
+    );
+    return {
+      dialogState,
+      onWindowChange,
+      linkDialogState,
+      updateLinkUrl,
+      switchFromPreviewToLinkEdit,
+      cancelLinkEdit,
+      removeLink,
+      openLinkEditDialog,
+      applyLinkChanges,
+      linkAutocompleteSuggestions
+    };
+  },
+  [EditorSystemType]
+);
+const [OnChangeSystem, OnChangeSystemType] = system(
+  (r, [{ createEditorSubscription, lexicalConvertOptions, markdownSource }, { jsxComponentDescriptors }]) => {
+    const onChange = r.node();
+    r.pub(createEditorSubscription, (activeEditor, rootEditor) => {
+      function updateMarkdown() {
+        const descriptors = r.getValue(jsxComponentDescriptors);
+        const options = r.getValue(lexicalConvertOptions);
+        const markdown2 = getStateAsMarkdown(rootEditor, { jsxComponentDescriptors: descriptors, ...options });
+        r.pub(onChange, markdown2);
+        r.pub(markdownSource, markdown2);
+      }
+      updateMarkdown();
+      return activeEditor.registerUpdateListener(({ dirtyElements, dirtyLeaves, prevEditorState, tags }) => {
+        if (dirtyElements.size === 0 && dirtyLeaves.size === 0 || tags.has("history-merge") || prevEditorState.isEmpty()) {
+          return;
+        }
+        updateMarkdown();
+      });
+    });
+    return {
+      onChange
+    };
+  },
+  [EditorSystemType, JsxSystemType]
+);
+const [ToolbarSystem, ToolbarSystemType] = system((r) => {
+  const toolbarComponents = r.node([]);
+  return {
+    toolbarComponents
+  };
+}, []);
+const {
+  Component: EditorSystemComponent,
+  usePublisher,
+  useEmitterValues
+} = realmFactoryToComponent(
+  getRealmFactory(EditorSystem, ViewModeSystem, SandpackSystem, LinkDialogSystem, JsxSystem, OnChangeSystem, ToolbarSystem),
+  {
+    required: {
+      markdownSource: "markdownSource",
+      headMarkdown: "headMarkdown",
+      jsxComponentDescriptors: "jsxComponentDescriptors",
+      sandpackConfig: "sandpackConfig",
+      toolbarComponents: "toolbarComponents",
+      markdownParseOptions: "markdownParseOptions",
+      lexicalConvertOptions: "lexicalConvertOptions",
+      lexicalNodes: "lexicalNodes"
+    },
+    optional: {
+      editorRootElementRef: "editorRootElementRef",
+      viewMode: "viewMode",
+      linkAutocompleteSuggestions: "linkAutocompleteSuggestions",
+      imageAutocompleteSuggestions: "imageAutocompleteSuggestions",
+      codeBlockLanguages: "codeBlockLanguages"
+    },
+    events: {
+      onChange: "onChange"
+    }
+  },
+  ({ children }) => {
+    return /* @__PURE__ */ React__default.createElement("div", null, /* @__PURE__ */ React__default.createElement(CaptureLexicalEditor, null), children);
+  }
+);
+const CaptureLexicalEditor = () => {
+  const setEditor = usePublisher("editor");
+  const [lexicalEditor] = useLexicalComposerContext();
+  React__default.useEffect(() => setEditor(lexicalEditor), [lexicalEditor, setEditor]);
+  return null;
+};
+const SvgCheck = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "m9.55 18-5.7-5.7 1.425-1.425L9.55 15.15l9.175-9.175L20.15 7.4 9.55 18Z" })));
+const CheckIcon = SvgCheck;
+const SvgClose = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M6.4 19 5 17.6l5.6-5.6L5 6.4 6.4 5l5.6 5.6L17.6 5 19 6.4 13.4 12l5.6 5.6-1.4 1.4-5.6-5.6L6.4 19Z" })));
+const CloseIcon = SvgClose;
+const SvgContentCopy = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M7 18V2h13v16H7Zm2-2h9V4H9v12Zm-6 6V6h2v14h11v2H3Z" })));
+const CopyIcon = SvgContentCopy;
+const SvgEdit = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M5 19h1.4l8.625-8.625-1.4-1.4L5 17.6V19ZM19.3 8.925l-4.25-4.2L17.875 1.9 22.1 6.125l-2.8 2.8ZM3 21v-4.25l10.6-10.6 4.25 4.25L7.25 21H3Z" })));
+const EditIcon = SvgEdit;
+const SvgLinkOff = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "m19.25 16.45-1.5-1.55a3.05 3.05 0 0 0 1.625-1.063A2.867 2.867 0 0 0 20 12c0-.833-.292-1.542-.875-2.125A2.893 2.893 0 0 0 17 9h-4V7h4c1.383 0 2.563.487 3.538 1.462C21.513 9.437 22 10.617 22 12c0 .95-.246 1.825-.737 2.625a4.79 4.79 0 0 1-2.013 1.825ZM15.85 13l-2-2H16v2h-.15Zm3.95 9.6L1.4 4.2l1.4-1.4 18.4 18.4-1.4 1.4ZM11 17H7c-1.383 0-2.562-.488-3.537-1.463C2.488 14.562 2 13.383 2 12c0-1.15.35-2.175 1.05-3.075.7-.9 1.6-1.492 2.7-1.775L7.6 9H7c-.833 0-1.542.292-2.125.875A2.893 2.893 0 0 0 4 12c0 .833.292 1.542.875 2.125A2.893 2.893 0 0 0 7 15h4v2Zm-3-4v-2h1.625l1.975 2H8Z" })));
+const LinkOffIcon = SvgLinkOff;
+const SvgOpenInNew = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M3 21V3h9v2H5v14h14v-7h2v9H3Zm6.7-5.3-1.4-1.4L17.6 5H14V3h7v7h-2V6.4l-9.3 9.3Z" })));
+const OpenInNewIcon = SvgOpenInNew;
+const SvgArrowDropDown = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "m12 15-5-5h10l-5 5Z" })));
+const DropDownIcon = SvgArrowDropDown;
+const editorRoot = "_editorRoot_gm91f_47";
+const editorWrapper = "_editorWrapper_gm91f_141";
+const nestedListItem = "_nestedListItem_gm91f_145";
+const toolbarRoot = "_toolbarRoot_gm91f_149";
+const toolbarModeSwitch = "_toolbarModeSwitch_gm91f_170";
+const toolbarToggleItem = "_toolbarToggleItem_gm91f_179";
+const toolbarGroupOfGroups = "_toolbarGroupOfGroups_gm91f_189";
+const toolbarToggleSingleGroup = "_toolbarToggleSingleGroup_gm91f_193";
+const toolbarButton = "_toolbarButton_gm91f_207";
+const toolbarNodeKindSelectContainer = "_toolbarNodeKindSelectContainer_gm91f_236";
+const toolbarButtonDropdownContainer = "_toolbarButtonDropdownContainer_gm91f_237";
+const toolbarCodeBlockLanguageSelectContent = "_toolbarCodeBlockLanguageSelectContent_gm91f_238";
+const toolbarNodeKindSelectTrigger = "_toolbarNodeKindSelectTrigger_gm91f_252";
+const toolbarButtonSelectTrigger = "_toolbarButtonSelectTrigger_gm91f_253";
+const toolbarCodeBlockLanguageSelectTrigger = "_toolbarCodeBlockLanguageSelectTrigger_gm91f_286";
+const toolbarNodeKindSelectItem = "_toolbarNodeKindSelectItem_gm91f_292";
+const toolbarNodeKindSelectDropdownArrow = "_toolbarNodeKindSelectDropdownArrow_gm91f_315";
+const contentEditable = "_contentEditable_gm91f_319";
+const sandpackWrapper = "_sandpackWrapper_gm91f_327";
+const frontmatterWrapper = "_frontmatterWrapper_gm91f_331";
+const frontmatterToggleButton = "_frontmatterToggleButton_gm91f_341";
+const frontmatterEditorTable = "_frontmatterEditorTable_gm91f_349";
+const iconButton = "_iconButton_gm91f_367";
+const frontmatterInput = "_frontmatterInput_gm91f_373";
+const primaryButton = "_primaryButton_gm91f_388";
+const linkDialogEditForm = "_linkDialogEditForm_gm91f_398";
+const linkDialogInputContainer = "_linkDialogInputContainer_gm91f_404";
+const linkDialogInputWrapper = "_linkDialogInputWrapper_gm91f_410";
+const linkDialogInput = "_linkDialogInput_gm91f_404";
+const linkDialogAutocompleteContainer = "_linkDialogAutocompleteContainer_gm91f_440";
+const linkDialogAnchor = "_linkDialogAnchor_gm91f_485";
+const linkDialogPopoverContent = "_linkDialogPopoverContent_gm91f_499";
+const tableColumnEditorPopoverContent = "_tableColumnEditorPopoverContent_gm91f_499";
+const dialogContent = "_dialogContent_gm91f_499";
+const linkDialogPreviewAnchor = "_linkDialogPreviewAnchor_gm91f_513";
+const tooltipContent = "_tooltipContent_gm91f_535";
+const actionButton = "_actionButton_gm91f_549";
+const primaryActionButton = "_primaryActionButton_gm91f_555";
+const tableEditor = "_tableEditor_gm91f_564";
+const toolCell = "_toolCell_gm91f_575";
+const tableColumnEditorTrigger = "_tableColumnEditorTrigger_gm91f_592";
+const tableRowEditorTrigger = "_tableRowEditorTrigger_gm91f_592";
+const addRowButton = "_addRowButton_gm91f_592";
+const addColumnButton = "_addColumnButton_gm91f_592";
+const tableColumnEditorToolbar = "_tableColumnEditorToolbar_gm91f_626";
+const toggleGroupRoot = "_toggleGroupRoot_gm91f_638";
+const tableToolsColumn = "_tableToolsColumn_gm91f_655";
+const leftAlignedCell = "_leftAlignedCell_gm91f_663";
+const rightAlignedCell = "_rightAlignedCell_gm91f_667";
+const centeredCell = "_centeredCell_gm91f_671";
+const dialogOverlay = "_dialogOverlay_gm91f_699";
+const overlayShow = "_overlayShow_gm91f_1";
+const contentShow = "_contentShow_gm91f_1";
+const styles = {
+  editorRoot,
+  editorWrapper,
+  nestedListItem,
+  toolbarRoot,
+  toolbarModeSwitch,
+  toolbarToggleItem,
+  toolbarGroupOfGroups,
+  toolbarToggleSingleGroup,
+  toolbarButton,
+  toolbarNodeKindSelectContainer,
+  toolbarButtonDropdownContainer,
+  toolbarCodeBlockLanguageSelectContent,
+  toolbarNodeKindSelectTrigger,
+  toolbarButtonSelectTrigger,
+  toolbarCodeBlockLanguageSelectTrigger,
+  toolbarNodeKindSelectItem,
+  toolbarNodeKindSelectDropdownArrow,
+  contentEditable,
+  sandpackWrapper,
+  frontmatterWrapper,
+  frontmatterToggleButton,
+  frontmatterEditorTable,
+  iconButton,
+  frontmatterInput,
+  primaryButton,
+  linkDialogEditForm,
+  linkDialogInputContainer,
+  linkDialogInputWrapper,
+  linkDialogInput,
+  linkDialogAutocompleteContainer,
+  linkDialogAnchor,
+  linkDialogPopoverContent,
+  tableColumnEditorPopoverContent,
+  dialogContent,
+  linkDialogPreviewAnchor,
+  tooltipContent,
+  actionButton,
+  primaryActionButton,
+  tableEditor,
+  toolCell,
+  tableColumnEditorTrigger,
+  tableRowEditorTrigger,
+  addRowButton,
+  addColumnButton,
+  tableColumnEditorToolbar,
+  toggleGroupRoot,
+  tableToolsColumn,
+  leftAlignedCell,
+  rightAlignedCell,
+  centeredCell,
+  dialogOverlay,
+  overlayShow,
+  contentShow
+};
+createCommand();
+const MAX_SUGGESTIONS$1 = 20;
+function LinkEditForm({ initialUrl, onSubmit, onCancel, linkAutocompleteSuggestions }) {
+  const [items, setItems] = React__default.useState(linkAutocompleteSuggestions.slice(0, MAX_SUGGESTIONS$1));
+  const { isOpen, getToggleButtonProps, getMenuProps, getInputProps, highlightedIndex, getItemProps, selectedItem } = useCombobox({
+    initialInputValue: initialUrl,
+    onInputValueChange({ inputValue }) {
+      inputValue = (inputValue == null ? void 0 : inputValue.toLowerCase()) || "";
+      const matchingItems = [];
+      for (const url of linkAutocompleteSuggestions) {
+        if (url.toLowerCase().includes(inputValue)) {
+          matchingItems.push(url);
+          if (matchingItems.length >= MAX_SUGGESTIONS$1) {
+            break;
+          }
+        }
+      }
+      setItems(matchingItems);
+    },
+    items,
+    itemToString(item) {
+      return item ?? "";
+    }
+  });
+  const onSubmitEH = (e) => {
+    e.preventDefault();
+    onSubmit(selectedItem || "");
+  };
+  const onKeyDownEH = React__default.useCallback(
+    (e) => {
+      var _a;
+      if (e.key === "Escape") {
+        (_a = e.target.form) == null ? void 0 : _a.reset();
+      } else if (e.key === "Enter" && (!isOpen || items.length === 0)) {
+        e.preventDefault();
+        onSubmit(e.target.value);
+      }
+    },
+    [isOpen, items, onSubmit]
+  );
+  const downshiftInputProps = getInputProps();
+  const inputProps = {
+    ...downshiftInputProps,
+    onKeyDown: (e) => {
+      onKeyDownEH(e);
+      downshiftInputProps.onKeyDown(e);
+    }
+  };
+  const dropdownIsVisible = isOpen && items.length > 0;
+  return /* @__PURE__ */ React__default.createElement("form", { onSubmit: onSubmitEH, onReset: onCancel, className: classNames(styles.linkDialogEditForm) }, /* @__PURE__ */ React__default.createElement("div", { className: styles.linkDialogInputContainer }, /* @__PURE__ */ React__default.createElement("div", { "data-visible-dropdown": dropdownIsVisible, className: styles.linkDialogInputWrapper }, /* @__PURE__ */ React__default.createElement("input", { className: styles.linkDialogInput, ...inputProps, autoFocus: true, size: 30, "data-editor-dialog": true }), /* @__PURE__ */ React__default.createElement("button", { "aria-label": "toggle menu", type: "button", ...getToggleButtonProps() }, /* @__PURE__ */ React__default.createElement(DropDownIcon, null))), /* @__PURE__ */ React__default.createElement("div", { className: styles.linkDialogAutocompleteContainer }, /* @__PURE__ */ React__default.createElement("ul", { ...getMenuProps(), "data-visible": dropdownIsVisible }, items.map((item, index2) => /* @__PURE__ */ React__default.createElement(
+    "li",
+    {
+      "data-selected": selectedItem === item,
+      "data-highlighted": highlightedIndex === index2,
+      key: `${item}${index2}`,
+      ...getItemProps({ item, index: index2 })
+    },
+    item
+  ))))), /* @__PURE__ */ React__default.createElement(ActionButton$1, { type: "submit", title: "Set URL", "aria-label": "Set URL" }, /* @__PURE__ */ React__default.createElement(CheckIcon, null)), /* @__PURE__ */ React__default.createElement(ActionButton$1, { type: "reset", title: "Cancel change", "aria-label": "Cancel change" }, /* @__PURE__ */ React__default.createElement(CloseIcon, null)));
+}
+function LinkDialogPlugin() {
+  const [editorRootElementRef] = useEmitterValues("editorRootElementRef");
+  const publishWindowChange = usePublisher("onWindowChange");
+  const [linkDialogState, linkAutocompleteSuggestions, activeEditor] = useEmitterValues(
+    "linkDialogState",
+    "linkAutocompleteSuggestions",
+    "activeEditor"
+  );
+  const updateLinkUrl = usePublisher("updateLinkUrl");
+  const cancelLinkEdit = usePublisher("cancelLinkEdit");
+  const switchFromPreviewToLinkEdit = usePublisher("switchFromPreviewToLinkEdit");
+  const removeLink = usePublisher("removeLink");
+  const applyLinkChanges = usePublisher("applyLinkChanges");
+  React__default.useEffect(() => {
+    const update = () => {
+      activeEditor == null ? void 0 : activeEditor.getEditorState().read(() => {
+        publishWindowChange(true);
+      });
+    };
+    window.addEventListener("resize", update);
+    window.addEventListener("scroll", update);
+    return () => {
+      window.removeEventListener("resize", update);
+      window.removeEventListener("scroll", update);
+    };
+  }, [activeEditor, publishWindowChange]);
+  const [copyUrlTooltipOpen, setCopyUrlTooltipOpen] = React__default.useState(false);
+  const theRect = linkDialogState == null ? void 0 : linkDialogState.rectangle;
+  const onSubmitEH = React__default.useCallback(
+    (url) => {
+      updateLinkUrl(url);
+      applyLinkChanges(true);
+    },
+    [applyLinkChanges, updateLinkUrl]
+  );
+  const urlIsExternal = linkDialogState.type === "preview" && linkDialogState.url.startsWith("http");
+  return /* @__PURE__ */ React__default.createElement(RadixPopover.Root, { open: linkDialogState.type !== "inactive" }, /* @__PURE__ */ React__default.createElement(
+    RadixPopover.Anchor,
+    {
+      "data-visible": linkDialogState.type === "edit",
+      className: styles.linkDialogAnchor,
+      style: {
+        top: theRect == null ? void 0 : theRect.top,
+        left: theRect == null ? void 0 : theRect.left,
+        width: theRect == null ? void 0 : theRect.width,
+        height: theRect == null ? void 0 : theRect.height
+      }
+    }
+  ), /* @__PURE__ */ React__default.createElement(RadixPopover.Portal, { container: editorRootElementRef == null ? void 0 : editorRootElementRef.current }, /* @__PURE__ */ React__default.createElement(
+    RadixPopover.Content,
+    {
+      className: classNames(styles.linkDialogPopoverContent),
+      sideOffset: 5,
+      onOpenAutoFocus: (e) => e.preventDefault(),
+      key: linkDialogState.linkNodeKey
+    },
+    linkDialogState.type === "edit" && /* @__PURE__ */ React__default.createElement(
+      LinkEditForm,
+      {
+        initialUrl: linkDialogState.url,
+        onSubmit: onSubmitEH,
+        onCancel: cancelLinkEdit.bind(null, true),
+        linkAutocompleteSuggestions
+      }
+    ),
+    linkDialogState.type === "preview" && /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement(
+      "a",
+      {
+        className: styles.linkDialogPreviewAnchor,
+        href: linkDialogState.url,
+        ...urlIsExternal ? { target: "_blank", rel: "noreferrer" } : {},
+        title: urlIsExternal ? `Open ${linkDialogState.url} in new window` : linkDialogState.url
+      },
+      /* @__PURE__ */ React__default.createElement("span", null, linkDialogState.url),
+      urlIsExternal && /* @__PURE__ */ React__default.createElement(OpenInNewIcon, null)
+    ), /* @__PURE__ */ React__default.createElement(ActionButton$1, { onClick: () => switchFromPreviewToLinkEdit(true), title: "Edit link URL", "aria-label": "Edit link URL" }, /* @__PURE__ */ React__default.createElement(EditIcon, null)), /* @__PURE__ */ React__default.createElement(Tooltip.Provider, null, /* @__PURE__ */ React__default.createElement(Tooltip.Root, { open: copyUrlTooltipOpen }, /* @__PURE__ */ React__default.createElement(Tooltip.Trigger, { asChild: true }, /* @__PURE__ */ React__default.createElement(
+      ActionButton$1,
+      {
+        title: "Copy to clipboard",
+        "aria-label": "Copy link URL",
+        onClick: () => {
+          void window.navigator.clipboard.writeText(linkDialogState.url).then(() => {
+            setCopyUrlTooltipOpen(true);
+            setTimeout(() => setCopyUrlTooltipOpen(false), 1e3);
+          });
+        }
+      },
+      copyUrlTooltipOpen ? /* @__PURE__ */ React__default.createElement(CheckIcon, null) : /* @__PURE__ */ React__default.createElement(CopyIcon, null)
+    )), /* @__PURE__ */ React__default.createElement(Tooltip.Portal, { container: editorRootElementRef == null ? void 0 : editorRootElementRef.current }, /* @__PURE__ */ React__default.createElement(Tooltip.Content, { className: classNames(styles.tooltipContent), sideOffset: 5 }, "Copied!", /* @__PURE__ */ React__default.createElement(Tooltip.Arrow, null))))), /* @__PURE__ */ React__default.createElement(ActionButton$1, { title: "Remove link", "aria-label": "Remove link", onClick: () => removeLink(true) }, /* @__PURE__ */ React__default.createElement(LinkOffIcon, null)))
+  )));
+}
+const ActionButton$1 = React__default.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ React__default.createElement("button", { className: classNames(styles.actionButton, className), ref, ...props });
+});
+function getElementNodesInSelection(selection) {
+  const nodesInSelection = selection.getNodes();
+  if (nodesInSelection.length === 0) {
+    return /* @__PURE__ */ new Set([selection.anchor.getNode().getParentOrThrow(), selection.focus.getNode().getParentOrThrow()]);
+  }
+  return new Set(nodesInSelection.map((n) => $isElementNode(n) ? n : n.getParentOrThrow()));
+}
+function isIndentPermitted(maxDepth) {
+  const selection = $getSelection();
+  if (!$isRangeSelection(selection)) {
+    return false;
+  }
+  const elementNodesInSelection = getElementNodesInSelection(selection);
+  let totalDepth = 0;
+  for (const elementNode of elementNodesInSelection) {
+    if ($isListNode(elementNode)) {
+      totalDepth = Math.max($getListDepth(elementNode) + 1, totalDepth);
+    } else if ($isListItemNode(elementNode)) {
+      const parent = elementNode.getParent();
+      if ((parent == null ? void 0 : parent.getChildren().length) === 1) {
+        const grandParentListItem = parent == null ? void 0 : parent.getParent();
+        if ($isListItemNode(grandParentListItem) && grandParentListItem.getChildren().length === 1) {
+          return false;
+        }
+      }
+      if (!$isListNode(parent)) {
+        throw new Error("ListMaxIndentLevelPlugin: A ListItemNode must have a ListNode for a parent.");
+      }
+      totalDepth = Math.max($getListDepth(parent) + 1, totalDepth);
+    }
+  }
+  return totalDepth <= maxDepth;
+}
+function ListMaxIndentLevelPlugin({ maxDepth }) {
+  const [editor] = useLexicalComposerContext();
+  useEffect(() => {
+    return editor.registerCommand(INDENT_CONTENT_COMMAND, () => !isIndentPermitted(maxDepth ?? 7), COMMAND_PRIORITY_CRITICAL);
+  }, [editor, maxDepth]);
+  return null;
+}
+function patchMarkdownTransformers(transformers) {
+  const codeTransformer = transformers.find((t) => t === CODE);
+  codeTransformer.replace = (parentNode, _children, match) => {
+    const codeBlockNode = $createCodeBlockNode({ code: "", language: match ? match[1] : "", meta: "" });
+    parentNode.replace(codeBlockNode);
+    setTimeout(() => codeBlockNode.select(), 80);
+  };
+  return transformers;
+}
+const PatchedMarkdownShortcutPlugin = () => {
+  return /* @__PURE__ */ React__default.createElement(MarkdownShortcutPlugin, { transformers: patchMarkdownTransformers(TRANSFORMERS) });
+};
+const SharedHistoryPlugin = () => {
+  const [historyState] = useEmitterValues("historyState");
+  return /* @__PURE__ */ React__default.createElement(HistoryPlugin, { externalHistoryState: historyState });
+};
+const index = "";
+function DiffViewer({ oldText, newText }) {
+  const diffText = formatLines(diffLines(oldText, newText), { context: 3 });
+  if (diffText.trim() === "")
+    return /* @__PURE__ */ React__default.createElement("div", null, "No changes");
+  const [diff] = parseDiff(diffText, { nearbySequences: "zip" });
+  return /* @__PURE__ */ React__default.createElement(Diff, { viewType: "split", diffType: "modify", hunks: diff.hunks || [] }, (hunks) => hunks.map((hunk) => /* @__PURE__ */ React__default.createElement(Hunk, { key: hunk.content, hunk })));
+}
+function MarkdownDiffView() {
+  const [markdown2, headMarkdown] = useEmitterValues("markdownSource", "headMarkdown");
+  return /* @__PURE__ */ React__default.createElement(DiffViewer, { oldText: headMarkdown, newText: markdown2 });
+}
+const ViewModeToggler = ({ children }) => {
+  const [viewMode] = useEmitterValues("viewMode");
+  return /* @__PURE__ */ React__default.createElement("div", null, /* @__PURE__ */ React__default.createElement("div", { style: { display: viewMode === "editor" ? "block" : "none" } }, children), viewMode === "diff" ? /* @__PURE__ */ React__default.createElement(MarkdownDiffView, null) : null, viewMode === "markdown" ? /* @__PURE__ */ React__default.createElement(SourceEditor, null) : null);
+};
+const SourceEditor = () => {
+  const [markdown$1] = useEmitterValues("markdownSource");
+  const updateMarkdown = usePublisher("markdownSource");
+  const codeMirrorRef = React__default.useRef(null);
+  return /* @__PURE__ */ React__default.createElement("div", null, /* @__PURE__ */ React__default.createElement(SandpackProvider, null, /* @__PURE__ */ React__default.createElement(
+    CodeEditor,
+    {
+      showLineNumbers: true,
+      additionalLanguages: [{ name: "markdown", extensions: ["md"], language: markdown() }],
+      initMode: "lazy",
+      filePath: `file.md`,
+      code: markdown$1,
+      onCodeUpdate: updateMarkdown,
+      ref: codeMirrorRef
+    }
+  )));
+};
+const InstantTooltip = React__default.forwardRef(({ title, children }, ref) => {
+  const [editorRootElementRef] = useEmitterValues("editorRootElementRef");
+  return /* @__PURE__ */ React__default.createElement(Tooltip.Provider, { delayDuration: 100 }, /* @__PURE__ */ React__default.createElement(Tooltip.Root, null, /* @__PURE__ */ React__default.createElement(Tooltip.Trigger, { ref, asChild: true }, /* @__PURE__ */ React__default.createElement("span", null, children)), /* @__PURE__ */ React__default.createElement(Tooltip.Portal, { container: editorRootElementRef == null ? void 0 : editorRootElementRef.current }, /* @__PURE__ */ React__default.createElement(Tooltip.Content, { className: classNames(styles.tooltipContent), sideOffset: 10 }, title))));
+});
+const SelectItem = React__default.forwardRef(
+  ({ children, className, ...props }, forwardedRef) => {
+    return /* @__PURE__ */ React__default.createElement(Select.Item, { ...props, ref: forwardedRef, className: classNames(className, styles.toolbarNodeKindSelectItem) }, /* @__PURE__ */ React__default.createElement(Select.ItemText, null, children));
+  }
+);
+const SelectTrigger = ({ title, placeholder, className }) => {
+  return /* @__PURE__ */ React__default.createElement(InstantTooltip, { title }, /* @__PURE__ */ React__default.createElement(Select.Trigger, { "aria-label": placeholder, className: classNames(styles.toolbarNodeKindSelectTrigger, className) }, /* @__PURE__ */ React__default.createElement(Select.Value, { placeholder }), /* @__PURE__ */ React__default.createElement(Select.Icon, { className: styles.toolbarNodeKindSelectDropdownArrow }, /* @__PURE__ */ React__default.createElement(DropDownIcon, null))));
+};
+const SelectContent = ({
+  children,
+  className = styles.toolbarNodeKindSelectContainer
+}) => {
+  const [editorRootElementRef] = useEmitterValues("editorRootElementRef");
+  return /* @__PURE__ */ React__default.createElement(Select.Portal, { container: editorRootElementRef == null ? void 0 : editorRootElementRef.current }, /* @__PURE__ */ React__default.createElement(Select.Content, { className, onCloseAutoFocus: (e) => e.preventDefault(), position: "popper" }, /* @__PURE__ */ React__default.createElement(Select.Viewport, null, children)));
+};
+const SelectButtonTrigger = ({
+  children,
+  title,
+  className
+}) => {
+  return /* @__PURE__ */ React__default.createElement(InstantTooltip, { title }, /* @__PURE__ */ React__default.createElement(Select.Trigger, { className: classNames(styles.toolbarButtonSelectTrigger, className) }, children, /* @__PURE__ */ React__default.createElement(Select.Icon, { className: styles.toolbarNodeKindSelectDropdownArrow }, /* @__PURE__ */ React__default.createElement(DropDownIcon, null))));
+};
+function CodeBlockLanguageSelect() {
+  const [activeEditorType, activeEditor, codeBlockLanguages] = useEmitterValues("activeEditorType", "activeEditor", "codeBlockLanguages");
+  const nodeLanguage = React__default.useMemo(() => {
+    let language;
+    activeEditor.getEditorState().read(() => {
+      const node = $getNodeByKey(activeEditorType.nodeKey);
+      language = node.getLanguage();
+    });
+    return language;
+  }, [activeEditor, activeEditorType]);
+  return /* @__PURE__ */ React__default.createElement(
+    Select.Root,
+    {
+      value: nodeLanguage,
+      onValueChange: (language) => {
+        activeEditor.update(() => {
+          const node = $getNodeByKey(activeEditorType.nodeKey);
+          node.setLanguage(language);
+          setTimeout(() => {
+            node.select();
+          }, 80);
+        });
+      }
+    },
+    /* @__PURE__ */ React__default.createElement(SelectTrigger, { title: "Change code block language", placeholder: "Language", className: styles.toolbarCodeBlockLanguageSelectTrigger }),
+    /* @__PURE__ */ React__default.createElement(SelectContent, { className: styles.toolbarCodeBlockLanguageSelectContent }, Object.entries(codeBlockLanguages).map(([value, label]) => /* @__PURE__ */ React__default.createElement(SelectItem, { key: value, value }, label)))
+  );
+}
+const SvgDelete = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M5 21V6H4V4h5V3h6v1h5v2h-1v15H5Zm2-2h10V6H7v13Zm2-2h2V8H9v9Zm4 0h2V8h-2v9Z" })));
+const DeleteIcon = SvgDelete;
+const SvgCode = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "m8 18-6-6 6-6 1.425 1.425-4.6 4.6L9.4 16.6 8 18Zm8 0-1.425-1.425 4.6-4.6L14.6 7.4 16 6l6 6-6 6Z" })));
+const CodeIcon = SvgCode;
+const SvgDeployedCode = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "m5 15.95 6 3.475v-6.85L5 9.1v6.85Zm8 3.475 6-3.475V9.1l-6 3.475v6.85Zm-6.925-12L12 10.85l5.925-3.425L12 4 6.075 7.425ZM3 17.125V6.875L12 1.7l9 5.175v10.25L12 22.3l-9-5.175Z" })));
+const LiveCodeIcon = SvgDeployedCode;
+const SvgDifference = (props) => /* @__PURE__ */ React.createElement("svg", { width: 25, height: 24, viewBox: "0 0 25 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "mask0_318_257", style: {
+  maskType: "alpha"
+}, maskUnits: "userSpaceOnUse", x: 0, y: 0, width: 25, height: 24 }, /* @__PURE__ */ React.createElement("rect", { x: 0.929688, width: 24, height: 24, fill: "#D9D9D9" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#mask0_318_257)" }, /* @__PURE__ */ React.createElement("path", { d: "M12.4297 12H14.4297V10H16.4297V8H14.4297V6H12.4297V8H10.4297V10H12.4297V12ZM10.4297 16H16.4297V14H10.4297V16ZM5.92969 20V2H14.9297L20.9297 8V20H5.92969ZM7.92969 18H18.9297V9L13.9297 4H7.92969V18Z", fill: "currentColor" })));
+const DifferenceIcon = SvgDifference;
+const SvgFormatBold = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M6.8 19V5h5.525c1.083 0 2.083.333 3 1 .917.667 1.375 1.592 1.375 2.775 0 .85-.192 1.504-.575 1.962-.383.459-.742.788-1.075.988.417.183.88.525 1.388 1.025.508.5.762 1.25.762 2.25 0 1.483-.542 2.521-1.625 3.113-1.083.591-2.1.887-3.05.887H6.8Zm3.025-2.8h2.6c.8 0 1.287-.204 1.462-.613.175-.408.263-.704.263-.887 0-.183-.088-.48-.263-.888-.175-.408-.687-.612-1.537-.612H9.825v3Zm0-5.7h2.325c.55 0 .95-.142 1.2-.425a1.4 1.4 0 0 0 .375-.95c0-.4-.142-.725-.425-.975-.283-.25-.65-.375-1.1-.375H9.825V10.5Z" })));
+const BoldIcon = SvgFormatBold;
+const SvgFormatItalic = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M5 19v-2.5h4l3-9H8V5h10v2.5h-3.5l-3 9H15V19H5Z" })));
+const ItalicIcon = SvgFormatItalic;
+const SvgFormatListBulleted = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M9 19v-2h12v2H9Zm0-6v-2h12v2H9Zm0-6V5h12v2H9ZM5 20a1.93 1.93 0 0 1-1.413-.587A1.928 1.928 0 0 1 3 18c0-.55.196-1.021.587-1.413A1.928 1.928 0 0 1 5 16c.55 0 1.02.196 1.412.587.392.392.588.863.588 1.413s-.196 1.021-.588 1.413A1.925 1.925 0 0 1 5 20Zm0-6c-.55 0-1.021-.196-1.413-.588A1.925 1.925 0 0 1 3 12c0-.55.196-1.021.587-1.413A1.928 1.928 0 0 1 5 10c.55 0 1.02.196 1.412.587.392.392.588.863.588 1.413s-.196 1.02-.588 1.412A1.923 1.923 0 0 1 5 14Zm0-6c-.55 0-1.021-.196-1.413-.588A1.925 1.925 0 0 1 3 6c0-.55.196-1.02.587-1.412A1.927 1.927 0 0 1 5 4c.55 0 1.02.196 1.412.588C6.804 4.979 7 5.45 7 6c0 .55-.196 1.02-.588 1.412A1.923 1.923 0 0 1 5 8Z" })));
+const BulletedListIcon = SvgFormatListBulleted;
+const SvgFormatListNumbered = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M3 22v-1.5h2.5v-.75H4v-1.5h1.5v-.75H3V16h4v2.25L6 19l1 .75V22H3Zm0-7v-3.75h2.5v-.75H3V9h4v3.75H4.5v.75H7V15H3Zm1.5-7V3.5H3V2h3v6H4.5ZM9 19v-2h12v2H9Zm0-6v-2h12v2H9Zm0-6V5h12v2H9Z" })));
+const NumberedListIcon = SvgFormatListNumbered;
+const SvgFormatUnderlined = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M5 21v-2h14v2H5Zm7-4c-1.683 0-2.992-.525-3.925-1.575-.933-1.05-1.4-2.442-1.4-4.175V3H9.25v8.4c0 .933.233 1.692.7 2.275.467.583 1.15.875 2.05.875.9 0 1.583-.292 2.05-.875.467-.583.7-1.342.7-2.275V3h2.575v8.25c0 1.733-.467 3.125-1.4 4.175C14.992 16.475 13.683 17 12 17Z" })));
+const UnderlinedIcon = SvgFormatUnderlined;
+const SvgFrameSource = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M3 21v-6h2v4h4v2H3Zm12 0v-2h4v-4h2v6h-6Zm-6.4-5.4L5 12l3.6-3.6L10 9.825 7.825 12 10 14.175 8.6 15.6Zm6.8 0L14 14.175 16.175 12 14 9.825 15.4 8.4 19 12l-3.6 3.6ZM3 9V3h6v2H5v4H3Zm16 0V5h-4V3h6v6h-2Z" })));
+const FrameSourceIcon = SvgFrameSource;
+const SvgFrontmatter = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M5 7h4v2H5z" }), /* @__PURE__ */ React.createElement("path", { d: "M5 7h4v2H5zm0 7h4v2H5z" }), /* @__PURE__ */ React.createElement("path", { d: "M5 14h4v2H5zm5-7h4v2h-4z" }), /* @__PURE__ */ React.createElement("path", { d: "M10 7h4v2h-4zm0 7h4v2h-4z" }), /* @__PURE__ */ React.createElement("path", { d: "M10 14h4v2h-4zm5-7h4v2h-4z" }), /* @__PURE__ */ React.createElement("path", { d: "M15 7h4v2h-4zm0 7h4v2h-4z" }), /* @__PURE__ */ React.createElement("path", { d: "M15 14h4v2h-4z" })));
+const FrontmatterIcon = SvgFrontmatter;
+const SvgHorizontalRule = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M4 13v-2h16v2H4Z" })));
+const HorizontalRuleIcon = SvgHorizontalRule;
+const SvgLink = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M11 17H7c-1.383 0-2.562-.488-3.537-1.463C2.488 14.562 2 13.383 2 12s.488-2.563 1.463-3.538C4.438 7.487 5.617 7 7 7h4v2H7c-.833 0-1.542.292-2.125.875A2.893 2.893 0 0 0 4 12c0 .833.292 1.542.875 2.125A2.893 2.893 0 0 0 7 15h4v2Zm-3-4v-2h8v2H8Zm5 4v-2h4c.833 0 1.542-.292 2.125-.875A2.893 2.893 0 0 0 20 12c0-.833-.292-1.542-.875-2.125A2.893 2.893 0 0 0 17 9h-4V7h4c1.383 0 2.563.487 3.538 1.462C21.513 9.437 22 10.617 22 12s-.487 2.562-1.462 3.537C19.563 16.512 18.383 17 17 17h-4Z" })));
+const LinkIcon = SvgLink;
+const SvgMarkdown = (props) => /* @__PURE__ */ React.createElement("svg", { width: 24, height: 24, viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "mask0_46_56", style: {
+  maskType: "alpha"
+}, maskUnits: "userSpaceOnUse", x: 0, y: 0, width: 24, height: 24 }, /* @__PURE__ */ React.createElement("rect", { width: 24, height: 24, fill: "#D9D9D9" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#mask0_46_56)" }, /* @__PURE__ */ React.createElement("path", { d: "M19 19L14 14L15.4 12.575L18 15.175V5H20V15.175L22.6 12.575L24 14L19 19Z", fill: "currentColor" }), /* @__PURE__ */ React.createElement("path", { d: "M13 19H10.5V9L6.5 15L2.5 9V19H0V5H2.5L6.5 11L10.5 5H13V19Z", fill: "currentColor" })));
+const MarkdownIcon = SvgMarkdown;
+const SvgRichText = (props) => /* @__PURE__ */ React.createElement("svg", { width: 24, height: 24, viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "mask0_318_249", style: {
+  maskType: "alpha"
+}, maskUnits: "userSpaceOnUse", x: 0, y: 0, width: 24, height: 24 }, /* @__PURE__ */ React.createElement("rect", { width: 24, height: 24, fill: "#D9D9D9" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#mask0_318_249)" }, /* @__PURE__ */ React.createElement("path", { d: "M5 21V19H19V21H5Z", fill: "currentColor" }), /* @__PURE__ */ React.createElement("path", { d: "M6.80005 17V3H12.325C13.4084 3 14.4084 3.33333 15.325 4C16.2417 4.66667 16.7001 5.59167 16.7001 6.775C16.7001 7.625 16.5084 8.279 16.125 8.737C15.7417 9.19567 15.3834 9.525 15.05 9.725C15.4667 9.90833 15.9294 10.25 16.438 10.75C16.946 11.25 17.2001 12 17.2001 13C17.2001 14.4833 16.6584 15.521 15.575 16.113C14.4917 16.7043 13.475 17 12.525 17H6.80005ZM9.82505 14.2H12.425C13.225 14.2 13.7124 13.9957 13.887 13.587C14.0624 13.179 14.15 12.8833 14.15 12.7C14.15 12.5167 14.0624 12.2207 13.887 11.812C13.7124 11.404 13.2 11.2 12.35 11.2H9.82505V14.2ZM9.82505 8.5H12.15C12.7 8.5 13.1 8.35833 13.35 8.075C13.6 7.79167 13.725 7.475 13.725 7.125C13.725 6.725 13.5834 6.4 13.3 6.15C13.0167 5.9 12.65 5.775 12.2 5.775H9.82505V8.5Z", fill: "currentColor" })));
+const RichTextIcon = SvgRichText;
+const SvgTable = (props) => /* @__PURE__ */ React.createElement("svg", { xmlns: "http://www.w3.org/2000/svg", width: 24, height: 24, fill: "currentColor", viewBox: "0 0 24 24", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "a", width: 24, height: 24, x: 0, y: 0, maskUnits: "userSpaceOnUse", style: {
+  maskType: "alpha"
+} }, /* @__PURE__ */ React.createElement("path", { d: "M0 0h24v24H0z" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#a)" }, /* @__PURE__ */ React.createElement("path", { d: "M3 21V3h18v18H3ZM5 9h14V5H5v4Zm5.325 5h3.35v-3h-3.35v3Zm0 5h3.35v-3h-3.35v3ZM5 14h3.325v-3H5v3Zm10.675 0H19v-3h-3.325v3ZM5 19h3.325v-3H5v3Zm10.675 0H19v-3h-3.325v3Z" }), /* @__PURE__ */ React.createElement("path", { d: "M8.325 9h2V5h-2v4Zm5.35 0h2V5h-2v4Z" })));
+const TableIcon = SvgTable;
+const BlockTypeSelect = () => {
+  const [currentBlockType] = useEmitterValues("currentBlockType");
+  const applyBlockType = usePublisher("applyBlockType");
+  return /* @__PURE__ */ React__default.createElement(Select.Root, { value: currentBlockType || "", onValueChange: applyBlockType }, /* @__PURE__ */ React__default.createElement(SelectTrigger, { title: "Select block type", placeholder: "Block type" }), /* @__PURE__ */ React__default.createElement(SelectContent, null, /* @__PURE__ */ React__default.createElement(SelectItem, { value: "paragraph" }, "Paragraph"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "quote" }, "Quote"), /* @__PURE__ */ React__default.createElement(Select.Separator, null), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "h1" }, "Heading 1"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "h2" }, "Heading 2"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "h3" }, "Heading 3"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "h4" }, "Heading 4"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "h5" }, "Heading 5"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "h6" }, "Heading 6"), /* @__PURE__ */ React__default.createElement(Select.Separator, null), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "note" }, "Note"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "tip" }, "Tip"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "info" }, "Info"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "caution" }, "Caution"), /* @__PURE__ */ React__default.createElement(SelectItem, { value: "danger" }, "Danger")));
+};
+const SvgAddPhoto = (props) => /* @__PURE__ */ React.createElement("svg", { width: 24, height: 24, viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", ...props }, /* @__PURE__ */ React.createElement("mask", { id: "mask0_343_38", style: {
+  maskType: "alpha"
+}, maskUnits: "userSpaceOnUse", x: 0, y: 0, width: 24, height: 24 }, /* @__PURE__ */ React.createElement("rect", { width: 24, height: 24, fill: "#D9D9D9" })), /* @__PURE__ */ React.createElement("g", { mask: "url(#mask0_343_38)" }, /* @__PURE__ */ React.createElement("path", { d: "M3 21V3H14V5H5V19H19V10H21V21H3ZM17 9V7H15V5H17V3H19V5H21V7H19V9H17ZM6 17H18L14.25 12L11.25 16L9 13L6 17Z", fill: "currentColor" })));
+const AddPhotoIcon = SvgAddPhoto;
+const ImageButton = React__default.forwardRef((props, forwardedRef) => {
+  const [editorRootElementRef, imageAutocompleteSuggestions] = useEmitterValues("editorRootElementRef", "imageAutocompleteSuggestions");
+  const [open, setOpen] = React__default.useState(false);
+  const insertImage = usePublisher("insertImage");
+  const onSubmit = React__default.useCallback(
+    (url) => {
+      insertImage(url);
+      setOpen(false);
+    },
+    [insertImage]
+  );
+  return /* @__PURE__ */ React__default.createElement(Dialog.Root, { open, onOpenChange: setOpen }, /* @__PURE__ */ React__default.createElement(Dialog.Trigger, { asChild: true }, /* @__PURE__ */ React__default.createElement(RadixToolbar.Button, { className: styles.toolbarButton, ...props, ref: forwardedRef }, /* @__PURE__ */ React__default.createElement(InstantTooltip, { title: "Insert image" }, /* @__PURE__ */ React__default.createElement(AddPhotoIcon, null)))), /* @__PURE__ */ React__default.createElement(Dialog.Portal, { container: editorRootElementRef.current }, /* @__PURE__ */ React__default.createElement(Dialog.Overlay, { className: styles.dialogOverlay }), /* @__PURE__ */ React__default.createElement(Dialog.Content, { className: styles.dialogContent }, /* @__PURE__ */ React__default.createElement(ImageForm, { initialUrl: "", onSubmit, imageAutocompleteSuggestions }))));
+});
+createCommand();
+const MAX_SUGGESTIONS = 20;
+const ImageForm = ({ initialUrl, onSubmit, imageAutocompleteSuggestions }) => {
+  const [items, setItems] = React__default.useState(imageAutocompleteSuggestions.slice(0, MAX_SUGGESTIONS));
+  const { isOpen, getToggleButtonProps, getMenuProps, getInputProps, highlightedIndex, getItemProps, selectedItem } = useCombobox({
+    initialInputValue: initialUrl,
+    onInputValueChange({ inputValue }) {
+      inputValue = (inputValue == null ? void 0 : inputValue.toLowerCase()) || "";
+      const matchingItems = [];
+      for (const url of imageAutocompleteSuggestions) {
+        if (url.toLowerCase().includes(inputValue)) {
+          matchingItems.push(url);
+          if (matchingItems.length >= MAX_SUGGESTIONS) {
+            break;
+          }
+        }
+      }
+      setItems(matchingItems);
+    },
+    items,
+    itemToString(item) {
+      return item ?? "";
+    }
+  });
+  const onSubmitEH = (e) => {
+    e.preventDefault();
+    onSubmit(selectedItem || "");
+  };
+  const onKeyDownEH = React__default.useCallback(
+    (e) => {
+      var _a;
+      if (e.key === "Escape") {
+        (_a = e.target.form) == null ? void 0 : _a.reset();
+      } else if (e.key === "Enter" && (!isOpen || items.length === 0)) {
+        e.preventDefault();
+        onSubmit(e.target.value);
+      }
+    },
+    [isOpen, items, onSubmit]
+  );
+  const downshiftInputProps = getInputProps();
+  const inputProps = {
+    ...downshiftInputProps,
+    onKeyDown: (e) => {
+      onKeyDownEH(e);
+      downshiftInputProps.onKeyDown(e);
+    }
+  };
+  const dropdownIsVisible = isOpen && items.length > 0;
+  return /* @__PURE__ */ React__default.createElement("form", { onSubmit: onSubmitEH, className: classNames(styles.linkDialogEditForm) }, /* @__PURE__ */ React__default.createElement("div", { className: styles.linkDialogInputContainer }, /* @__PURE__ */ React__default.createElement("div", { "data-visible-dropdown": dropdownIsVisible, className: styles.linkDialogInputWrapper }, /* @__PURE__ */ React__default.createElement(
+    "input",
+    {
+      placeholder: "Paste or select an image url",
+      className: styles.linkDialogInput,
+      ...inputProps,
+      autoFocus: true,
+      size: 30,
+      "data-editor-dialog": true
+    }
+  ), /* @__PURE__ */ React__default.createElement("button", { "aria-label": "toggle menu", type: "button", ...getToggleButtonProps() }, /* @__PURE__ */ React__default.createElement(DropDownIcon, null))), /* @__PURE__ */ React__default.createElement("div", { className: styles.linkDialogAutocompleteContainer }, /* @__PURE__ */ React__default.createElement("ul", { ...getMenuProps(), "data-visible": dropdownIsVisible }, items.map((item, index2) => /* @__PURE__ */ React__default.createElement(
+    "li",
+    {
+      "data-selected": selectedItem === item,
+      "data-highlighted": highlightedIndex === index2,
+      key: `${item}${index2}`,
+      ...getItemProps({ item, index: index2 })
+    },
+    item
+  ))))), /* @__PURE__ */ React__default.createElement(ActionButton, { type: "submit", title: "Insert image", "aria-label": "Insert image", className: styles.primaryActionButton }, /* @__PURE__ */ React__default.createElement(CheckIcon, null)), /* @__PURE__ */ React__default.createElement(Dialog.Close, { className: styles.actionButton }, /* @__PURE__ */ React__default.createElement(CloseIcon, null)));
+};
+const ActionButton = React__default.forwardRef(({ className, ...props }, ref) => {
+  return /* @__PURE__ */ React__default.createElement("button", { className: classNames(styles.actionButton, className), ref, ...props });
+});
+const ToggleItem = React__default.forwardRef(
+  ({ title, children, className: passedClassName, ...props }, forwardedRef) => {
+    return /* @__PURE__ */ React__default.createElement(RadixToolbar.ToggleItem, { className: classNames(passedClassName, styles.toolbarToggleItem), ...props, ref: forwardedRef }, /* @__PURE__ */ React__default.createElement(InstantTooltip, { title }, children));
+  }
+);
+const ToolbarButton = React__default.forwardRef(
+  ({ title, children, ...props }, forwardedRef) => {
+    return /* @__PURE__ */ React__default.createElement(RadixToolbar.Button, { className: styles.toolbarButton, ...props, ref: forwardedRef }, /* @__PURE__ */ React__default.createElement(InstantTooltip, { title }, children));
+  }
+);
+const ToggleSingleGroup = React__default.forwardRef(
+  ({ children, className, ...props }, forwardedRef) => {
+    return /* @__PURE__ */ React__default.createElement(
+      RadixToolbar.ToggleGroup,
+      {
+        ...props,
+        type: "single",
+        ref: forwardedRef,
+        className: classNames(styles.toolbarToggleSingleGroup, className)
+      },
+      children
+    );
+  }
+);
+const ToggleSingleGroupWithItem = React__default.forwardRef(({ on, title, children, ...props }, forwardedRef) => {
+  return /* @__PURE__ */ React__default.createElement(ToggleSingleGroup, { ...props, value: on ? "on" : "off", ref: forwardedRef }, /* @__PURE__ */ React__default.createElement(ToggleItem, { title, value: "on" }, children));
+});
+const GroupGroup = ({ children }) => {
+  return /* @__PURE__ */ React__default.createElement("div", { className: styles.toolbarGroupOfGroups }, children);
+};
+const ToolbarSeparator = RadixToolbar.ToolbarSeparator;
+const BoldItalicUnderlineButtons = () => {
+  const [currentFormat] = useEmitterValues("currentFormat", "currentListType");
+  const applyFormat = usePublisher("applyFormat");
+  const boldIsOn = (currentFormat & IS_BOLD) !== 0;
+  const italicIsOn = (currentFormat & IS_ITALIC) !== 0;
+  const underlineIsOn = (currentFormat & IS_UNDERLINE) !== 0;
+  const boldTitle = boldIsOn ? "Remove bold" : "Bold";
+  const italicTitle = italicIsOn ? "Remove italic" : "Italic";
+  const underlineTitle = underlineIsOn ? "Remove underline" : "Underline";
+  return /* @__PURE__ */ React__default.createElement(GroupGroup, null, /* @__PURE__ */ React__default.createElement(ToggleSingleGroupWithItem, { title: boldTitle, "aria-label": "Bold", on: boldIsOn, onValueChange: applyFormat.bind(null, "bold") }, /* @__PURE__ */ React__default.createElement(BoldIcon, null)), /* @__PURE__ */ React__default.createElement(ToggleSingleGroupWithItem, { title: italicTitle, "aria-label": "Italic", on: italicIsOn, onValueChange: applyFormat.bind(null, "italic") }, /* @__PURE__ */ React__default.createElement(ItalicIcon, null)), /* @__PURE__ */ React__default.createElement(
+    ToggleSingleGroupWithItem,
+    {
+      "aria-label": "Underline",
+      title: underlineTitle,
+      on: underlineIsOn,
+      onValueChange: applyFormat.bind(null, "underline")
+    },
+    /* @__PURE__ */ React__default.createElement(UnderlinedIcon, { style: { transform: "translateY(2px)" } })
+  ));
+};
+const CodeFormattingButton = () => {
+  const [currentFormat] = useEmitterValues("currentFormat", "currentListType");
+  const applyFormat = usePublisher("applyFormat");
+  const codeIsOn = (currentFormat & IS_CODE) !== 0;
+  const codeTitle = codeIsOn ? "Remove inline code" : "Inline code";
+  return /* @__PURE__ */ React__default.createElement(GroupGroup, null, /* @__PURE__ */ React__default.createElement(ToggleSingleGroupWithItem, { title: codeTitle, "aria-label": "Inline code", on: codeIsOn, onValueChange: applyFormat.bind(null, "code") }, /* @__PURE__ */ React__default.createElement(CodeIcon, null)));
+};
+const ListButtons = () => {
+  const [currentListType] = useEmitterValues("currentListType");
+  const applyListType = usePublisher("applyListType");
+  return /* @__PURE__ */ React__default.createElement(GroupGroup, null, /* @__PURE__ */ React__default.createElement(
+    ToggleSingleGroup,
+    {
+      "aria-label": "List type",
+      onValueChange: applyListType,
+      value: currentListType || "",
+      onFocus: (e) => e.preventDefault()
+    },
+    /* @__PURE__ */ React__default.createElement(ToggleItem, { title: "Bulleted list", value: "bullet", "aria-label": "Bulleted list" }, /* @__PURE__ */ React__default.createElement(BulletedListIcon, null)),
+    /* @__PURE__ */ React__default.createElement(ToggleItem, { title: "Numbered list", value: "number", "aria-label": "Numbered list" }, /* @__PURE__ */ React__default.createElement(NumberedListIcon, null))
+  ));
+};
+const LinkButton = () => {
+  const openLinkEditDialog = usePublisher("openLinkEditDialog");
+  return /* @__PURE__ */ React__default.createElement(ToolbarButton, { title: "Create link", onClick: openLinkEditDialog.bind(null, true) }, /* @__PURE__ */ React__default.createElement(LinkIcon, null));
+};
+const TableButton = () => {
+  const insertTable = usePublisher("insertTable");
+  return /* @__PURE__ */ React__default.createElement(ToolbarButton, { title: "Insert table", onClick: insertTable.bind(null, true) }, /* @__PURE__ */ React__default.createElement(TableIcon, null));
+};
+const CodeBlockButton = () => {
+  const insertCodeBlock = usePublisher("insertCodeBlock");
+  return /* @__PURE__ */ React__default.createElement(ToolbarButton, { title: "Insert code block", onClick: insertCodeBlock.bind(null, true) }, /* @__PURE__ */ React__default.createElement(FrameSourceIcon, null));
+};
+const HorizontalRuleButton = () => {
+  const insertHorizontalRule = usePublisher("insertHorizontalRule");
+  return /* @__PURE__ */ React__default.createElement(ToolbarButton, { title: "Insert horizontal rule", onClick: insertHorizontalRule.bind(null, true) }, /* @__PURE__ */ React__default.createElement(HorizontalRuleIcon, null));
+};
+const SandpackButton = () => {
+  const insertSandpack = usePublisher("insertSandpack");
+  const [sandpackConfig] = useEmitterValues("sandpackConfig");
+  return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, sandpackConfig.presets.length === 1 ? /* @__PURE__ */ React__default.createElement(ToolbarButton, { title: "Insert live code block", onClick: insertSandpack.bind(null, "") }, /* @__PURE__ */ React__default.createElement(LiveCodeIcon, null)) : /* @__PURE__ */ React__default.createElement(Select.Root, { value: "", onValueChange: insertSandpack }, /* @__PURE__ */ React__default.createElement(SelectButtonTrigger, { title: "Insert live code snippet" }, /* @__PURE__ */ React__default.createElement(LiveCodeIcon, null)), /* @__PURE__ */ React__default.createElement(SelectContent, { className: styles.toolbarButtonDropdownContainer }, sandpackConfig.presets.map((preset) => /* @__PURE__ */ React__default.createElement(SelectItem, { key: preset.name, value: preset.meta }, preset.label)))));
+};
+const FrontmatterButton = () => {
+  const insertFrontmatter = usePublisher("insertFrontmatter");
+  return /* @__PURE__ */ React__default.createElement(ToolbarButton, { title: "Insert frontmatter editor", onClick: insertFrontmatter.bind(null, true) }, /* @__PURE__ */ React__default.createElement(FrontmatterIcon, null));
+};
+const ViewModeSwitch = () => {
+  const [viewMode] = useEmitterValues("viewMode", "activeEditorType");
+  const setViewMode = usePublisher("viewMode");
+  return /* @__PURE__ */ React__default.createElement(
+    ToggleSingleGroup,
+    {
+      "aria-label": "View Mode",
+      onValueChange: (v) => {
+        if (v !== "") {
+          setViewMode(v);
+        }
+      },
+      value: viewMode,
+      className: styles.toolbarModeSwitch
+    },
+    /* @__PURE__ */ React__default.createElement(ToggleItem, { value: "editor", "aria-label": "Rich text", title: "Rich text mode" }, /* @__PURE__ */ React__default.createElement(RichTextIcon, null)),
+    /* @__PURE__ */ React__default.createElement(ToggleItem, { value: "diff", "aria-label": "View diff", title: "Diff mode" }, /* @__PURE__ */ React__default.createElement(DifferenceIcon, null)),
+    /* @__PURE__ */ React__default.createElement(ToggleItem, { value: "markdown", "aria-label": "View Markdown", title: "Markdown source mode" }, /* @__PURE__ */ React__default.createElement(MarkdownIcon, null))
+  );
+};
+const ToolbarComponents = {
+  BlockTypeSelect,
+  BoldItalicUnderlineButtons,
+  CodeBlockButton,
+  FrontmatterButton,
+  GroupGroup,
+  HorizontalRuleIcon,
+  LinkButton,
+  ListButtons,
+  SandpackButton,
+  TableButton,
+  ToggleItem,
+  ToggleSingleGroup,
+  ToggleSingleGroupWithItem,
+  ToolbarButton,
+  ToolbarSeparator,
+  ImageButton
+};
+const ToolbarPlugin = () => {
+  const [activeEditorType, viewMode] = useEmitterValues("activeEditorType", "viewMode");
+  return /* @__PURE__ */ React__default.createElement(RadixToolbar.Root, { className: styles.toolbarRoot, "aria-label": "Formatting options" }, viewMode === "editor" && (activeEditorType.type === "lexical" ? /* @__PURE__ */ React__default.createElement(RichTextButtonSet, null) : activeEditorType.type === "codeblock" ? /* @__PURE__ */ React__default.createElement(CodeBlockButtonSet, null) : /* @__PURE__ */ React__default.createElement(SandpackButtonSet, null)), /* @__PURE__ */ React__default.createElement(ToolbarSeparator, null), /* @__PURE__ */ React__default.createElement(ViewModeSwitch, null));
+};
+const CodeBlockButtonSet = () => {
+  const [activeEditor, activeEditorType] = useEmitterValues("activeEditor", "activeEditorType");
+  return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement(CodeBlockLanguageSelect, null), /* @__PURE__ */ React__default.createElement(
+    ToolbarButton,
+    {
+      title: "Remove code block",
+      onClick: () => {
+        activeEditor.update(() => {
+          const node = $getNodeByKey(activeEditorType.nodeKey);
+          node.selectNext();
+          node.remove();
+        });
+      }
+    },
+    /* @__PURE__ */ React__default.createElement(DeleteIcon, null)
+  ));
+};
+const SandpackButtonSet = () => {
+  const [activeEditor, activeEditorType] = useEmitterValues("activeEditor", "activeEditorType");
+  return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, /* @__PURE__ */ React__default.createElement(
+    ToolbarButton,
+    {
+      title: "Remove live code block",
+      onClick: () => {
+        activeEditor.update(() => {
+          const node = $getNodeByKey(activeEditorType.nodeKey);
+          node.selectNext();
+          node.remove();
+        });
+      }
+    },
+    /* @__PURE__ */ React__default.createElement(DeleteIcon, null)
+  ));
+};
+const RichTextButtonSet = () => {
+  const [toolbarComponents] = useEmitterValues("toolbarComponents");
+  return /* @__PURE__ */ React__default.createElement(React__default.Fragment, null, toolbarComponents.map((Component, index2) => /* @__PURE__ */ React__default.createElement(Component, { key: index2 })));
+};
+const LazyFrontmatterEditor = React__default.lazy(
+  () => import("./FrontmatterEditor-a8263f5d.js").then((module) => ({ default: module.FrontmatterEditor }))
+);
+const LazyJsxEditor = React__default.lazy(() => import("./JsxEditor-4511b188.js").then((module) => ({ default: module.JsxEditor })));
+const LazySandpackEditor = React__default.lazy(
+  () => import("./SandpackEditor-0a3bfaf0.js").then((module) => ({ default: module.SandpackEditor }))
+);
+const LazyCodeBlockEditor = React__default.lazy(
+  () => import("./CodeBlockEditor-85a8b6b0.js").then((module) => ({ default: module.CodeBlockEditor }))
+);
+const LazyTableEditor = React__default.lazy(() => import("./TableEditor-0aedb943.js").then((module) => ({ default: module.TableEditor })));
+const defaultNodeDecorators = {
+  FrontmatterEditor: LazyFrontmatterEditor,
+  JsxEditor: LazyJsxEditor,
+  SandpackEditor: LazySandpackEditor,
+  CodeBlockEditor: LazyCodeBlockEditor,
+  TableEditor: LazyTableEditor
+};
+const defaultToolbarComponents = [
+  BoldItalicUnderlineButtons,
+  ToolbarSeparator,
+  CodeFormattingButton,
+  ToolbarSeparator,
+  ListButtons,
+  ToolbarSeparator,
+  BlockTypeSelect,
+  ToolbarSeparator,
+  LinkButton,
+  ImageButton,
+  TableButton,
+  HorizontalRuleButton,
+  FrontmatterButton,
+  ToolbarSeparator,
+  CodeBlockButton,
+  SandpackButton
+];
+const defaultSandpackConfig = {
+  defaultPreset: "react",
+  presets: [
+    {
+      name: "react",
+      meta: "live react",
+      label: "React",
+      sandpackTemplate: "react",
+      sandpackTheme: "light",
+      snippetFileName: "/App.js",
+      snippetLanguage: "jsx",
+      initialSnippetContent: `
+export default function App() {
+  return (
+    <div className="App">
+      <h1>Hello CodeSandbox</h1>
+      <h2>Start editing to see some magic happen!</h2>
+    </div>
+  );
+}
+`.trim()
+    }
+  ]
+};
+const defaultMdxOptionValues = {
+  markdownParse: {
+    defaultVisitors: defaultMdastVisitors,
+    defaultSyntaxExtensions,
+    defaultMdastExtensions
+  },
+  lexicalConvert: {
+    defaultVisitors: defaultLexicalVisitors,
+    defaultExtensions,
+    defaultMarkdownOptions: defaultToMarkdownOptions
+  },
+  defaultLexicalNodes
+};
+const MDXEditor = React__default.forwardRef(
+  ({
+    markdown: markdown2,
+    headMarkdown,
+    jsxComponentDescriptors = [],
+    sandpackConfig = defaultSandpackConfig,
+    onChange,
+    viewMode,
+    linkAutocompleteSuggestions,
+    imageAutoCompleteSuggestions,
+    className,
+    contentEditableClassName,
+    toolbarComponents = defaultToolbarComponents,
+    markdownParseOptions: {
+      syntaxExtensions = Object.values(defaultSyntaxExtensions),
+      mdastExtensions = Object.values(defaultMdastExtensions),
+      visitors: importVisitors = Object.values(defaultMdastVisitors)
+    } = {},
+    lexicalConvertOptions: {
+      toMarkdownExtensions = Object.values(defaultExtensions),
+      toMarkdownOptions = defaultToMarkdownOptions,
+      visitors: exportVisitors = Object.values(defaultLexicalVisitors)
+    } = {},
+    lexicalNodes = Object.values(defaultLexicalNodes)
+  }, ref) => {
+    const editorRootElementRef = React__default.useRef(null);
+    return /* @__PURE__ */ React__default.createElement("div", { className: classNames(styles.editorRoot, styles.editorWrapper, className), ref: editorRootElementRef }, /* @__PURE__ */ React__default.createElement(
+      LexicalComposer,
+      {
+        initialConfig: {
+          editorState: () => {
+            importMarkdownToLexical({
+              root: $getRoot(),
+              visitors: importVisitors,
+              mdastExtensions,
+              markdown: markdown2,
+              syntaxExtensions
+            });
+          },
+          namespace: "MDXEditor",
+          theme: {
+            ...theme,
+            nodeDecoratorComponents: defaultNodeDecorators
+          },
+          nodes: lexicalNodes,
+          onError: (error) => console.error(error)
+        }
+      },
+      /* @__PURE__ */ React__default.createElement(
+        EditorSystemComponent,
+        {
+          markdownSource: markdown2,
+          headMarkdown: headMarkdown || markdown2,
+          jsxComponentDescriptors,
+          sandpackConfig,
+          onChange,
+          viewMode,
+          linkAutocompleteSuggestions,
+          imageAutocompleteSuggestions: imageAutoCompleteSuggestions,
+          editorRootElementRef,
+          toolbarComponents,
+          markdownParseOptions: {
+            visitors: importVisitors,
+            mdastExtensions,
+            syntaxExtensions
+          },
+          lexicalConvertOptions: {
+            visitors: exportVisitors,
+            toMarkdownOptions,
+            toMarkdownExtensions
+          },
+          lexicalNodes
+        },
+        /* @__PURE__ */ React__default.createElement(ToolbarPlugin, null),
+        /* @__PURE__ */ React__default.createElement(ViewModeToggler, null, /* @__PURE__ */ React__default.createElement(
+          RichTextPlugin,
+          {
+            contentEditable: /* @__PURE__ */ React__default.createElement(ContentEditable, { className: classNames(styles.contentEditable, contentEditableClassName) }),
+            placeholder: /* @__PURE__ */ React__default.createElement("div", null),
+            ErrorBoundary: LexicalErrorBoundary
+          }
+        )),
+        /* @__PURE__ */ React__default.createElement(LinkPlugin, null),
+        /* @__PURE__ */ React__default.createElement(HorizontalRulePlugin, null),
+        /* @__PURE__ */ React__default.createElement(ListPlugin, null),
+        /* @__PURE__ */ React__default.createElement(ListMaxIndentLevelPlugin, { maxDepth: 7 }),
+        /* @__PURE__ */ React__default.createElement(TabIndentationPlugin, null),
+        /* @__PURE__ */ React__default.createElement(LinkDialogPlugin, null),
+        /* @__PURE__ */ React__default.createElement(SharedHistoryPlugin, null),
+        /* @__PURE__ */ React__default.createElement(PatchedMarkdownShortcutPlugin, null),
+        /* @__PURE__ */ React__default.createElement(MDXMethods, { mdxRef: ref })
+      )
+    ));
+  }
+);
+const MDXMethods = ({ mdxRef }) => {
+  const [markdownSource] = useEmitterValues("markdownSource");
+  React__default.useImperativeHandle(
+    mdxRef,
+    () => {
+      return {
+        getMarkdown: () => {
+          return markdownSource;
+        }
+      };
+    },
+    [markdownSource]
+  );
+  return null;
+};
+export {
+  $createAdmonitionNode as $,
+  AdmonitionNode as A,
+  CodeBlockNode as C,
+  FrontmatterNode as F,
+  ImageNode as I,
+  JsxNode as J,
+  MDXEditor as M,
+  SharedHistoryPlugin as S,
+  ToolbarComponents as T,
+  usePublisher as a,
+  $isAdmonitionNode as b,
+  $createCodeBlockNode as c,
+  $isCodeBlockNode as d,
+  exportLexicalTreeToMdast as e,
+  $createFrontmatterNode as f,
+  $isFrontmatterNode as g,
+  $createImageNode as h,
+  importMdastTreeToLexical as i,
+  $isImageNode as j,
+  $createJsxNode as k,
+  $isJsxNode as l,
+  SandpackNode as m,
+  $createSandpackNode as n,
+  $isSandpackNode as o,
+  TableNode as p,
+  $isTableNode as q,
+  $createTableNode as r,
+  styles as s,
+  theme as t,
+  useEmitterValues as u,
+  defaultMdxOptionValues as v
+};