@lobehub/editor 4.15.0 → 4.15.2

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

@@ -0,0 +1,285 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { KernelPlugin, init_plugin } from "../../../editor-kernel/plugin.js";
+import { canContainTransformableMarkdown } from "../utils/index.js";
+import { INSERT_MARKDOWN_COMMAND, registerMarkdownCommand } from "../command/index.js";
+import MarkdownDataSource from "../data-source/markdown-data-source.js";
+import { IMarkdownShortCutService, MarkdownShortCutService } from "../service/shortcut.js";
+import { detectCodeLanguage, detectLanguage } from "../utils/detectLanguage.js";
+import { $getNodeByKey, $getSelection, $isRangeSelection, $isTextNode, COLLABORATION_TAG, COMMAND_PRIORITY_CRITICAL, COMMAND_PRIORITY_LOW, COPY_COMMAND, HISTORIC_TAG, KEY_ENTER_COMMAND, PASTE_COMMAND } from "lexical";
+import { $getClipboardDataFromSelection, setLexicalClipboardDataTransfer } from "@lexical/clipboard";
+import { $isCodeNode } from "@lexical/code-core";
+//#region src/plugins/markdown/plugin/index.ts
+init_plugin();
+init_debug();
+const DEFAULT_PASTE_MARKDOWN_AUTO_CONVERT_THRESHOLD = 5;
+const RICH_HTML_SELECTOR = "strong,em,b,i,h1,h2,h3,h4,h5,h6,ul,ol,table,img,blockquote,pre>code,a[href]";
+const MARKDOWN_DETECTION_RULES = [
+	{
+		name: "headers",
+		score: 5,
+		test: (text) => /^#{1,6}\s+\S/m.test(text)
+	},
+	{
+		name: "code-fence-start",
+		score: 5,
+		test: (text) => /^```[\w-]*$/m.test(text)
+	},
+	{
+		name: "links",
+		score: 4,
+		test: (text) => /\[[^\]]+]\([^)]+\)/.test(text)
+	},
+	{
+		name: "images",
+		score: 5,
+		test: (text) => /!\[[^\]]*]\([^)]+\)/.test(text)
+	},
+	{
+		name: "tables",
+		score: 5,
+		test: (text) => /^\|.+\|$/m.test(text) && /^\|[\s:|-]+\|$/m.test(text)
+	},
+	{
+		name: "admonitions",
+		score: 5,
+		test: (text) => /^>\s*\[!(?:note|tip|warning|caution|important)]/im.test(text)
+	},
+	{
+		name: "task-lists",
+		score: 4,
+		test: (text) => /^[*-]\s+\[[ x]]/m.test(text)
+	},
+	{
+		name: "bold",
+		score: 2,
+		test: (text) => /\*\*.+?\*\*/.test(text)
+	},
+	{
+		name: "italic",
+		score: 1,
+		test: (text) => /(?<!\*)\*(?!\*)(?!\s).+?(?<!\s)(?<!\*)\*(?!\*)/.test(text)
+	},
+	{
+		name: "unordered-lists",
+		score: 1,
+		test: (text) => /^[*+-]\s+\S/m.test(text)
+	},
+	{
+		name: "ordered-lists",
+		score: 1,
+		test: (text) => /^\d+\.\s+\S/m.test(text)
+	},
+	{
+		name: "blockquotes",
+		score: 1,
+		test: (text) => /^>\s+\S/m.test(text)
+	},
+	{
+		name: "inline-code",
+		score: 1,
+		test: (text) => /`.+?`/.test(text)
+	},
+	{
+		name: "horizontal-rules",
+		score: 2,
+		test: (text) => /^[*_-]{3,}$/m.test(text)
+	},
+	{
+		name: "multi-paragraph",
+		score: 5,
+		test: (text) => text.split(/\n{2,}/).filter(Boolean).length >= 2
+	},
+	{
+		name: "short-text-penalty",
+		score: -3,
+		test: (text) => text.length < 20
+	},
+	{
+		name: "single-line-penalty",
+		score: -2,
+		test: (text) => !text.includes("\n")
+	}
+];
+const MarkdownPlugin = class extends KernelPlugin {
+	static {
+		this.pluginName = "MarkdownPlugin";
+	}
+	constructor(kernel, config) {
+		super();
+		this.kernel = kernel;
+		this.config = config;
+		this.logger = createDebugLogger("plugin", "markdown");
+		this.service = new MarkdownShortCutService(kernel);
+		kernel.registerService(IMarkdownShortCutService, this.service);
+		this.markdownDataSource = new MarkdownDataSource("markdown", this.service, (serviceId) => {
+			return kernel.requireService(serviceId);
+		});
+		kernel.registerDataSource(this.markdownDataSource);
+	}
+	onInit(editor) {
+		this.register(editor.registerUpdateListener(({ tags, dirtyLeaves, editorState, prevEditorState }) => {
+			if (tags.has(COLLABORATION_TAG) || tags.has(HISTORIC_TAG)) return;
+			if (editor.isComposing()) return;
+			const selection = editorState.read($getSelection);
+			const prevSelection = prevEditorState.read($getSelection);
+			if (!$isRangeSelection(prevSelection) || !$isRangeSelection(selection) || !selection.isCollapsed() || selection.is(prevSelection)) return;
+			const anchorKey = selection.anchor.key;
+			const anchorOffset = selection.anchor.offset;
+			const anchorNode = editorState._nodeMap.get(anchorKey);
+			if (!$isTextNode(anchorNode) || !dirtyLeaves.has(anchorKey) || anchorOffset !== 1 && anchorOffset > prevSelection.anchor.offset + 1) return;
+			editor.update(() => {
+				if (!canContainTransformableMarkdown(anchorNode)) return;
+				const parentNode = anchorNode.getParent();
+				if (parentNode === null || $isCodeNode(parentNode)) return;
+				this.service.runTransformers(parentNode, anchorNode, selection.anchor.offset);
+			});
+		}));
+		this.register(editor.registerCommand(KEY_ENTER_COMMAND, (payload) => {
+			const ret = editor.getEditorState().read(() => {
+				const selection = $getSelection();
+				if (!$isRangeSelection(selection) || !selection.isCollapsed()) return false;
+				const anchorKey = selection.anchor.key;
+				const anchorNode = $getNodeByKey(anchorKey);
+				if (!anchorNode) return false;
+				return {
+					anchorNode,
+					offset: selection.anchor.offset
+				};
+			});
+			if (!ret) return false;
+			const { anchorNode, offset } = ret;
+			if (!canContainTransformableMarkdown(anchorNode)) return false;
+			const parentNode = anchorNode.getParent();
+			if (parentNode === null || $isCodeNode(parentNode)) return false;
+			if (this.service.testTransformers(parentNode, anchorNode, offset, "enter")) {
+				queueMicrotask(() => {
+					editor.update(() => {
+						this.service.runTransformers(parentNode, anchorNode, offset, "enter");
+					});
+				});
+				payload?.stopPropagation();
+				payload?.stopImmediatePropagation();
+				payload?.preventDefault();
+				return true;
+			}
+			return false;
+		}, COMMAND_PRIORITY_CRITICAL));
+		this.register(editor.registerCommand(PASTE_COMMAND, (event) => {
+			if (!(event instanceof ClipboardEvent)) return false;
+			if (!this.shouldHandlePasteMarkdown()) return false;
+			const clipboardData = event.clipboardData;
+			if (!clipboardData) return false;
+			const text = clipboardData.getData("text/plain").trimEnd().replaceAll(/[\u200B-\u200D\u2060\uFEFF]/g, "");
+			const html = clipboardData.getData("text/html").trimEnd();
+			if (!text) return false;
+			this.logger.debug("paste content analysis:", {
+				clipboardTypes: Array.from(clipboardData.types || []),
+				hasHTML: !!(html && html.trim()),
+				htmlLength: html?.length || 0,
+				textLength: text.length
+			});
+			if (this.hasRichHTML(clipboardData)) {
+				this.logger.debug("rich HTML detected, skipping markdown auto-convert");
+				return false;
+			}
+			const detectionResult = this.getMarkdownDetectionResult(text);
+			if (detectionResult.shouldAutoConvert) {
+				this.logger.debug("markdown auto-convert detected:", detectionResult);
+				const historyState = this.kernel.getHistoryState().current;
+				setTimeout(() => {
+					editor.dispatchCommand(INSERT_MARKDOWN_COMMAND, {
+						historyState,
+						markdown: text
+					});
+					this.kernel.emit("markdownParse", {
+						cacheState: editor.getEditorState(),
+						historyState,
+						markdown: text,
+						matchedPatterns: detectionResult.matchedPatterns,
+						score: detectionResult.score
+					});
+				}, 10);
+			} else this.logger.debug("markdown score below auto-convert threshold, keeping as plain text:", detectionResult);
+			return false;
+		}, COMMAND_PRIORITY_CRITICAL));
+		this.register(registerMarkdownCommand(editor, this.kernel, this.service));
+		this.register(editor.registerCommand(COPY_COMMAND, (event) => {
+			if (!(event instanceof ClipboardEvent)) return false;
+			const clipboardData = event.clipboardData;
+			if (!clipboardData) return false;
+			const selection = $getSelection();
+			if (!selection || selection.isCollapsed()) return false;
+			const markdown = this.markdownDataSource.write(editor, { selection: true });
+			if (!markdown) return false;
+			event.preventDefault();
+			setLexicalClipboardDataTransfer(clipboardData, $getClipboardDataFromSelection(selection));
+			clipboardData.setData("text/plain", markdown);
+			clipboardData.setData("text/markdown", markdown);
+			this.logger.debug("copy with text/markdown:", { markdownLength: markdown.length });
+			return true;
+		}, COMMAND_PRIORITY_LOW));
+	}
+	/**
+	* Detect if content is code and should be inserted as code block
+	* Uses advanced language detection with pattern matching
+	* Excludes markdown because markdown content is handled by the paste auto-convert flow
+	*/
+	detectCodeContent(text) {
+		const detected = detectLanguage(text);
+		if (detected && detected.confidence > 50) {
+			if (detected.language === "markdown") return null;
+			this.logger.debug("language detected:", detected);
+			return detected;
+		}
+		const fastDetected = detectCodeLanguage(text);
+		if (fastDetected) {
+			if (fastDetected === "markdown") return null;
+			return {
+				confidence: 80,
+				language: fastDetected
+			};
+		}
+		return null;
+	}
+	hasRichHTML(clipboardData) {
+		const html = clipboardData.getData("text/html");
+		if (!html) return false;
+		if (/data-vscode|vscode-/i.test(html)) return false;
+		if (typeof DOMParser === "undefined") return false;
+		return new DOMParser().parseFromString(html, "text/html").body.querySelectorAll(RICH_HTML_SELECTOR).length > 0;
+	}
+	/**
+	* Analyze pasted text and determine whether it should auto convert to markdown
+	*/
+	getMarkdownDetectionResult(text) {
+		if (this.detectCodeContent(text)) return {
+			matchedPatterns: [],
+			score: 0,
+			shouldAutoConvert: false
+		};
+		const matchedPatterns = [];
+		let score = 0;
+		const threshold = this.getPasteMarkdownAutoConvertThreshold();
+		for (const rule of MARKDOWN_DETECTION_RULES) {
+			if (!rule.test(text)) continue;
+			matchedPatterns.push(rule.name);
+			score += rule.score;
+		}
+		return {
+			matchedPatterns,
+			score,
+			shouldAutoConvert: score >= threshold
+		};
+	}
+	getPasteMarkdownAutoConvertThreshold() {
+		const threshold = this.config?.pasteMarkdownAutoConvertThreshold;
+		if (typeof threshold !== "number" || Number.isNaN(threshold)) return DEFAULT_PASTE_MARKDOWN_AUTO_CONVERT_THRESHOLD;
+		return Math.max(1, threshold);
+	}
+	shouldHandlePasteMarkdown() {
+		if (this.config?.enablePasteMarkdown === false) return false;
+		return this.config?.autoFormatMarkdown !== false;
+	}
+};
+//#endregion
+export { MarkdownPlugin };

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

@@ -0,0 +1,6 @@
+import { FC } from "react";
+
+//#region src/plugins/markdown/react/index.d.ts
+declare const ReactMarkdownPlugin: FC<void>;
+//#endregion
+export { ReactMarkdownPlugin };

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

@@ -0,0 +1,31 @@
+"use client";
+import { useLexicalComposerContext } from "../../../editor-kernel/react/react-context.js";
+import { INodePlugin } from "../../inode/plugin/index.js";
+import { MarkdownPlugin } from "../plugin/index.js";
+import { useTranslation } from "../../../editor-kernel/react/useTranslation.js";
+import { toast } from "@lobehub/ui";
+import { useLayoutEffect } from "react";
+//#region src/plugins/markdown/react/index.tsx
+const ReactMarkdownPlugin = () => {
+	const [editor] = useLexicalComposerContext();
+	const t = useTranslation();
+	useLayoutEffect(() => {
+		editor.registerPlugin(INodePlugin);
+		editor.registerPlugin(MarkdownPlugin);
+		const handleEvent = () => {
+			toast.info({
+				description: t("markdown.autoFormatMessage"),
+				duration: 5e3,
+				title: t("markdown.autoFormatTitle")
+			});
+		};
+		editor.on("markdownParse", handleEvent);
+		return () => {
+			editor.off("markdownParse", handleEvent);
+		};
+	}, [editor, t]);
+	return null;
+};
+ReactMarkdownPlugin.displayName = "ReactMarkdownPlugin";
+//#endregion
+export { ReactMarkdownPlugin as default };

package/es/plugins/markdown/service/shortcut.d.ts

@@ -0,0 +1,57 @@
+import { IServiceID } from "../../../types/kernel.js";
+import { IRootNode } from "../../../editor-kernel/inode/root-node.js";
+import { MarkdownReaderFunc, TransformerRecord } from "../data-source/markdown/parse.js";
+import { Transformer } from "./transformers.js";
+import { BaseSelection, ElementNode, LexicalEditor, LexicalNode, TextNode } from "lexical";
+
+//#region src/plugins/markdown/service/shortcut.d.ts
+interface IMarkdownWriterContext {
+  /**
+   * Add processor
+   * @param processor
+   */
+  addProcessor(processor: (before: string, content: string, after: string) => string): void;
+  /**
+   * Direct output
+   * @param line
+   * @returns
+   */
+  appendLine: (line: string) => void;
+  /**
+   * Control child node to markdown
+   * @param parentCtx
+   * @param child
+   * @returns
+   */
+  processChild: (parentCtx: IMarkdownWriterContext, child: LexicalNode) => void;
+  /**
+   * Wrap child elements
+   * @param before
+   * @param after
+   * @returns
+   */
+  wrap: (before: string, after: string) => void;
+}
+declare const MARKDOWN_WRITER_LEVEL_MAX = 0;
+declare const MARKDOWN_READER_LEVEL_HIGH = 1;
+declare const MARKDOWN_READER_LEVEL_NORMAL = 2;
+type MARKDOWN_READER_LEVEL = typeof MARKDOWN_READER_LEVEL_HIGH | typeof MARKDOWN_READER_LEVEL_NORMAL | typeof MARKDOWN_WRITER_LEVEL_MAX;
+interface IMarkdownShortCutService {
+  insertIRootNode(editor: LexicalEditor, root: IRootNode, selection: BaseSelection): void;
+  parseMarkdownToLexical(markdown: string): IRootNode;
+  /**
+   * Register Markdown reader
+   */
+  registerMarkdownReader<K extends keyof TransformerRecord>(type: K, reader: MarkdownReaderFunc<K>, level?: MARKDOWN_READER_LEVEL): void;
+  registerMarkdownShortCut(transformer: Transformer): void;
+  registerMarkdownShortCuts(transformers: Transformer[]): void;
+  /**
+   * Register Markdown writer
+   * @param type Lexical Node type
+   * @param writer
+   */
+  registerMarkdownWriter(type: string, writer: (ctx: IMarkdownWriterContext, node: LexicalNode) => void | boolean): void;
+}
+declare const IMarkdownShortCutService: IServiceID<IMarkdownShortCutService>;
+//#endregion
+export { IMarkdownShortCutService, MARKDOWN_READER_LEVEL, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX };

package/es/plugins/markdown/service/shortcut.js

@@ -0,0 +1,101 @@
+import { createDebugLogger, init_debug } from "../../../utils/debug.js";
+import { genServiceId } from "../../../editor-kernel/utils.js";
+import { parseMarkdownToLexical } from "../data-source/markdown/parse.js";
+import { indexBy, insertIRootNode } from "../utils/index.js";
+import { $runTextFormatTransformers, runElementTransformers, runTextMatchTransformers, testElementTransformers } from "./transformers.js";
+//#region src/plugins/markdown/service/shortcut.ts
+init_debug();
+const MARKDOWN_WRITER_LEVEL_MAX = 0;
+const MARKDOWN_READER_LEVEL_HIGH = 1;
+const MARKDOWN_READER_LEVEL_NORMAL = 2;
+const IMarkdownShortCutService = genServiceId("MarkdownShortCutService");
+var MarkdownShortCutService = class {
+	constructor(kernel) {
+		this.kernel = kernel;
+		this.elementTransformers = [];
+		this.textFormatTransformers = [];
+		this.textMatchTransformers = [];
+		this.logger = createDebugLogger("service", "markdown");
+		this._markdownWriters = {};
+		this._markdownReaders = [
+			{},
+			{},
+			{}
+		];
+		this._textFormatTransformersByTrigger = null;
+		this._textMatchTransformersByTrigger = null;
+	}
+	get markdownWriters() {
+		return this._markdownWriters;
+	}
+	get markdownReaders() {
+		return this._markdownReaders.reduce((acc, curr) => {
+			Object.keys(curr).forEach((key) => {
+				if (!acc[key]) acc[key] = [];
+				const existing = acc[key];
+				const adding = curr[key];
+				existing.push(...adding);
+			});
+			return acc;
+		}, {});
+	}
+	get textMatchTransformersByTrigger() {
+		if (!this._textMatchTransformersByTrigger) this._textMatchTransformersByTrigger = indexBy(this.textMatchTransformers, ({ trigger }) => trigger);
+		return this._textMatchTransformersByTrigger;
+	}
+	get textFormatTransformersByTrigger() {
+		if (!this._textFormatTransformersByTrigger) this._textFormatTransformersByTrigger = indexBy(this.textFormatTransformers, ({ tag }) => tag.at(-1));
+		return this._textFormatTransformersByTrigger;
+	}
+	registerMarkdownShortCut(transformer) {
+		switch (transformer.type) {
+			case "element":
+				this.elementTransformers.push(transformer);
+				break;
+			case "text-format":
+				this.textFormatTransformers.push(transformer);
+				break;
+			case "text-match":
+				this.textMatchTransformers.push(transformer);
+				break;
+			default: throw new Error(`Unknown transformer type: ${transformer}`);
+		}
+	}
+	registerMarkdownShortCuts(transformers) {
+		for (const transformer of transformers) this.registerMarkdownShortCut(transformer);
+	}
+	testTransformers(parentNode, anchorNode, anchorOffset, trigger) {
+		if (testElementTransformers(parentNode, anchorNode, anchorOffset, this.elementTransformers, trigger)) return true;
+		return false;
+	}
+	runTransformers(parentNode, anchorNode, anchorOffset, trigger) {
+		if (runElementTransformers(parentNode, anchorNode, anchorOffset, this.elementTransformers, trigger)) return true;
+		if (runTextMatchTransformers(anchorNode, anchorOffset, this.textMatchTransformersByTrigger)) return true;
+		if ($runTextFormatTransformers(anchorNode, anchorOffset, this.textFormatTransformersByTrigger)) return true;
+		return false;
+	}
+	registerMarkdownWriter(type, writer) {
+		if (!this._markdownWriters[type]) {
+			this._markdownWriters[type] = writer;
+			return;
+		}
+		if (this.kernel?.isHotReloadMode()) {
+			this.logger.warn(`🔄 Hot reload: markdown writer "${type}"`);
+			this._markdownWriters[type] = writer;
+			return;
+		}
+		throw new Error(`Markdown writer for type "${type}" is already registered.`);
+	}
+	registerMarkdownReader(type, reader, level = 2) {
+		if (!this._markdownReaders[level][type]) this._markdownReaders[level][type] = [];
+		if (this._markdownReaders[level]) this._markdownReaders[level][type]?.push(reader);
+	}
+	parseMarkdownToLexical(markdown) {
+		return parseMarkdownToLexical(markdown, this.markdownReaders);
+	}
+	insertIRootNode(editor, root, selection) {
+		insertIRootNode(editor, root, selection);
+	}
+};
+//#endregion
+export { IMarkdownShortCutService, MARKDOWN_READER_LEVEL_HIGH, MARKDOWN_READER_LEVEL_NORMAL, MARKDOWN_WRITER_LEVEL_MAX, MarkdownShortCutService };

package/es/plugins/markdown/service/transformers.d.ts

@@ -0,0 +1,61 @@
+import { ElementNode, LexicalNode, RangeSelection, TextFormatType, TextNode } from "lexical";
+
+//#region src/plugins/markdown/service/transformers.d.ts
+type TextFormatTransformer = Readonly<{
+  format?: ReadonlyArray<TextFormatType>;
+  intraword?: boolean;
+  process?: (selection: RangeSelection) => boolean | void;
+  tag: string;
+  type: 'text-format';
+}>;
+type TextMatchTransformer = Readonly<{
+  /**
+   * For import operations, this function can be used to determine the end index of the match, after `importRegExp` has matched.
+   * Without this function, the end index will be determined by the length of the match from `importRegExp`. Manually determining the end index can be useful if
+   * the match from `importRegExp` is not the entire text content of the node. That way, `importRegExp` can be used to match only the start of the node, and `getEndIndex`
+   * can be used to match the end of the node.
+   *
+   * @returns The end index of the match, or false if the match was unsuccessful and a different transformer should be tried.
+   */
+  getEndIndex?: (node: TextNode, match: RegExpMatchArray) => number | false;
+  /**
+   * This regex determines what text is matched during markdown imports
+   */
+  importRegExp?: RegExp;
+  /**
+   * This regex determines what text is matched for markdown shortcuts while typing in the editor
+   */
+  regExp: RegExp;
+  /**
+   * Determines how the matched markdown text should be transformed into a node during the markdown import process
+   *
+   * @returns nothing, or a TextNode that may be a child of the new node that is created.
+   * If a TextNode is returned, text format matching will be applied to it (e.g. bold, italic, etc.)
+   */
+  replace?: (node: TextNode, match: RegExpMatchArray) => void | TextNode;
+  /**
+   * Single character that allows the transformer to trigger when typed in the editor. This does not affect markdown imports outside of the markdown shortcut plugin.
+   * If the trigger is matched, the `regExp` will be used to match the text in the second step.
+   */
+  trigger?: string;
+  type: 'text-match';
+}>;
+type ElementTransformer = {
+  regExp: RegExp;
+  /**
+   * `replace` is called when markdown is imported or typed in the editor
+   *
+   * @return return false to cancel the transform, even though the regex matched. Lexical will then search for the next transformer.
+   */
+  replace: (parentNode: ElementNode, children: Array<LexicalNode>, match: Array<string>,
+  /**
+   * Whether the match is from an import operation (e.g. through `$convertFromMarkdownString`) or not (e.g. through typing in the editor).
+   */
+
+  isImport: boolean) => boolean | void;
+  trigger?: 'enter';
+  type: 'element';
+};
+type Transformer = ElementTransformer | TextFormatTransformer | TextMatchTransformer;
+//#endregion
+export { Transformer };

package/es/plugins/markdown/service/transformers.js

@@ -0,0 +1,119 @@
+import { PUNCTUATION_OR_SPACE, getOpenTagStartIndex, isEqualSubString } from "../utils/index.js";
+import { $createRangeSelection, $getNodeByKey, $getSelection, $isLineBreakNode, $isRangeSelection, $isRootOrShadowRoot, $isTextNode, $setSelection } from "lexical";
+//#region src/plugins/markdown/service/transformers.ts
+function testElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers, fromTrigger) {
+	if (!$isRootOrShadowRoot(parentNode.getParent()) || parentNode.getFirstChild() !== anchorNode) return false;
+	const textContent = anchorNode.getTextContent();
+	if (fromTrigger !== "enter" && textContent[anchorOffset - 1] !== " ") return false;
+	for (const { regExp, trigger } of elementTransformers) {
+		const match = textContent.match(regExp);
+		if (fromTrigger === trigger && match && match[0].length === (fromTrigger === "enter" || match[0].endsWith(" ") ? anchorOffset : anchorOffset - 1)) return true;
+	}
+	return false;
+}
+function runElementTransformers(parentNode, anchorNode, anchorOffset, elementTransformers, fromTrigger) {
+	if (!$isRootOrShadowRoot(parentNode.getParent()) || parentNode.getFirstChild() !== anchorNode) return false;
+	const textContent = anchorNode.getTextContent();
+	if (fromTrigger !== "enter" && textContent[anchorOffset - 1] !== " ") return false;
+	for (const { regExp, replace, trigger } of elementTransformers) {
+		const match = textContent.match(regExp);
+		if (fromTrigger === trigger && match && match[0].length === (fromTrigger === "enter" || match[0].endsWith(" ") ? anchorOffset : anchorOffset - 1)) {
+			const nextSiblings = anchorNode.getNextSiblings();
+			const [leadingNode, remainderNode] = anchorNode.splitText(anchorOffset);
+			if (replace(parentNode, remainderNode ? [remainderNode, ...nextSiblings] : nextSiblings, match, false) !== false) {
+				leadingNode.remove();
+				return true;
+			}
+		}
+	}
+	return false;
+}
+function runTextMatchTransformers(anchorNode, anchorOffset, transformersByTrigger) {
+	let textContent = anchorNode.getTextContent();
+	const transformers = transformersByTrigger[textContent[anchorOffset - 1]];
+	if (!transformers) return false;
+	if (anchorOffset < textContent.length) textContent = textContent.slice(0, anchorOffset);
+	for (const transformer of transformers) {
+		if (!transformer.replace || !transformer.regExp) continue;
+		const match = textContent.match(transformer.regExp);
+		if (match === null) continue;
+		const startIndex = match.index || 0;
+		const endIndex = startIndex + match[0].length;
+		let replaceNode;
+		if (startIndex === 0) [replaceNode] = anchorNode.splitText(endIndex);
+		else [, replaceNode] = anchorNode.splitText(startIndex, endIndex);
+		replaceNode.selectNext(0, 0);
+		transformer.replace(replaceNode, match);
+		return true;
+	}
+	return false;
+}
+function $runTextFormatTransformers(anchorNode, anchorOffset, textFormatTransformers) {
+	const textContent = anchorNode.getTextContent();
+	const closeTagEndIndex = anchorOffset - 1;
+	const closeChar = textContent[closeTagEndIndex];
+	const matchers = textFormatTransformers[closeChar];
+	if (!matchers) return false;
+	for (const matcher of matchers) {
+		const { tag } = matcher;
+		const tagLength = tag.length;
+		const closeTagStartIndex = closeTagEndIndex - tagLength + 1;
+		if (tagLength > 1 && !isEqualSubString(textContent, closeTagStartIndex, tag, 0, tagLength)) continue;
+		if (textContent[closeTagStartIndex - 1] === " ") continue;
+		const afterCloseTagChar = textContent[closeTagEndIndex + 1];
+		if (matcher.intraword === false && afterCloseTagChar && !PUNCTUATION_OR_SPACE.test(afterCloseTagChar)) continue;
+		const closeNode = anchorNode;
+		let openNode = closeNode;
+		let openTagStartIndex = getOpenTagStartIndex(textContent, closeTagStartIndex, tag);
+		let sibling = openNode;
+		while (openTagStartIndex < 0 && (sibling = sibling.getPreviousSibling())) {
+			if ($isLineBreakNode(sibling)) break;
+			if ($isTextNode(sibling)) {
+				if (sibling.hasFormat("code")) continue;
+				const siblingTextContent = sibling.getTextContent();
+				openNode = sibling;
+				openTagStartIndex = getOpenTagStartIndex(siblingTextContent, siblingTextContent.length, tag);
+			}
+		}
+		if (openTagStartIndex < 0) continue;
+		if (openNode === closeNode && openTagStartIndex + tagLength === closeTagStartIndex) continue;
+		const prevOpenNodeText = openNode.getTextContent();
+		if (openTagStartIndex > 0 && prevOpenNodeText[openTagStartIndex - 1] === closeChar) continue;
+		const beforeOpenTagChar = prevOpenNodeText[openTagStartIndex - 1];
+		if (matcher.intraword === false && beforeOpenTagChar && !PUNCTUATION_OR_SPACE.test(beforeOpenTagChar)) continue;
+		const prevCloseNodeText = closeNode.getTextContent();
+		const closeNodeText = prevCloseNodeText.slice(0, closeTagStartIndex) + prevCloseNodeText.slice(closeTagEndIndex + 1);
+		closeNode.setTextContent(closeNodeText);
+		const openNodeText = openNode === closeNode ? closeNodeText : prevOpenNodeText;
+		openNode.setTextContent(openNodeText.slice(0, openTagStartIndex) + openNodeText.slice(openTagStartIndex + tagLength));
+		const selection = $getSelection();
+		const nextSelection = $createRangeSelection();
+		$setSelection(nextSelection);
+		const newOffset = closeTagEndIndex - tagLength * (openNode === closeNode ? 2 : 1) + 1;
+		nextSelection.anchor.set(openNode.__key, openTagStartIndex, "text");
+		nextSelection.focus.set(closeNode.__key, newOffset, "text");
+		if (matcher.process) {
+			if (matcher.process(nextSelection) === false) {
+				const currentOpenNode = $getNodeByKey(openNode.__key);
+				const currentCloseNode = $getNodeByKey(closeNode.__key);
+				if ($isTextNode(currentOpenNode)) currentOpenNode.setTextContent(prevOpenNodeText);
+				if (currentCloseNode !== currentOpenNode && $isTextNode(currentCloseNode)) currentCloseNode.setTextContent(prevCloseNodeText);
+				$setSelection(anchorNode.selectEnd());
+				continue;
+			}
+			return true;
+		} else if (matcher.format) {
+			for (const format of matcher.format) if (!nextSelection.hasFormat(format)) nextSelection.formatText(format);
+			nextSelection.anchor.set(nextSelection.focus.key, nextSelection.focus.offset, nextSelection.focus.type);
+			for (const format of matcher.format) if (nextSelection.hasFormat(format)) nextSelection.toggleFormat(format);
+			if ($isRangeSelection(selection)) nextSelection.format = selection.format;
+		} else {
+			$setSelection(selection);
+			continue;
+		}
+		return true;
+	}
+	return false;
+}
+//#endregion
+export { $runTextFormatTransformers, runElementTransformers, runTextMatchTransformers, testElementTransformers };

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

@@ -0,0 +1,22 @@
+//#region src/plugins/markdown/utils/detectLanguage.d.ts
+/**
+ * Language detection utility for code snippets
+ * Uses pattern matching and heuristics to identify programming languages
+ */
+interface LanguageDetectionResult {
+  confidence: number;
+  language: string;
+}
+/**
+ * Detect the programming language of a code snippet
+ * @param code - The code snippet to analyze
+ * @returns Language detection result with confidence score
+ */
+declare function detectLanguage(code: string): LanguageDetectionResult | null;
+/**
+ * Simple detection for common formats with high confidence
+ * Falls back to detectLanguage for more complex detection
+ */
+declare function detectCodeLanguage(code: string): string | null;
+//#endregion
+export { detectCodeLanguage, detectLanguage };