@lobehub/editor 4.15.1 → 4.15.2

package/es/plugins/markdown/utils/detectLanguage.js

@@ -0,0 +1,251 @@
+//#region src/plugins/markdown/utils/detectLanguage.ts
+const LANGUAGE_PATTERNS = {
+	bash: {
+		optional: [
+			/\|\||&&/,
+			/echo\s+/,
+			/if\s+\[/
+		],
+		required: [/^#!\/bin\/(ba)?sh/, /\${?\w+}?/],
+		weight: 7
+	},
+	csharp: {
+		optional: [
+			/\[.*]/,
+			/async\s+Task/,
+			/var\s+\w+\s*=/
+		],
+		required: [/(public|private|protected)\s+(class|interface|namespace)/, /using\s+\w+/],
+		weight: 8
+	},
+	css: {
+		optional: [/@media|@import|@keyframes/, /!important/],
+		required: [/[#.]?[\w-]+\s*{/, /:\s*[\w#%-]+;/],
+		weight: 8
+	},
+	dockerfile: {
+		required: [/^FROM\s+/, /^(RUN|CMD|COPY|ADD|WORKDIR|ENV|EXPOSE)\s+/m],
+		weight: 10
+	},
+	go: {
+		optional: [
+			/import\s+\(/,
+			/:=/,
+			/defer|goroutine/
+		],
+		required: [/package\s+\w+/, /func\s+\w+/],
+		weight: 8
+	},
+	graphql: {
+		optional: [/fragment\s+/, /on\s+\w+/],
+		required: [/(query|mutation|subscription)\s+/, /{[\S\s]*}/],
+		weight: 8
+	},
+	html: {
+		optional: [/<\/\w+>/, /class=|id=/],
+		required: [/<(html|head|body|div|span|p|a|img|script|style|link|meta)/i],
+		weight: 9
+	},
+	ini: {
+		exclude: [/^\s*</, /{.*}/],
+		required: [/^\[.*]$/m, /\w+\s*=\s*/],
+		weight: 6
+	},
+	java: {
+		optional: [
+			/@Override|@Autowired/,
+			/extends|implements/,
+			/System\.out/
+		],
+		required: [/(public|private|protected)\s+(class|interface|static)/, /\w+\s+\w+\s*\([^)]*\)\s*{/],
+		weight: 8
+	},
+	javascript: {
+		exclude: [
+			/^\s*</,
+			/interface\s+\w+/,
+			/:\s*\w+\s*[;=]/
+		],
+		optional: [
+			/=>\s*{/,
+			/console\.(log|error|warn)/,
+			/\.then\(/,
+			/require\(/
+		],
+		required: [/(function|const|let|var|class|import|export|async|await)\s/],
+		weight: 7
+	},
+	json: {
+		optional: [/"[^"]*"\s*:/, /:\s*["'[{]/],
+		required: [/^\s*[[{]/, /[\]}]\s*$/],
+		weight: 10
+	},
+	jsx: {
+		exclude: [/^\s*<!DOCTYPE/, /^\s*<html/],
+		optional: [
+			/className=/,
+			/{.*}/,
+			/import.*from/
+		],
+		required: [/<\w+[^>]*>/, /(const|function|class)\s+\w+/],
+		weight: 8
+	},
+	makefile: {
+		optional: [/\$\(.*\)/, /\.PHONY/],
+		required: [/^[\w-]+:\s*/, /^\t/m],
+		weight: 7
+	},
+	markdown: {
+		optional: [
+			/```/,
+			/\*\*.*\*\*/,
+			/^\s*[*+-]\s+/m
+		],
+		required: [/^#{1,6}\s+/, /\[.*]\(.*\)/],
+		weight: 6
+	},
+	php: {
+		optional: [
+			/function\s+\w+/,
+			/class\s+\w+/,
+			/echo|print/
+		],
+		required: [/<\?php/, /\$\w+/],
+		weight: 10
+	},
+	powershell: {
+		optional: [
+			/\|\s*Where/,
+			/\|\s*Select/,
+			/param\(/
+		],
+		required: [/\$\w+/, /(Get|Set|New|Remove)-\w+/],
+		weight: 8
+	},
+	python: {
+		optional: [
+			/if __name__|print\(/,
+			/self\.|lambda/,
+			/@\w+\s*$/m
+		],
+		required: [/(def|class|import|from)\s+\w+/, /:\s*$/m],
+		weight: 8
+	},
+	ruby: {
+		optional: [
+			/do\s*\|.*\|/,
+			/puts|require/,
+			/:\w+\s*=>/
+		],
+		required: [/(def|class|module|end)\s/, /@\w+/],
+		weight: 7
+	},
+	rust: {
+		optional: [
+			/::\w+/,
+			/&mut|&str/,
+			/#\[derive\(/
+		],
+		required: [/(fn|struct|impl|trait|use)\s+/, /let\s+(mut\s+)?\w+/],
+		weight: 8
+	},
+	scss: {
+		optional: [/@mixin|@include|@extend/, /#{.*}/],
+		required: [/\$[\w-]+\s*:/, /[&@]\w+/],
+		weight: 8
+	},
+	sql: {
+		optional: [/from|where|join|group by|order by/i, /\*/],
+		required: [/(select|insert|update|delete|create|alter|drop)\s+/i],
+		weight: 9
+	},
+	toml: {
+		optional: [/\[\[.*]]/, /"""[\S\s]*"""/],
+		required: [/^\[.*]$/m, /\w+\s*=\s*[\w"']/],
+		weight: 8
+	},
+	tsx: {
+		optional: [
+			/:\s*React\./,
+			/:\s*FC</,
+			/useState|useEffect/
+		],
+		required: [/<\w+[^>]*>/, /interface|type\s+\w+/],
+		weight: 9
+	},
+	typescript: {
+		optional: [
+			/<\w+>/,
+			/as\s+\w+/,
+			/implements|extends/
+		],
+		required: [/(interface|type|enum)\s+\w+/, /:\s*\w+(\[]|<.+>)?\s*[);=]/],
+		weight: 8
+	},
+	xml: {
+		optional: [/<\/\w+>/, /xmlns/],
+		required: [/<\?xml|<\w+[^>]*>/],
+		weight: 9
+	},
+	yaml: {
+		exclude: [/^\s*[[\]{]/],
+		required: [/^[\s-]*\w+:\s*/, /^[\s-]*-\s+/m],
+		weight: 8
+	}
+};
+/**
+* Detect the programming language of a code snippet
+* @param code - The code snippet to analyze
+* @returns Language detection result with confidence score
+*/
+function detectLanguage(code) {
+	if (!code || code.trim().length === 0) return null;
+	const trimmed = code.trim();
+	const scores = {};
+	for (const [language, pattern] of Object.entries(LANGUAGE_PATTERNS)) {
+		let score = 0;
+		const baseWeight = pattern.weight || 5;
+		if (pattern.exclude) {
+			if (pattern.exclude.some((regex) => regex.test(trimmed))) continue;
+		}
+		if (pattern.required) {
+			if (!pattern.required.every((regex) => regex.test(trimmed))) continue;
+			score += baseWeight * 2;
+		}
+		if (pattern.optional) {
+			const matchedOptional = pattern.optional.filter((regex) => regex.test(trimmed)).length;
+			score += matchedOptional * baseWeight;
+		}
+		if (score > 0) scores[language] = score;
+	}
+	const entries = Object.entries(scores);
+	if (entries.length === 0) return null;
+	entries.sort((a, b) => b[1] - a[1]);
+	const [topLanguage, topScore] = entries[0];
+	const maxPossibleScore = (LANGUAGE_PATTERNS[topLanguage].weight || 5) * 5;
+	const confidence = Math.min(100, Math.round(topScore / maxPossibleScore * 100));
+	if (confidence < 30) return null;
+	return {
+		confidence,
+		language: topLanguage
+	};
+}
+/**
+* Simple detection for common formats with high confidence
+* Falls back to detectLanguage for more complex detection
+*/
+function detectCodeLanguage(code) {
+	const trimmed = code.trim();
+	if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) try {
+		JSON.parse(trimmed);
+		return "json";
+	} catch {}
+	if (/^\s*(select|insert|update|delete|create|alter|drop)\s+/i.test(code)) return "sql";
+	if (/^<\?xml/i.test(code)) return "xml";
+	if (/^FROM\s+|^RUN\s+|^CMD\s+/m.test(code)) return "dockerfile";
+	if (/<\?php/.test(code)) return "php";
+	const result = detectLanguage(code);
+	return result && result.confidence > 50 ? result.language : null;
+}
+//#endregion
+export { detectCodeLanguage, detectLanguage };

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

@@ -0,0 +1,11 @@
+import { BaseSelection, LexicalEditor, LexicalNode, TextNode } from "lexical";
+
+//#region src/plugins/markdown/utils/index.d.ts
+/**
+ * Checks if a character is a punctuation character.
+ * @param char The character to check.
+ * @returns True if the character is a punctuation character, false otherwise.
+ */
+declare function isPunctuationChar(char: string): boolean;
+//#endregion
+export { isPunctuationChar };

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

@@ -0,0 +1,143 @@
+import { $caretFromPoint, $getCaretRange, $getChildCaret, $getRoot, $isElementNode, $isRangeSelection, $isTextNode, $isTextPointCaret, $parseSerializedNode, SELECTION_INSERT_CLIPBOARD_NODES_COMMAND } from "lexical";
+//#region src/plugins/markdown/utils/index.ts
+/**
+* Returns true if the node can contain transformable markdown.
+* Code nodes cannot contain transformable markdown.
+* For example, `code **bold**` should not be transformed to
+* <code>code <strong>bold</strong></code>.
+*/
+function canContainTransformableMarkdown(node) {
+	return $isTextNode(node) && !node.hasFormat("code");
+}
+function isEqualSubString(stringA, aStart, stringB, bStart, length) {
+	for (let i = 0; i < length; i++) if (stringA[aStart + i] !== stringB[bStart + i]) return false;
+	return true;
+}
+const PUNCTUATION_OR_SPACE = /[!-/:-@[-`{-~\s]/;
+function getOpenTagStartIndex(string, maxIndex, tag) {
+	const tagLength = tag.length;
+	for (let i = maxIndex; i >= tagLength; i--) {
+		const startIndex = i - tagLength;
+		if (isEqualSubString(string, startIndex, tag, 0, tagLength) && string[startIndex + tagLength] !== " ") return startIndex;
+	}
+	return -1;
+}
+function indexBy(list, callback) {
+	const index = {};
+	for (const item of list) {
+		const key = callback(item);
+		if (!key) continue;
+		if (index[key]) index[key].push(item);
+		else index[key] = [item];
+	}
+	return index;
+}
+let Punctuation = /[!"#$%&'()*+,./:;<=>?@[\\\]^_`{|}~\u00A1\u2010-\u2027-]/;
+try {
+	Punctuation = /* @__PURE__ */ new RegExp("[\\p{Pc}|\\p{Pd}|\\p{Pe}|\\p{Pf}|\\p{Pi}|\\p{Po}|\\p{Ps}]", "u");
+} catch {}
+/**
+* Checks if a character is a punctuation character.
+* @param char The character to check.
+* @returns True if the character is a punctuation character, false otherwise.
+*/
+function isPunctuationChar(char) {
+	return Punctuation.test(char);
+}
+function $updateSelectionOnInsert(selection) {
+	if ($isRangeSelection(selection) && selection.isCollapsed()) {
+		const anchor = selection.anchor;
+		let nodeToInspect = null;
+		const anchorCaret = $caretFromPoint(anchor, "previous");
+		if (anchorCaret) if ($isTextPointCaret(anchorCaret)) nodeToInspect = anchorCaret.origin;
+		else {
+			const range = $getCaretRange(anchorCaret, $getChildCaret($getRoot(), "next").getFlipped());
+			for (const caret of range) if ($isTextNode(caret.origin)) {
+				nodeToInspect = caret.origin;
+				break;
+			} else if ($isElementNode(caret.origin) && !caret.origin.isInline()) break;
+		}
+		if (nodeToInspect && $isTextNode(nodeToInspect)) {
+			const newFormat = nodeToInspect.getFormat();
+			const newStyle = nodeToInspect.getStyle();
+			if (selection.format !== newFormat || selection.style !== newStyle) {
+				selection.format = newFormat;
+				selection.style = newStyle;
+				selection.dirty = true;
+			}
+		}
+	}
+}
+/**
+* Inserts Lexical nodes into the editor using different strategies depending on
+* some simple selection-based heuristics. If you're looking for a generic way to
+* to insert nodes into the editor at a specific selection point, you probably want
+* {@link lexical.$insertNodes}
+*
+* @param editor LexicalEditor instance to insert the nodes into.
+* @param nodes The nodes to insert.
+* @param selection The selection to insert the nodes into.
+*/
+function $insertGeneratedNodes(editor, nodes, selection) {
+	if (!editor.dispatchCommand(SELECTION_INSERT_CLIPBOARD_NODES_COMMAND, {
+		nodes,
+		selection
+	})) {
+		selection.insertNodes(nodes);
+		$updateSelectionOnInsert(selection);
+	}
+}
+/**
+* Creates an object containing all the styles and their values provided in the CSS string.
+* @param css - The CSS string of styles and their values.
+* @returns The styleObject containing all the styles and their values.
+*/
+function getStyleObjectFromRawCSS(css) {
+	const styleObject = {};
+	if (!css) return styleObject;
+	const styles = css.split(";");
+	for (const style of styles) if (style !== "") {
+		const [key, value] = style.split(/:([^]+)/);
+		if (key && value) styleObject[key.trim()] = value.trim();
+	}
+	return styleObject;
+}
+/**
+* Copyright (c) Meta Platforms, Inc. and affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*
+*/
+const CSS_TO_STYLES = /* @__PURE__ */ new Map();
+/**
+* Gets the TextNode's style object and adds the styles to the CSS.
+* @param node - The TextNode to add styles to.
+*/
+function $addNodeStyle(node) {
+	const CSSText = node.getStyle();
+	const styles = getStyleObjectFromRawCSS(CSSText);
+	CSS_TO_STYLES.set(CSSText, styles);
+}
+/**
+* This method takes an array of objects conforming to the BaseSerializedNode interface and returns
+* an Array containing instances of the corresponding LexicalNode classes registered on the editor.
+* Normally, you'd get an Array of BaseSerialized nodes from {@link $generateJSONFromSelectedNodes}
+*
+* @param serializedNodes an Array of objects conforming to the BaseSerializedNode interface.
+* @returns an Array of Lexical Node objects.
+*/
+function $generateNodesFromSerializedNodes(serializedNodes) {
+	const nodes = [];
+	for (const serializedNode of serializedNodes) {
+		const node = $parseSerializedNode(serializedNode);
+		if ($isTextNode(node)) $addNodeStyle(node);
+		nodes.push(node);
+	}
+	return nodes;
+}
+function insertIRootNode(editor, root, selection) {
+	$insertGeneratedNodes(editor, $generateNodesFromSerializedNodes(root.children), selection);
+}
+//#endregion
+export { $generateNodesFromSerializedNodes, $insertGeneratedNodes, PUNCTUATION_OR_SPACE, canContainTransformableMarkdown, getOpenTagStartIndex, indexBy, insertIRootNode, isEqualSubString, isPunctuationChar };

package/es/plugins/markdown/utils/logger.js

@@ -0,0 +1,6 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+//#region src/plugins/markdown/utils/logger.ts
+init_debug();
+const logger = createDebugLogger("plugin", "markdown");
+//#endregion
+export { logger };

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

@@ -0,0 +1,9 @@
+import * as _$lexical from "lexical";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/math/command/index.d.ts
+declare const INSERT_MATH_COMMAND: _$lexical.LexicalCommand<{
+  code: string;
+}>;
+//#endregion
+export { INSERT_MATH_COMMAND };

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

@@ -0,0 +1,38 @@
+import { $createMathInlineNode } from "../node/index.js";
+import { $createParagraphNode, $getNodeByKey, $insertNodes, $isRootOrShadowRoot, COMMAND_PRIORITY_HIGH, createCommand } from "lexical";
+import { $wrapNodeInElement, mergeRegister } from "@lexical/utils";
+//#region src/plugins/math/command/index.ts
+const INSERT_MATH_COMMAND = createCommand("INSERT_MATH_COMMAND");
+const UPDATE_MATH_COMMAND = createCommand("UPDATE_MATH_COMMAND");
+const SELECT_MATH_SIDE_COMMAND = createCommand("SELECT_MATH_SIDE_COMMAND");
+function registerMathCommand(editor) {
+	return mergeRegister(editor.registerCommand(INSERT_MATH_COMMAND, (payload) => {
+		const { code } = payload;
+		editor.update(() => {
+			const mathNode = $createMathInlineNode(code);
+			$insertNodes([mathNode]);
+			if ($isRootOrShadowRoot(mathNode.getParentOrThrow())) $wrapNodeInElement(mathNode, $createParagraphNode).selectEnd();
+		});
+		return true;
+	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(UPDATE_MATH_COMMAND, (payload) => {
+		const { code, key } = payload;
+		editor.update(() => {
+			const mathCode = $getNodeByKey(key);
+			if (mathCode) {
+				mathCode.updateCode(code);
+				mathCode.selectNext();
+			}
+		});
+		return true;
+	}, COMMAND_PRIORITY_HIGH), editor.registerCommand(SELECT_MATH_SIDE_COMMAND, (payload) => {
+		const { key, prev } = payload;
+		editor.update(() => {
+			const mathNode = $getNodeByKey(key);
+			if (mathNode) if (prev) mathNode.selectPrevious();
+			else mathNode.selectNext();
+		});
+		return true;
+	}, COMMAND_PRIORITY_HIGH));
+}
+//#endregion
+export { INSERT_MATH_COMMAND, SELECT_MATH_SIDE_COMMAND, UPDATE_MATH_COMMAND, registerMathCommand };

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

@@ -0,0 +1,3 @@
+import { INSERT_MATH_COMMAND } from "./command/index.js";
+import { MathPlugin } from "./plugin/index.js";
+import { ReactMathPlugin } from "./react/index.js";

package/es/plugins/math/node/index.d.ts

@@ -0,0 +1,44 @@
+import { DOMConversionMap, DOMExportOutput, DecoratorNode, EditorConfig, LexicalEditor, LexicalNode, LexicalUpdateJSON, SerializedLexicalNode, Spread } from "lexical";
+
+//#region src/plugins/math/node/index.d.ts
+type SerializedMathInlineNode = Spread<{
+  code: string;
+}, SerializedLexicalNode>;
+declare class MathInlineNode extends DecoratorNode<unknown> {
+  static getType(): string;
+  static clone(node: MathInlineNode): MathInlineNode;
+  static importJSON(serializedNode: SerializedMathInlineNode): MathInlineNode;
+  static importDOM(): DOMConversionMap | null;
+  __code: string;
+  constructor(code?: string, key?: string);
+  get code(): string;
+  updateCode(newCode: string): void;
+  exportDOM(): DOMExportOutput;
+  createDOM(config: EditorConfig): HTMLElement;
+  exportJSON(): SerializedMathInlineNode;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedMathInlineNode>): this;
+  getTextContent(): string;
+  isInline(): boolean;
+  updateDOM(): boolean;
+  decorate(editor: LexicalEditor): unknown;
+}
+declare class MathBlockNode extends DecoratorNode<unknown> {
+  static getType(): string;
+  static clone(node: MathBlockNode): MathBlockNode;
+  static importJSON(serializedNode: SerializedMathInlineNode): MathBlockNode;
+  static importDOM(): DOMConversionMap | null;
+  __code: string;
+  constructor(code?: string, key?: string);
+  get code(): string;
+  updateCode(newCode: string): void;
+  exportDOM(): DOMExportOutput;
+  createDOM(config: EditorConfig): HTMLElement;
+  exportJSON(): SerializedMathInlineNode;
+  updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedMathInlineNode>): this;
+  getTextContent(): string;
+  isInline(): boolean;
+  updateDOM(): boolean;
+  decorate(editor: LexicalEditor): unknown;
+}
+//#endregion
+export { MathBlockNode, MathInlineNode };

package/es/plugins/math/node/index.js

@@ -0,0 +1,161 @@
+import { getKernelFromEditor } from "../../../editor-kernel/utils.js";
+import { $applyNodeReplacement, DecoratorNode } from "lexical";
+import { addClassNamesToElement } from "@lexical/utils";
+//#region src/plugins/math/node/index.ts
+var MathInlineNode = class MathInlineNode extends DecoratorNode {
+	static getType() {
+		return "math";
+	}
+	static clone(node) {
+		return new MathInlineNode(node.__code, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createMathInlineNode().updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { span: (node) => {
+			if (node.classList.contains("math-inline")) return {
+				conversion: $convertMathInlineElement,
+				priority: 0
+			};
+			return null;
+		} };
+	}
+	constructor(code = "", key) {
+		super(key);
+		this.__code = code;
+	}
+	get code() {
+		return this.__code;
+	}
+	updateCode(newCode) {
+		const writer = this.getWritable();
+		writer.__code = newCode;
+	}
+	exportDOM() {
+		const span = document.createElement("span");
+		span.className = "math-inline";
+		return { element: span };
+	}
+	createDOM(config) {
+		const element = document.createElement("span");
+		addClassNamesToElement(element, config.theme.mathInline);
+		return element;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			code: this.__code
+		};
+	}
+	updateFromJSON(serializedNode) {
+		const node = super.updateFromJSON(serializedNode);
+		this.__code = serializedNode.code || "";
+		return node;
+	}
+	getTextContent() {
+		return `$${this.code}$`;
+	}
+	isInline() {
+		return true;
+	}
+	updateDOM() {
+		return false;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(MathInlineNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		};
+	}
+};
+var MathBlockNode = class MathBlockNode extends DecoratorNode {
+	static getType() {
+		return "mathBlock";
+	}
+	static clone(node) {
+		return new MathBlockNode(node.__code, node.__key);
+	}
+	static importJSON(serializedNode) {
+		return $createMathBlockNode().updateFromJSON(serializedNode);
+	}
+	static importDOM() {
+		return { div: (node) => {
+			if (node.classList.contains("math-block")) return {
+				conversion: $convertMathBlockElement,
+				priority: 0
+			};
+			return null;
+		} };
+	}
+	constructor(code = "", key) {
+		super(key);
+		this.__code = code;
+	}
+	get code() {
+		return this.__code;
+	}
+	updateCode(newCode) {
+		const writer = this.getWritable();
+		writer.__code = newCode;
+	}
+	exportDOM() {
+		const div = document.createElement("div");
+		div.className = "math-block";
+		return { element: div };
+	}
+	createDOM(config) {
+		const element = document.createElement("div");
+		addClassNamesToElement(element, config.theme.mathBlock);
+		return element;
+	}
+	exportJSON() {
+		return {
+			...super.exportJSON(),
+			code: this.__code
+		};
+	}
+	updateFromJSON(serializedNode) {
+		const node = super.updateFromJSON(serializedNode);
+		this.__code = serializedNode.code || "";
+		return node;
+	}
+	getTextContent() {
+		return `$$\n${this.code}\n$$\n`;
+	}
+	isInline() {
+		return false;
+	}
+	updateDOM() {
+		return false;
+	}
+	decorate(editor) {
+		const decorator = getKernelFromEditor(editor)?.getDecorator(MathBlockNode.getType());
+		if (!decorator) return null;
+		if (typeof decorator === "function") return decorator(this, editor);
+		return {
+			queryDOM: decorator.queryDOM,
+			render: decorator.render(this, editor)
+		};
+	}
+};
+function $createMathInlineNode(code = "") {
+	return $applyNodeReplacement(new MathInlineNode(code));
+}
+function $createMathBlockNode(code = "") {
+	return $applyNodeReplacement(new MathBlockNode(code));
+}
+function $convertMathInlineElement() {
+	return { node: $createMathInlineNode() };
+}
+function $convertMathBlockElement() {
+	return { node: $createMathBlockNode() };
+}
+function $isMathNode(node) {
+	return node instanceof MathInlineNode || node instanceof MathBlockNode;
+}
+//#endregion
+export { $createMathBlockNode, $createMathInlineNode, $isMathNode, MathBlockNode, MathInlineNode };

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

@@ -0,0 +1,15 @@
+import { IEditorPluginConstructor } from "../../../types/kernel.js";
+import { MathBlockNode, MathInlineNode } from "../node/index.js";
+import { LexicalEditor } from "lexical";
+
+//#region src/plugins/math/plugin/index.d.ts
+interface MathPluginOptions {
+  decorator: (node: MathInlineNode | MathBlockNode, editor: LexicalEditor) => unknown;
+  theme?: {
+    mathBlock?: string;
+    mathInline?: string;
+  };
+}
+declare const MathPlugin: IEditorPluginConstructor<MathPluginOptions>;
+//#endregion
+export { MathPlugin };