@mdxeditor/editor 0.0.1 → 0.0.5-development

package/dist/plugins/codemirror/index.js

@@ -0,0 +1,62 @@
+import { coreSystem } from "../core/index.js";
+import { codeBlockSystem } from "../codeblock/index.js";
+import { CodeMirrorEditor } from "./CodeMirrorEditor.js";
+import { system } from "../../gurx/realmFactory.js";
+import { realmPlugin } from "../../gurx/react.js";
+const defaultCodeBlockLanguages = {
+  js: "JavaScript",
+  ts: "TypeScript",
+  tsx: "TypeScript (React)",
+  jsx: "JavaScript (React)",
+  css: "CSS"
+};
+const codeMirrorSystem = system(
+  (r, [, { insertCodeBlock }]) => {
+    const codeBlockLanguages = r.node(defaultCodeBlockLanguages);
+    const insertCodeMirror = r.node();
+    r.link(
+      r.pipe(
+        insertCodeMirror,
+        r.o.map(({ language, code }) => {
+          return {
+            code,
+            language,
+            meta: ""
+          };
+        })
+      ),
+      insertCodeBlock
+    );
+    return {
+      codeBlockLanguages,
+      insertCodeMirror
+    };
+  },
+  [coreSystem, codeBlockSystem]
+);
+const [
+  /** @internal */
+  codeMirrorPlugin,
+  /** @internal */
+  codeMirrorHooks
+] = realmPlugin({
+  id: "codemirror",
+  systemSpec: codeMirrorSystem,
+  applyParamsToSystem(r, params) {
+    r.pubKey("codeBlockLanguages", params.codeBlockLanguages);
+  },
+  init(r, { codeBlockLanguages }) {
+    r.pubKey("appendCodeBlockEditorDescriptor", {
+      match(language, meta) {
+        return codeBlockLanguages.hasOwnProperty(language) && meta === "";
+      },
+      priority: 1,
+      Editor: CodeMirrorEditor
+    });
+  }
+});
+export {
+  codeMirrorHooks,
+  codeMirrorPlugin,
+  codeMirrorSystem
+};

package/dist/plugins/core/GenericHTMLNode.d.ts

@@ -0,0 +1,38 @@
+import { DOMConversionMap, DOMExportOutput, ElementNode, LexicalEditor, LexicalNode, NodeKey, SerializedElementNode, Spread } from 'lexical';
+import { MdxJsxAttribute } from 'mdast-util-mdx-jsx';
+import { MDX_NODE_TYPES, htmlTags } from './MdastHTMLNode';
+export type KnownHTMLTagType = (typeof htmlTags)[number];
+declare const TYPE_NAME: "generic-html";
+export type SerializedGenericHTMLNode = Spread<{
+    tag: KnownHTMLTagType;
+    type: typeof TYPE_NAME;
+    mdxType: MdxNodeType;
+    attributes: MdxJsxAttribute[];
+    version: 1;
+}, SerializedElementNode>;
+type MdxNodeType = (typeof MDX_NODE_TYPES)[number];
+export declare class GenericHTMLNode extends ElementNode {
+    /** @internal */
+    __tag: KnownHTMLTagType;
+    __nodeType: MdxNodeType;
+    __attributes: MdxJsxAttribute[];
+    static getType(): string;
+    static clone(node: GenericHTMLNode): GenericHTMLNode;
+    constructor(tag: KnownHTMLTagType, type: MdxNodeType, attributes: MdxJsxAttribute[], key?: NodeKey);
+    getTag(): KnownHTMLTagType;
+    getNodeType(): MdxNodeType;
+    getAttributes(): MdxJsxAttribute[];
+    updateAttributes(attributes: MdxJsxAttribute[]): void;
+    getStyle(): string;
+    createDOM(): HTMLElement;
+    updateDOM(): boolean;
+    static importDOM(): DOMConversionMap | null;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    static importJSON(serializedNode: SerializedGenericHTMLNode): GenericHTMLNode;
+    exportJSON(): SerializedGenericHTMLNode;
+    extractWithChild(): boolean;
+    isInline(): boolean;
+}
+export declare function $createGenericHTMLNode(tag: KnownHTMLTagType, type: MdxNodeType, attributes: MdxJsxAttribute[]): GenericHTMLNode;
+export declare function $isGenericHTMLNode(node: LexicalNode | null | undefined): node is GenericHTMLNode;
+export {};

package/dist/plugins/core/GenericHTMLNode.js

@@ -0,0 +1,117 @@
+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 { ElementNode, $applyNodeReplacement } from "lexical";
+const TYPE_NAME = "generic-html";
+class GenericHTMLNode extends ElementNode {
+  constructor(tag, type, attributes, key) {
+    super(key);
+    /** @internal */
+    __publicField(this, "__tag");
+    __publicField(this, "__nodeType");
+    __publicField(this, "__attributes");
+    this.__tag = tag;
+    this.__nodeType = type;
+    this.__attributes = attributes;
+  }
+  static getType() {
+    return TYPE_NAME;
+  }
+  static clone(node) {
+    return new GenericHTMLNode(node.__tag, node.__nodeType, node.__attributes, node.__key);
+  }
+  getTag() {
+    return this.__tag;
+  }
+  getNodeType() {
+    return this.__nodeType;
+  }
+  getAttributes() {
+    return this.__attributes;
+  }
+  updateAttributes(attributes) {
+    const self = this.getWritable();
+    self.__attributes = attributes;
+  }
+  getStyle() {
+    var _a;
+    return (_a = this.__attributes.find((attribute) => attribute.name === "style")) == null ? void 0 : _a.value;
+  }
+  // View
+  createDOM() {
+    const tag = this.__tag;
+    const element = document.createElement(tag);
+    this.__attributes.forEach((attribute) => {
+      element.setAttribute(attribute.name, attribute.value);
+    });
+    return element;
+  }
+  updateDOM() {
+    return false;
+  }
+  static importDOM() {
+    return {};
+  }
+  exportDOM(editor) {
+    const { element } = super.exportDOM(editor);
+    return {
+      element
+    };
+  }
+  static importJSON(serializedNode) {
+    const node = $createGenericHTMLNode(serializedNode.tag, serializedNode.mdxType, serializedNode.attributes);
+    node.setFormat(serializedNode.format);
+    node.setIndent(serializedNode.indent);
+    node.setDirection(serializedNode.direction);
+    return node;
+  }
+  exportJSON() {
+    return {
+      ...super.exportJSON(),
+      tag: this.getTag(),
+      attributes: this.__attributes,
+      mdxType: this.__nodeType,
+      type: TYPE_NAME,
+      version: 1
+    };
+  }
+  /*
+    // Mutation
+    insertNewAfter(selection?: RangeSelection, restoreSelection = true): ParagraphNode | GenericHTMLNode {
+      const anchorOffet = selection ? selection.anchor.offset : 0
+      const newElement =
+        anchorOffet > 0 && anchorOffet < this.getTextContentSize() ? $createHeadingNode(this.getTag()) : $createParagraphNode()
+      const direction = this.getDirection()
+      newElement.setDirection(direction)
+      this.insertAfter(newElement, restoreSelection)
+      return newElement
+    }
+  
+    collapseAtStart(): true {
+      const newElement = !this.isEmpty() ? $createHeadingNode(this.getTag()) : $createParagraphNode()
+      const children = this.getChildren()
+      children.forEach((child) => newElement.append(child))
+      this.replace(newElement)
+      return true
+    }*/
+  extractWithChild() {
+    return true;
+  }
+  isInline() {
+    return this.__nodeType === "mdxJsxTextElement";
+  }
+}
+function $createGenericHTMLNode(tag, type, attributes) {
+  return $applyNodeReplacement(new GenericHTMLNode(tag, type, attributes));
+}
+function $isGenericHTMLNode(node) {
+  return node instanceof GenericHTMLNode;
+}
+export {
+  $createGenericHTMLNode,
+  $isGenericHTMLNode,
+  GenericHTMLNode
+};

package/dist/plugins/core/Icon.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+export type IconKey = 'add_column' | 'add_photo' | 'add_row' | 'arrow_drop_down' | 'check' | 'check_small' | 'close' | 'code' | 'content_copy' | 'delete_big' | 'delete_small' | 'sandpack' | 'difference' | 'edit' | 'admonition' | 'extension' | 'format_align_center' | 'format_align_left' | 'format_align_right' | 'format_bold' | 'format_italic' | 'format_list_bulleted' | 'format_list_checked' | 'format_list_numbered' | 'format_underlined' | 'frame_source' | 'frontmatter' | 'horizontal_rule' | 'insert_col_left' | 'insert_col_right' | 'insert_row_above' | 'insert_row_below' | 'link' | 'link_off' | 'markdown' | 'more_horiz' | 'more_vert' | 'open_in_new' | 'redo' | 'rich_text' | 'settings' | 'table' | 'undo';
+declare const Icon: React.FC<{
+    name: IconKey;
+}>;
+export default Icon;

package/dist/plugins/core/Icon.js

@@ -0,0 +1,96 @@
+import React__default from "react";
+import SvgAddColumn from "../../icons/add_column.svg.js";
+import SvgAddPhoto from "../../icons/add_photo.svg.js";
+import SvgAddRow from "../../icons/add_row.svg.js";
+import SvgArrowDropDown from "../../icons/arrow_drop_down.svg.js";
+import SvgCheck from "../../icons/check.svg.js";
+import SvgCheckSmall from "../../icons/check_small.svg.js";
+import SvgClose from "../../icons/close.svg.js";
+import SvgCode from "../../icons/code.svg.js";
+import SvgContentCopy from "../../icons/content_copy.svg.js";
+import SvgDeleteBig from "../../icons/delete_big.svg.js";
+import SvgDeleteSmall from "../../icons/delete_small.svg.js";
+import SvgSandpack from "../../icons/sandpack.svg.js";
+import SvgDifference from "../../icons/difference.svg.js";
+import SvgEdit from "../../icons/edit.svg.js";
+import SvgAdmonition from "../../icons/admonition.svg.js";
+import SvgExtension from "../../icons/extension.svg.js";
+import SvgFormatAlignCenter from "../../icons/format_align_center.svg.js";
+import SvgFormatAlignLeft from "../../icons/format_align_left.svg.js";
+import SvgFormatAlignRight from "../../icons/format_align_right.svg.js";
+import SvgFormatBold from "../../icons/format_bold.svg.js";
+import SvgFormatItalic from "../../icons/format_italic.svg.js";
+import SvgFormatListBulleted from "../../icons/format_list_bulleted.svg.js";
+import SvgFormatListChecked from "../../icons/format_list_checked.svg.js";
+import SvgFormatListNumbered from "../../icons/format_list_numbered.svg.js";
+import SvgFormatUnderlined from "../../icons/format_underlined.svg.js";
+import SvgFrameSource from "../../icons/frame_source.svg.js";
+import SvgFrontmatter from "../../icons/frontmatter.svg.js";
+import SvgHorizontalRule from "../../icons/horizontal_rule.svg.js";
+import SvgInsertColLeft from "../../icons/insert_col_left.svg.js";
+import SvgInsertColRight from "../../icons/insert_col_right.svg.js";
+import SvgInsertRowAbove from "../../icons/insert_row_above.svg.js";
+import SvgInsertRowBelow from "../../icons/insert_row_below.svg.js";
+import SvgLink from "../../icons/link.svg.js";
+import SvgLinkOff from "../../icons/link_off.svg.js";
+import SvgMarkdown from "../../icons/markdown.svg.js";
+import SvgMoreHoriz from "../../icons/more_horiz.svg.js";
+import SvgMoreVert from "../../icons/more_vert.svg.js";
+import SvgOpenInNew from "../../icons/open_in_new.svg.js";
+import SvgRedo from "../../icons/redo.svg.js";
+import SvgRichText from "../../icons/rich_text.svg.js";
+import SvgSettings from "../../icons/settings.svg.js";
+import SvgTable from "../../icons/table.svg.js";
+import SvgUndo from "../../icons/undo.svg.js";
+const IconMap = {
+  add_column: SvgAddColumn,
+  add_photo: SvgAddPhoto,
+  add_row: SvgAddRow,
+  arrow_drop_down: SvgArrowDropDown,
+  check: SvgCheck,
+  check_small: SvgCheckSmall,
+  close: SvgClose,
+  code: SvgCode,
+  content_copy: SvgContentCopy,
+  delete_big: SvgDeleteBig,
+  delete_small: SvgDeleteSmall,
+  sandpack: SvgSandpack,
+  difference: SvgDifference,
+  edit: SvgEdit,
+  admonition: SvgAdmonition,
+  extension: SvgExtension,
+  format_align_center: SvgFormatAlignCenter,
+  format_align_left: SvgFormatAlignLeft,
+  format_align_right: SvgFormatAlignRight,
+  format_bold: SvgFormatBold,
+  format_italic: SvgFormatItalic,
+  format_list_bulleted: SvgFormatListBulleted,
+  format_list_checked: SvgFormatListChecked,
+  format_list_numbered: SvgFormatListNumbered,
+  format_underlined: SvgFormatUnderlined,
+  frame_source: SvgFrameSource,
+  frontmatter: SvgFrontmatter,
+  horizontal_rule: SvgHorizontalRule,
+  insert_col_left: SvgInsertColLeft,
+  insert_col_right: SvgInsertColRight,
+  insert_row_above: SvgInsertRowAbove,
+  insert_row_below: SvgInsertRowBelow,
+  link: SvgLink,
+  link_off: SvgLinkOff,
+  markdown: SvgMarkdown,
+  more_horiz: SvgMoreHoriz,
+  more_vert: SvgMoreVert,
+  open_in_new: SvgOpenInNew,
+  redo: SvgRedo,
+  rich_text: SvgRichText,
+  settings: SvgSettings,
+  table: SvgTable,
+  undo: SvgUndo
+};
+const Icon = ({ name }) => {
+  const IconComponent = IconMap[name];
+  return /* @__PURE__ */ React__default.createElement(IconComponent, null);
+};
+export {
+  Icon as default
+};

package/dist/plugins/core/LexicalGenericHTMLNodeVisitor.d.ts

@@ -0,0 +1,4 @@
+import { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx';
+import { GenericHTMLNode } from './GenericHTMLNode';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+export declare const LexicalGenericHTMLVisitor: LexicalExportVisitor<GenericHTMLNode, MdxJsxFlowElement | MdxJsxTextElement>;

package/dist/plugins/core/LexicalGenericHTMLNodeVisitor.js

@@ -0,0 +1,15 @@
+import { $isGenericHTMLNode } from "./GenericHTMLNode.js";
+const LexicalGenericHTMLVisitor = {
+  testLexicalNode: $isGenericHTMLNode,
+  visitLexicalNode({ actions, lexicalNode }) {
+    actions.addAndStepInto("mdxJsxTextElement", {
+      name: lexicalNode.getTag(),
+      type: lexicalNode.getNodeType(),
+      attributes: lexicalNode.getAttributes()
+    });
+  },
+  priority: -100
+};
+export {
+  LexicalGenericHTMLVisitor
+};

package/dist/plugins/core/LexicalLinebreakVisitor.d.ts

@@ -0,0 +1,4 @@
+import { LineBreakNode } from 'lexical';
+import * as Mdast from 'mdast';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+export declare const LexicalLinebreakVisitor: LexicalExportVisitor<LineBreakNode, Mdast.Text>;

package/dist/plugins/core/LexicalLinebreakVisitor.js

@@ -0,0 +1,10 @@
+import { $isLineBreakNode } from "lexical";
+const LexicalLinebreakVisitor = {
+  testLexicalNode: $isLineBreakNode,
+  visitLexicalNode: ({ mdastParent, actions }) => {
+    actions.appendToParent(mdastParent, { type: "text", value: "\n" });
+  }
+};
+export {
+  LexicalLinebreakVisitor
+};

package/dist/plugins/core/LexicalParagraphVisitor.d.ts

@@ -0,0 +1,4 @@
+import { ParagraphNode } from 'lexical';
+import * as Mdast from 'mdast';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+export declare const LexicalParagraphVisitor: LexicalExportVisitor<ParagraphNode, Mdast.Paragraph>;

package/dist/plugins/core/LexicalParagraphVisitor.js

@@ -0,0 +1,10 @@
+import { $isParagraphNode } from "lexical";
+const LexicalParagraphVisitor = {
+  testLexicalNode: $isParagraphNode,
+  visitLexicalNode: ({ actions }) => {
+    actions.addAndStepInto("paragraph");
+  }
+};
+export {
+  LexicalParagraphVisitor
+};

package/dist/plugins/core/LexicalRootVisitor.d.ts

@@ -0,0 +1,4 @@
+import { RootNode as LexicalRootNode } from 'lexical';
+import * as Mdast from 'mdast';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+export declare const LexicalRootVisitor: LexicalExportVisitor<LexicalRootNode, Mdast.Content>;

package/dist/plugins/core/LexicalRootVisitor.js

@@ -0,0 +1,10 @@
+import { $isRootNode } from "lexical";
+const LexicalRootVisitor = {
+  testLexicalNode: $isRootNode,
+  visitLexicalNode: ({ actions }) => {
+    actions.addAndStepInto("root");
+  }
+};
+export {
+  LexicalRootVisitor
+};

package/dist/plugins/core/LexicalTextVisitor.d.ts

@@ -0,0 +1,5 @@
+import { TextNode } from 'lexical';
+import * as Mdast from 'mdast';
+import { LexicalExportVisitor } from '../../exportMarkdownFromLexical';
+export declare function isMdastText(mdastNode: Mdast.Content): mdastNode is Mdast.Text;
+export declare const LexicalTextVisitor: LexicalExportVisitor<TextNode, Mdast.Text>;

package/dist/plugins/core/LexicalTextVisitor.js

@@ -0,0 +1,102 @@
+import { $isTextNode } from "lexical";
+import { IS_CODE, IS_ITALIC, IS_BOLD, IS_UNDERLINE } from "../../FormatConstants.js";
+function isMdastText(mdastNode) {
+  return mdastNode.type === "text";
+}
+const JOINABLE_TAGS = ["u", "span"];
+const LexicalTextVisitor = {
+  shouldJoin: (prevNode, currentNode) => {
+    if (["text", "emphasis", "strong"].includes(prevNode.type)) {
+      return prevNode.type === currentNode.type;
+    }
+    if (prevNode.type === "mdxJsxTextElement" && currentNode.type === "mdxJsxTextElement" && JOINABLE_TAGS.includes(currentNode.name)) {
+      const currentMdxNode = currentNode;
+      return prevNode.name === currentMdxNode.name && JSON.stringify(prevNode.attributes) === JSON.stringify(currentMdxNode.attributes);
+    }
+    return false;
+  },
+  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;
+    const style = lexicalNode.getStyle();
+    if (format & IS_CODE) {
+      actions.addAndStepInto("inlineCode", {
+        value: textContent
+      });
+      return;
+    }
+    let localParentNode = mdastParent;
+    if (style) {
+      localParentNode = actions.appendToParent(localParentNode, {
+        type: "mdxJsxTextElement",
+        name: "span",
+        children: [],
+        attributes: [{ type: "mdxJsxAttribute", name: "style", value: style }]
+      });
+    }
+    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
+    });
+  }
+};
+export {
+  LexicalTextVisitor,
+  isMdastText
+};

package/dist/plugins/core/MdastBreakVisitor.d.ts

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

package/dist/plugins/core/MdastBreakVisitor.js

@@ -0,0 +1,10 @@
+import { $createLineBreakNode } from "lexical";
+const MdastBreakVisitor = {
+  testNode: "break",
+  visitNode: function({ lexicalParent }) {
+    lexicalParent.append($createLineBreakNode());
+  }
+};
+export {
+  MdastBreakVisitor
+};

package/dist/plugins/core/MdastFormattingVisitor.d.ts

@@ -0,0 +1,4 @@
+import * as Mdast from 'mdast';
+import { MdxJsxTextElement } from 'mdast-util-mdx';
+import { MdastImportVisitor } from '../../importMarkdownToLexical';
+export declare const MdastFormattingVisitor: MdastImportVisitor<Mdast.Emphasis | Mdast.Strong | MdxJsxTextElement>;

package/dist/plugins/core/MdastFormattingVisitor.js

@@ -0,0 +1,36 @@
+import { IS_UNDERLINE, IS_ITALIC, IS_BOLD } from "../../FormatConstants.js";
+function isOpeningUnderlineNode(node) {
+  return node.type === "html" && node.value === "<u>";
+}
+function isClosingUnderlineNode(node) {
+  return node.type === "html" && node.value === "</u>";
+}
+function isJsxUnderlineNode(node) {
+  return node.type === "mdxJsxTextElement" && node.name === "u";
+}
+const MdastFormattingVisitor = {
+  testNode(mdastNode) {
+    return mdastNode.type === "emphasis" || mdastNode.type === "strong" || isJsxUnderlineNode(mdastNode) || isOpeningUnderlineNode(mdastNode) || isClosingUnderlineNode(mdastNode);
+  },
+  visitNode({ mdastNode, lexicalParent, actions, mdastParent }) {
+    if (isOpeningUnderlineNode(mdastNode)) {
+      actions.addFormatting(IS_UNDERLINE, mdastParent);
+      return;
+    }
+    if (isClosingUnderlineNode(mdastNode)) {
+      actions.removeFormatting(IS_UNDERLINE, mdastParent);
+      return;
+    }
+    if (mdastNode.type === "emphasis") {
+      actions.addFormatting(IS_ITALIC);
+    } else if (mdastNode.type === "strong") {
+      actions.addFormatting(IS_BOLD);
+    } else if (isJsxUnderlineNode(mdastNode)) {
+      actions.addFormatting(IS_UNDERLINE);
+    }
+    actions.visitChildren(mdastNode, lexicalParent);
+  }
+};
+export {
+  MdastFormattingVisitor
+};

package/dist/plugins/core/MdastHTMLNode.d.ts

@@ -0,0 +1,13 @@
+import * as Mdast from 'mdast';
+import { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx';
+interface MdastBlockHTMLNode extends MdxJsxFlowElement {
+    name: (typeof htmlTags)[number];
+}
+interface MdastInlineHTMLNode extends MdxJsxTextElement {
+    name: (typeof htmlTags)[number];
+}
+export type MdastHTMLNode = MdastBlockHTMLNode | MdastInlineHTMLNode;
+export declare const MDX_NODE_TYPES: readonly ["mdxJsxTextElement", "mdxJsxFlowElement"];
+export declare function isMdastHTMLNode(node: Mdast.Parent | Mdast.Content | Mdast.Root): node is MdastHTMLNode;
+export declare const htmlTags: readonly ["a", "abbr", "address", "area", "article", "aside", "audio", "b", "base", "bdi", "bdo", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "footer", "form", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "iframe", "input", "ins", "kbd", "label", "legend", "li", "link", "main", "map", "mark", "meta", "meter", "nav", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "script", "section", "select", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track", "u", "ul", "var", "video", "wbr"];
+export {};