@lobehub/editor 4.15.1 → 4.15.2

package/es/plugins/litexml/utils/index.js

@@ -0,0 +1,59 @@
+import { $isElementNode, resetRandomKey } from "lexical";
+//#region src/plugins/litexml/utils/index.ts
+const getNumericId = (id) => {
+	if (typeof id !== "number" && typeof id !== "string") return null;
+	const numericId = Number(id);
+	return Number.isInteger(numericId) && numericId >= 0 ? numericId : null;
+};
+function $parseSerializedNodeImpl(serializedNode, editor, keepId = false, state = null) {
+	const type = serializedNode.type;
+	const registeredNode = editor._nodes.get(type);
+	if (registeredNode === void 0) throw new Error(`parseEditorState: type "${type}" not found`);
+	const nodeClass = registeredNode.klass;
+	if (serializedNode.type !== nodeClass.getType()) throw new Error(`LexicalNode: Node ${nodeClass.name} does not implement .importJSON().`);
+	if (keepId) {
+		const id = getNumericId(serializedNode.id);
+		if (id !== null) resetRandomKey(id);
+	}
+	const node = nodeClass.importJSON(serializedNode);
+	const children = serializedNode.children;
+	if ($isElementNode(node) && Array.isArray(children)) {
+		const childNodes = [];
+		for (const serializedJSONChildNode of children) {
+			const childNode = $parseSerializedNodeImpl(serializedJSONChildNode, editor, keepId, state);
+			childNodes.push(childNode);
+		}
+		node.append(...childNodes);
+	}
+	return node;
+}
+function exportNodeToJSON(node) {
+	const serializedNode = node.exportJSON();
+	const nodeClass = node.constructor;
+	if (serializedNode.type !== nodeClass.getType()) throw new Error(`LexicalNode: Node ${nodeClass.name} does not match the serialized type. Check if .exportJSON() is implemented and it is returning the correct type.`);
+	if ($isElementNode(node)) {
+		const serializedChildren = serializedNode.children;
+		if (!Array.isArray(serializedChildren)) throw new Error(`LexicalNode: Node ${nodeClass.name} is an element but .exportJSON() does not have a children array.`);
+		const children = node.getChildren();
+		for (const child of children) {
+			const serializedChildNode = exportNodeToJSON(child);
+			serializedChildren.push(serializedChildNode);
+		}
+	}
+	return serializedNode;
+}
+function $cloneNode(node, editor) {
+	return $parseSerializedNodeImpl(exportNodeToJSON(node), editor);
+}
+const maxId = 1679616;
+const startId = 1e6;
+const step = 7211;
+const modInverse = 1394051;
+function idToChar(id) {
+	return ((Number(id) * step + startId) % maxId).toString(36).padStart(4, "0");
+}
+function charToId(char) {
+	return String((parseInt(char, 36) - startId + maxId) * modInverse % maxId);
+}
+//#endregion
+export { $cloneNode, $parseSerializedNodeImpl, charToId, idToChar };

package/es/plugins/markdown/command/index.d.ts

@@ -0,0 +1,14 @@
+import { HistoryStateEntry } from "@lexical/history";
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/markdown/command/index.d.ts
+declare const INSERT_MARKDOWN_COMMAND: _$lexical.LexicalCommand<{
+  historyState: HistoryStateEntry | null;
+  markdown: string;
+}>;
+declare const GET_MARKDOWN_SELECTION_COMMAND: _$lexical.LexicalCommand<{
+  onResult: (startLine: number, endLine: number) => void;
+}>;
+//#endregion
+export { GET_MARKDOWN_SELECTION_COMMAND, INSERT_MARKDOWN_COMMAND };

package/es/plugins/markdown/command/index.js

@@ -0,0 +1,74 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { parseMarkdownToLexical } from "../data-source/markdown/parse.js";
+import { $generateNodesFromSerializedNodes, $insertGeneratedNodes } from "../utils/index.js";
+import { $getSelection, $isRangeSelection, COMMAND_PRIORITY_HIGH, HISTORIC_TAG, HISTORY_PUSH_TAG, createCommand } from "lexical";
+import { mergeRegister } from "@lexical/utils";
+//#region src/plugins/markdown/command/index.ts
+init_debug();
+const logger = createDebugLogger("plugin", "markdown");
+const INSERT_MARKDOWN_COMMAND = createCommand("INSERT_MARKDOWN_COMMAND");
+const GET_MARKDOWN_SELECTION_COMMAND = createCommand("GET_MARKDOWN_SELECTION_COMMAND");
+function restoreToEntry(editor, entry) {
+	if (!entry) return;
+	editor.setEditorState(entry.editorState, { tag: HISTORIC_TAG });
+}
+const SPICAL_TEXT = "￰";
+const getLineNumber = (content, charIndex) => {
+	return content.slice(0, Math.max(0, charIndex)).split("\n").length;
+};
+function registerMarkdownCommand(editor, kernel, service) {
+	return mergeRegister(editor.registerCommand(INSERT_MARKDOWN_COMMAND, (payload) => {
+		const { markdown } = payload;
+		logger.debug("INSERT_MARKDOWN_COMMAND payload:", payload);
+		restoreToEntry(editor, payload.historyState);
+		setTimeout(() => {
+			editor.update(() => {
+				try {
+					const root = parseMarkdownToLexical(markdown, service.markdownReaders);
+					const selection = $getSelection();
+					const nodes = $generateNodesFromSerializedNodes(root.children);
+					logger.debug("INSERT_MARKDOWN_COMMAND nodes:", nodes);
+					$insertGeneratedNodes(editor, nodes, selection);
+					return true;
+				} catch (error) {
+					logger.error("Failed to handle markdown paste:", error);
+				}
+			}, { tag: HISTORY_PUSH_TAG });
+		}, 0);
+		return false;
+	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(GET_MARKDOWN_SELECTION_COMMAND, (payload) => {
+		const newEditor = kernel.cloneNodeEditor();
+		const s = kernel.getSelection();
+		if (s) {
+			newEditor.setSelection(s);
+			newEditor.getLexicalEditor()?.update(() => {
+				const sel = $getSelection();
+				if (!sel) return;
+				if ($isRangeSelection(sel)) {
+					const { key: anchorKey, offset: anchorOffset, type: anchorType } = sel.anchor;
+					const { key: focusKey, offset: focusOffset, type: focusType } = sel.focus;
+					const newRang = sel.clone();
+					newRang.anchor.set(anchorKey, anchorOffset, anchorType);
+					newRang.focus.set(anchorKey, anchorOffset, anchorType);
+					newRang.insertText(SPICAL_TEXT);
+					newRang.focus.set(focusKey, focusOffset, focusType);
+					newRang.anchor.set(focusKey, focusOffset, focusType);
+					newRang.insertText(SPICAL_TEXT);
+				}
+			}, { onUpdate: () => {
+				const markdownContent = newEditor.getDocument("markdown");
+				const startIndex = markdownContent.indexOf(SPICAL_TEXT);
+				const endIndex = markdownContent.lastIndexOf(SPICAL_TEXT);
+				const startLine = getLineNumber(markdownContent, startIndex);
+				const endLine = getLineNumber(markdownContent, endIndex);
+				payload.onResult(startLine, endLine);
+				logger.debug("GET_MARKDOWN_SELECTION_COMMAND markdownContent:", markdownContent);
+				logger.debug("GET_MARKDOWN_SELECTION_COMMAND startLine:", startLine, "endLine:", endLine);
+				return markdownContent;
+			} });
+		}
+		return false;
+	}, COMMAND_PRIORITY_HIGH));
+}
+//#endregion
+export { GET_MARKDOWN_SELECTION_COMMAND, INSERT_MARKDOWN_COMMAND, registerMarkdownCommand };

package/es/plugins/markdown/data-source/markdown/parse.d.ts

@@ -0,0 +1,14 @@
+import { IElementNode } from "../../../../editor-kernel/inode/i-element-node.js";
+import { INode } from "../../../../editor-kernel/inode/i-node.js";
+import { ITextNode } from "../../../../editor-kernel/inode/text-node.js";
+import { PhrasingContent, Root, RootContent } from "../../../../node_modules/.pnpm/@types_mdast@4.0.4/node_modules/@types/mdast/index.js";
+
+//#region src/plugins/markdown/data-source/markdown/parse.d.ts
+type MarkdownReadNode = INode | ITextNode | IElementNode;
+type MarkdownNode = Root | RootContent | PhrasingContent;
+type MarkdownReaderFunc<K> = (node: Extract<MarkdownNode, {
+  type: K;
+}>, children: MarkdownReadNode[], index: number) => MarkdownReadNode | MarkdownReadNode[] | false;
+type TransformerRecord = { [K in MarkdownNode['type']]?: MarkdownReaderFunc<K> | Array<MarkdownReaderFunc<K>> };
+//#endregion
+export { MarkdownReaderFunc, TransformerRecord };

package/es/plugins/markdown/data-source/markdown/parse.js

@@ -0,0 +1,195 @@
+import { INodeHelper, init_helper } from "../../../../editor-kernel/inode/helper.js";
+import { logger } from "../../utils/logger.js";
+import { remark } from "remark";
+import remarkCjkFriendly from "remark-cjk-friendly";
+import remarkGfm from "remark-gfm";
+import remarkMath from "remark-math";
+//#region src/plugins/markdown/data-source/markdown/parse.ts
+init_helper();
+const selfClosingHtmlTags = new Set([
+	"area",
+	"base",
+	"br",
+	"col",
+	"embed",
+	"hr",
+	"img",
+	"input",
+	"link",
+	"meta",
+	"param",
+	"source",
+	"track",
+	"wbr"
+]);
+var MarkdownContext = class {
+	constructor(root, markdown) {
+		this.root = root;
+		this.markdown = markdown;
+		this.stack = [];
+	}
+	push(html) {
+		this.stack.push(html);
+	}
+	get isReadingHTML() {
+		return this.stack.length > 0;
+	}
+	get last() {
+		return this.stack.at(-1);
+	}
+	pop() {
+		return this.stack.pop();
+	}
+};
+const getNodeRawMarkdown = (node, markdown) => {
+	const start = node.position?.start.offset;
+	const end = node.position?.end.offset;
+	if (typeof start === "number" && typeof end === "number") return markdown.slice(start, end);
+	if ("value" in node && typeof node.value === "string") return node.value;
+	return "";
+};
+const createFallbackRawNode = (node, ctx, parentType) => {
+	const raw = getNodeRawMarkdown(node, ctx.markdown);
+	if (!raw) return null;
+	if (parentType === null || parentType === "root") return {
+		...INodeHelper.createParagraph(),
+		children: [INodeHelper.createTextNode(raw)]
+	};
+	return INodeHelper.createTextNode(raw);
+};
+function convertMdastToLexical(node, index, ctx, markdownReaders = {}, parentType = null) {
+	switch (node.type) {
+		case "text": return INodeHelper.createTextNode(node.value);
+		default: {
+			if (!markdownReaders[node.type]) return createFallbackRawNode(node, ctx, parentType);
+			let children = [];
+			if ("children" in node && Array.isArray(node.children)) {
+				let htmlStack = [];
+				children = node.children.reduce((ret, child, index) => {
+					if (child.type === "html") {
+						if (!markdownReaders["html"]) {
+							ret.push(INodeHelper.createTextNode(child.value));
+							return ret;
+						}
+						if (child.value.startsWith("<!--") && child.value.endsWith("-->")) return ret;
+						const tag = child.value.replaceAll(/^<\/?|>$/g, "");
+						const isEndTag = child.value.startsWith("</");
+						if (selfClosingHtmlTags.has(tag)) {
+							const reader = markdownReaders["html"];
+							if (Array.isArray(reader)) for (const element of reader) {
+								const inode = element(child, [], index);
+								if (inode) {
+									ret.push(inode);
+									return ret;
+								}
+							}
+							else if (typeof reader === "function") {
+								const inode = reader(child, [], index);
+								if (inode) {
+									ret.push(inode);
+									return ret;
+								}
+							}
+							return ret;
+						}
+						if (isEndTag) {
+							const top = ctx.pop();
+							htmlStack.pop();
+							if (top?.tag !== tag) {
+								logger.warn("HTML tag mismatch:", tag);
+								ret.push(...top?.children || []);
+								return ret;
+							}
+							const reader = markdownReaders["html"];
+							const children = top.children.flat().filter(Boolean) || [];
+							if (Array.isArray(reader)) for (const element of reader) {
+								const inode = element(top.node, children, index);
+								if (inode) {
+									ret.push(inode);
+									return ret;
+								}
+							}
+							else if (typeof reader === "function") {
+								const inode = reader(top.node, children, index);
+								if (inode) {
+									ret.push(inode);
+									return ret;
+								}
+							}
+							if (top) ret.push(...top.children);
+							return ret;
+						}
+						const htmlStackItem = {
+							children: [],
+							index,
+							isEndTag,
+							node: child,
+							tag
+						};
+						htmlStack.push(htmlStackItem);
+						ctx.push(htmlStackItem);
+						return ret;
+					}
+					if (htmlStack.length > 0) {
+						const top = ctx.last;
+						if (top) top.children.push(convertMdastToLexical(child, index, ctx, markdownReaders, node.type));
+						return ret;
+					}
+					ret.push(convertMdastToLexical(child, index, ctx, markdownReaders, node.type));
+					return ret;
+				}, []).filter(Boolean).flat();
+				while (htmlStack.length > 0) {
+					const tag = htmlStack.shift();
+					ctx.pop();
+					children.push(INodeHelper.createTextNode(tag?.node.value), ...tag.children.flat());
+					children = children.flat();
+				}
+			}
+			if (markdownReaders[node.type]) {
+				const reader = markdownReaders[node.type];
+				if (Array.isArray(reader)) for (const element of reader) {
+					const inode = element(node, children, index);
+					if (inode) return inode;
+				}
+				else if (typeof reader === "function") {
+					const inode = reader(node, children, index);
+					if (inode) return inode;
+				}
+			}
+			return children || null;
+		}
+	}
+}
+function registerDefaultReaders(markdownReaders) {
+	if (!markdownReaders["root"]) markdownReaders["root"] = (node, children) => {
+		return {
+			...INodeHelper.createRootNode(),
+			children
+		};
+	};
+	if (!markdownReaders["paragraph"]) markdownReaders["paragraph"] = (node, children) => {
+		return {
+			...INodeHelper.createParagraph(),
+			children
+		};
+	};
+	if (!markdownReaders["heading"]) markdownReaders["heading"] = (node, children) => {
+		const headingType = `h${Math.min(Math.max(node.depth, 1), 6)}`;
+		return INodeHelper.createElementNode("heading", {
+			children,
+			direction: "ltr",
+			format: "",
+			indent: 0,
+			tag: headingType
+		});
+	};
+}
+function parseMarkdownToLexical(markdown, markdownReaders = {}) {
+	const ast = remark().use(remarkCjkFriendly).use(remarkMath).use([[remarkGfm, { singleTilde: false }]]).parse(markdown);
+	logger.debug("Parsed MDAST:", ast);
+	const ctx = new MarkdownContext(ast, markdown);
+	registerDefaultReaders(markdownReaders);
+	return convertMdastToLexical(ast, 0, ctx, markdownReaders);
+}
+//#endregion
+export { parseMarkdownToLexical };

package/es/plugins/markdown/data-source/markdown-data-source.js

@@ -0,0 +1,148 @@
+import { INodeHelper, init_helper } from "../../../editor-kernel/inode/helper.js";
+import DataSource from "../../../editor-kernel/data-source.js";
+import { INodeService } from "../../inode/service/index.js";
+import { logger } from "../utils/logger.js";
+import { parseMarkdownToLexical } from "./markdown/parse.js";
+import { MarkdownWriterContext } from "./markdown-writer-context.js";
+import { $isTableSelection } from "@lexical/table";
+import { $getCharacterOffsets, $getNodeByKey, $getRoot, $getSelection, $isElementNode, $isRangeSelection, $isTextNode } from "lexical";
+import { remark } from "remark";
+import remarkGfm from "remark-gfm";
+//#region src/plugins/markdown/data-source/markdown-data-source.ts
+init_helper();
+var MarkdownDataSource = class extends DataSource {
+	formatMarkdown(markdown) {
+		try {
+			const result = remark().use([[remarkGfm, { singleTilde: false }]]).data("settings", {
+				bullet: "-",
+				emphasis: "*",
+				fences: true,
+				rule: "-",
+				strong: "*",
+				tightDefinitions: true
+			}).processSync(markdown);
+			return String(result);
+		} catch (error) {
+			logger.error("Failed to format markdown:", error);
+			return markdown;
+		}
+	}
+	constructor(dataType, markdownService, getService) {
+		super(dataType);
+		this.dataType = dataType;
+		this.markdownService = markdownService;
+		this.getService = getService;
+	}
+	read(editor, data) {
+		const inode = { root: parseMarkdownToLexical(data, this.markdownService.markdownReaders) };
+		this.getService?.(INodeService)?.processNodeTree(inode);
+		logger.debug("Parsed Lexical State:", inode);
+		editor.setEditorState(editor.parseEditorState(inode));
+	}
+	write(editor, options) {
+		if (options?.selection) return editor.getEditorState().read(() => {
+			const selection = $getSelection();
+			if (!selection) return null;
+			const selectedNodes = selection.getNodes();
+			if ($isRangeSelection(selection)) {
+				const lastIndex = selectedNodes.length - 1;
+				const anchor = selection.anchor;
+				const focus = selection.focus;
+				const isBefore = anchor.isBefore(focus);
+				const firstNode = selectedNodes[0];
+				const lastNode = selectedNodes[lastIndex];
+				const [anchorOffset, focusOffset] = $getCharacterOffsets(selection);
+				let lastElement = [];
+				const rootNodes = [];
+				for (let i = 0; i < selectedNodes.length; i++) {
+					const node = selectedNodes[i];
+					if ($isElementNode(node)) {
+						const sNode = {
+							...node.exportJSON(),
+							$key: node.getKey()
+						};
+						for (let i = 0; i < rootNodes.length; i++) {
+							const child = rootNodes[i];
+							const childNode = $getNodeByKey(child.$key);
+							if (node.isParentOf(childNode)) {
+								sNode.children.push(child);
+								rootNodes.splice(i, 1);
+								i--;
+							}
+						}
+						let hasPush = false;
+						for (let i = lastElement.length - 1; i >= 0; i--) if ($getNodeByKey(lastElement[i].$key)?.isParentOf(node)) {
+							lastElement[i].children.push(sNode);
+							hasPush = true;
+							break;
+						} else lastElement.pop();
+						if (!hasPush) rootNodes.push(sNode);
+						lastElement.push(sNode);
+					} else if ($isTextNode(node)) {
+						const sNode = {
+							...node.exportJSON(),
+							$key: node.getKey()
+						};
+						if (node === firstNode) if (node === lastNode) {
+							if (anchor.type !== "element" || focus.type !== "element" || focus.offset === anchor.offset) sNode.text = anchorOffset < focusOffset ? sNode.text.slice(anchorOffset, focusOffset) : sNode.text.slice(focusOffset, anchorOffset);
+						} else sNode.text = isBefore ? sNode.text.slice(anchorOffset) : sNode.text.slice(focusOffset);
+						else if (node === lastNode) sNode.text = isBefore ? sNode.text.slice(0, focusOffset) : sNode.text.slice(0, anchorOffset);
+						let hasPush = false;
+						for (let i = lastElement.length - 1; i >= 0; i--) if ($getNodeByKey(lastElement[i].$key)?.isParentOf(node)) {
+							lastElement[i].children.push(sNode);
+							hasPush = true;
+							break;
+						} else lastElement.pop();
+						if (!hasPush) rootNodes.push(sNode);
+					} else {
+						const sNode = {
+							...node.exportJSON(),
+							$key: node.getKey()
+						};
+						let hasPush = false;
+						for (let i = lastElement.length - 1; i >= 0; i--) if ($getNodeByKey(lastElement[i].$key)?.isParentOf(node)) {
+							lastElement[i].children.push(sNode);
+							hasPush = true;
+							break;
+						} else lastElement.pop();
+						if (!hasPush) rootNodes.push(sNode);
+					}
+				}
+				const rootNode = INodeHelper.createRootNode();
+				if (rootNodes.some((node) => INodeHelper.isTextNode(node))) {
+					const p = INodeHelper.createParagraph();
+					INodeHelper.appendChild(p, ...rootNodes);
+					INodeHelper.appendChild(rootNode, p);
+				} else INodeHelper.appendChild(rootNode, ...rootNodes);
+				const editorState = editor.parseEditorState({ root: rootNode });
+				const lexicalRootNode = editorState._nodeMap.get("root");
+				const rootCtx = new MarkdownWriterContext(this.markdownService);
+				return editorState.read(() => {
+					lexicalRootNode.getChildren().forEach((child) => rootCtx.processChild(rootCtx, child));
+					return this.formatMarkdown(rootCtx.toString());
+				});
+			} else if ($isTableSelection(selection)) {}
+			const rootNode = INodeHelper.createRootNode();
+			if (selectedNodes.some((node) => node.isInline())) {
+				const p = INodeHelper.createParagraph();
+				INodeHelper.appendChild(p, ...selectedNodes.map((node) => node.exportJSON()));
+				INodeHelper.appendChild(rootNode, p);
+			} else INodeHelper.appendChild(rootNode, ...selectedNodes.map((node) => node.exportJSON()));
+			const editorState = editor.parseEditorState({ root: rootNode });
+			const lexicalRootNode = editorState._nodeMap.get("root");
+			const rootCtx = new MarkdownWriterContext(this.markdownService);
+			return editorState.read(() => {
+				lexicalRootNode.getChildren().forEach((child) => rootCtx.processChild(rootCtx, child));
+				return rootCtx.toString();
+			});
+		});
+		return editor.getEditorState().read(() => {
+			const rootNode = $getRoot();
+			const rootCtx = new MarkdownWriterContext(this.markdownService);
+			rootNode.getChildren().forEach((child) => rootCtx.processChild(rootCtx, child));
+			return this.formatMarkdown(rootCtx.toString());
+		});
+	}
+};
+//#endregion
+export { MarkdownDataSource as default };

package/es/plugins/markdown/data-source/markdown-writer-context.js

@@ -0,0 +1,40 @@
+import { $isElementNode } from "lexical";
+//#region src/plugins/markdown/data-source/markdown-writer-context.ts
+var MarkdownWriterContext = class MarkdownWriterContext {
+	constructor(markdownService) {
+		this.before = "";
+		this.after = "";
+		this.children = [];
+		this.markdownService = markdownService;
+	}
+	appendLine(line) {
+		this.children.push(line);
+	}
+	newChild() {
+		const child = new MarkdownWriterContext(this.markdownService);
+		this.children.push(child);
+		return child;
+	}
+	wrap(before, after) {
+		this.before = before;
+		this.after = after;
+	}
+	addProcessor(processor) {
+		this.processor = processor;
+	}
+	toString() {
+		const content = this.before + this.children.map((child) => child.toString()).join("") + this.after;
+		return this.processor ? this.processor(this.before, this.children.map((child) => child.toString()).join(""), this.after) : content;
+	}
+	processChild(parentCtx, child) {
+		const writer = this.markdownService.markdownWriters[child.getType()];
+		let currentCtx = parentCtx;
+		if ($isElementNode(child)) currentCtx = currentCtx.newChild();
+		let skipChildren = false;
+		if (writer) skipChildren = writer(currentCtx, child);
+		if (skipChildren) return;
+		if ($isElementNode(child)) child.getChildren().forEach((child) => this.processChild(currentCtx, child));
+	}
+};
+//#endregion
+export { MarkdownWriterContext };

package/es/plugins/markdown/index.d.ts

@@ -0,0 +1,7 @@
+import { IMarkdownShortCutService, MARKDOWN_READER_LEVEL, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX } from "./service/shortcut.js";
+import { GET_MARKDOWN_SELECTION_COMMAND, INSERT_MARKDOWN_COMMAND } from "./command/index.js";
+import { MarkdownPlugin } from "./plugin/index.js";
+import { ReactMarkdownPlugin } from "./react/index.js";
+import { isPunctuationChar } from "./utils/index.js";
+import { detectCodeLanguage, detectLanguage } from "./utils/detectLanguage.js";
+import { isPureUrl, isValidUrl } from "../../utils/url.js";

package/es/plugins/markdown/plugin/index.d.ts

@@ -0,0 +1,22 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+//#region src/plugins/markdown/plugin/index.d.ts
+interface MarkdownPluginOptions {
+  /**
+   * Automatically convert pasted markdown once the detection threshold is reached
+   * @default true
+   */
+  autoFormatMarkdown?: boolean;
+  /**
+   * Enable automatic markdown conversion for pasted content
+   * @default true
+   */
+  enablePasteMarkdown?: boolean;
+  /**
+   * Minimum markdown score required before auto conversion runs
+   * @default 5
+   */
+  pasteMarkdownAutoConvertThreshold?: number;
+}
+declare const MarkdownPlugin: IEditorPluginConstructor<MarkdownPluginOptions>;
+//#endregion
+export { MarkdownPlugin };