@lofcz/platejs-markdown 52.3.6 → 52.3.9

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import * as platejs2 from "platejs";
 import { Descendant, NodeKey, Nullable, OmitFirst, PluginConfig, SlateEditor, TElement, TListElement, TNodeMap, TText, Value } from "platejs";
 import { MdxJsxFlowElement, MdxJsxFlowElement as MdMdxJsxFlowElement, MdxJsxTextElement, MdxJsxTextElement as MdMdxJsxTextElement } from "mdast-util-mdx";
-import { Options } from "remark-stringify";
 import { Plugin } from "unified";
+import { Options } from "remark-stringify";
 import { Token } from "marked";
 import baseRemarkMdx from "remark-mdx";
 import { Blockquote as MdBlockquote, Break as MdBreak, Code as MdCode, Content as MdContent, Definition as MdDefinition, Delete as MdDelete, Emphasis as MdEmphasis, FootnoteDefinition as MdFootnoteDefinition, FootnoteReference as MdFootnoteReference, Heading as MdHeading, Html as MdHtml, Image as MdImage, ImageReference as MdImageReference, InlineCode as MdInlineCode, Link as MdLink, LinkReference as MdLinkReference, List as MdList, ListItem as MdListItem, Paragraph as MdParagraph, PhrasingContent as MDPhrasingContent, Root, Root as MdRoot, RootContent as MdRootContent, Strong as MdStrong, Table as MdTable, TableCell as MdTableCell, TableRow as MdTableRow, Text as MdText, ThematicBreak as MdThematicBreak, Yaml as MdYaml } from "mdast";
@@ -40,6 +40,48 @@ declare const convertTextsSerialize: (slateTexts: readonly TText[], options: Ser
 //#region src/lib/serializer/listToMdastTree.d.ts
 declare function listToMdastTree(nodes: TListElement[], options: SerializeMdOptions, isBlock?: boolean): any;
 //#endregion
+//#region src/lib/serializer/serializeMdWithSourceMap.d.ts
+type SelectionPath = number[];
+type MarkdownSourceMapKind = 'block' | 'blockquote' | 'code_block' | 'heading' | 'list_item' | 'media' | 'paragraph' | 'table_cell';
+type MarkdownSourceMapSegment = {
+  containsMdx: boolean;
+  endLine: number;
+  kind: MarkdownSourceMapKind;
+  markdown: string;
+  nodeId?: string;
+  path: SelectionPath;
+  pathKey: string;
+  startLine: number;
+  text: string;
+};
+type SerializeMdSourceMapResult = {
+  /** All segments including container-level (parent MDX) segments, sorted by path. */
+  allSegments: MarkdownSourceMapSegment[];
+  markdown: string;
+  /** Leaf-level segments only (most precise per path). */
+  segments: MarkdownSourceMapSegment[];
+};
+declare const serializeMdWithSourceMap: (editor: SlateEditor, options?: Omit<SerializeMdOptions, "editor">) => SerializeMdSourceMapResult;
+//#endregion
+//#region src/lib/serializer/resolveSelectionLines.d.ts
+type SelectionPoint = {
+  offset: number;
+  path: number[];
+};
+type SelectionRange = {
+  anchor: SelectionPoint;
+  focus: SelectionPoint;
+};
+type ResolveSelectionByPathResult = {
+  containsMdx: boolean;
+  endLine: number;
+  extractedMarkdown: string;
+  markdown: string;
+  segments: MarkdownSourceMapSegment[];
+  startLine: number;
+};
+declare const resolveSelectionByPath: (editor: SlateEditor, selection: SelectionRange, options?: Omit<SerializeMdOptions, "editor">) => ResolveSelectionByPathResult;
+//#endregion
 //#region src/lib/serializer/serializeInlineMd.d.ts
 declare const serializeInlineMd: (editor: SlateEditor, options?: SerializeMdOptions) => string;
 //#endregion
@@ -494,4 +536,4 @@ declare const tagRemarkPlugin: (pluginFn: any, tag: string) => {
 };
 declare const getRemarkPluginsWithoutMdx: (plugins: Plugin[]) => Plugin[];
 //#endregion
-export { AllowNodeConfig, DeserializeMdOptions, type MDPhrasingContent, MarkdownConfig, MarkdownPlugin, type MdBlockquote, type MdBreak, type MdCode, type MdContent, MdDecoration, type MdDefinition, type MdDelete, type MdEmphasis, type MdFootnoteDefinition, type MdFootnoteReference, type MdHeading, type MdHtml, type MdImage, type MdImageReference, type MdInlineCode, type MdInlineMath, type MdLink, type MdLinkReference, type MdList, type MdListItem, MdMark, type MdMath, type MdMdxJsxFlowElement, type MdMdxJsxTextElement, MdNodeParser, type MdParagraph, type MdRoot, type MdRootContent, MdRules, type MdStrong, type MdTable, type MdTableCell, type MdTableRow, type MdText, type MdThematicBreak, MdType, type MdYaml, MentionNode, ParseMarkdownBlocksOptions, PlateType, REMARK_MDX_TAG, SerializeMdOptions, StrictPlateType, basicMarkdownMarks, buildMdastNode, buildRules, buildSlateNode, columnRules, convertChildrenDeserialize, convertNodesDeserialize, convertNodesSerialize, convertTextsDeserialize, convertTextsSerialize, customMdxDeserialize, defaultRules, deserializeInlineMd, deserializeMd, fontRules, getCustomMark, getDeserializerByKey, getMergedOptionsDeserialize, getMergedOptionsSerialize, getRemarkPluginsWithoutMdx, getSerializerByKey, getStyleValue, htmlToJsx, listToMdastTree, markdownToAstProcessor, markdownToSlateNodes, markdownToSlateNodesSafely, mdastToPlate, mdastToSlate, mediaRules, parseAttributes, parseMarkdownBlocks, plateToMdast, propsToAttributes, remarkMdx, remarkMention, serializeInlineMd, serializeMd, splitIncompleteMdx, stripMarkdown, stripMarkdownBlocks, stripMarkdownInline, tagRemarkPlugin, type unistLib, unreachable, wrapWithBlockId };
+export { AllowNodeConfig, DeserializeMdOptions, type MDPhrasingContent, MarkdownConfig, MarkdownPlugin, MarkdownSourceMapKind, MarkdownSourceMapSegment, type MdBlockquote, type MdBreak, type MdCode, type MdContent, MdDecoration, type MdDefinition, type MdDelete, type MdEmphasis, type MdFootnoteDefinition, type MdFootnoteReference, type MdHeading, type MdHtml, type MdImage, type MdImageReference, type MdInlineCode, type MdInlineMath, type MdLink, type MdLinkReference, type MdList, type MdListItem, MdMark, type MdMath, type MdMdxJsxFlowElement, type MdMdxJsxTextElement, MdNodeParser, type MdParagraph, type MdRoot, type MdRootContent, MdRules, type MdStrong, type MdTable, type MdTableCell, type MdTableRow, type MdText, type MdThematicBreak, MdType, type MdYaml, MentionNode, ParseMarkdownBlocksOptions, PlateType, REMARK_MDX_TAG, ResolveSelectionByPathResult, SelectionRange, SerializeMdOptions, SerializeMdSourceMapResult, StrictPlateType, basicMarkdownMarks, buildMdastNode, buildRules, buildSlateNode, columnRules, convertChildrenDeserialize, convertNodesDeserialize, convertNodesSerialize, convertTextsDeserialize, convertTextsSerialize, customMdxDeserialize, defaultRules, deserializeInlineMd, deserializeMd, fontRules, getCustomMark, getDeserializerByKey, getMergedOptionsDeserialize, getMergedOptionsSerialize, getRemarkPluginsWithoutMdx, getSerializerByKey, getStyleValue, htmlToJsx, listToMdastTree, markdownToAstProcessor, markdownToSlateNodes, markdownToSlateNodesSafely, mdastToPlate, mdastToSlate, mediaRules, parseAttributes, parseMarkdownBlocks, plateToMdast, propsToAttributes, remarkMdx, remarkMention, resolveSelectionByPath, serializeInlineMd, serializeMd, serializeMdWithSourceMap, splitIncompleteMdx, stripMarkdown, stripMarkdownBlocks, stripMarkdownInline, tagRemarkPlugin, type unistLib, unreachable, wrapWithBlockId };

package/dist/index.js

@@ -1,8 +1,9 @@
 import { ElementApi, KEYS, TextApi, bindFirst, createTSlatePlugin, getPluginKey, getPluginType, isUrl } from "platejs";
 import "mdast-util-mdx";
 import kebabCase from "lodash/kebabCase.js";
-import remarkStringify from "remark-stringify";
+import { defaultHandlers, toMarkdown } from "mdast-util-to-markdown";
 import { unified } from "unified";
+import remarkStringify from "remark-stringify";
 import remarkParse from "remark-parse";
 import { marked } from "marked";
 import baseRemarkMdx from "remark-mdx";
@@ -591,12 +592,12 @@ const convertNodesSerialize = (nodes, options, isBlock = false) => {
 	for (let i = 0; i <= nodes.length; i++) {
 		const n = nodes[i];
 		if (n && TextApi.isText(n)) {
-			if (shouldIncludeText(n, options)) textQueue.push(n);
+			if (shouldIncludeText$1(n, options)) textQueue.push(n);
 		} else {
 			if (textQueue.length > 0) mdastNodes.push(...convertTextsSerialize(textQueue, options));
 			textQueue = [];
 			if (!n) continue;
-			if (!shouldIncludeNode$1(n, options)) continue;
+			if (!shouldIncludeNode$2(n, options)) continue;
 			const pType = getPluginType(options.editor, KEYS.p) ?? KEYS.p;
 			if (n?.type === pType && "listStyleType" in n) {
 				listBlock.push(n);
@@ -631,6 +632,122 @@ const buildMdastNode = (node, options, isBlock = false) => {
 	}
 	unreachable(node);
 };
+const shouldIncludeText$1 = (text, options) => {
+	const { allowedNodes, allowNode, disallowedNodes } = options;
+	if (allowedNodes && disallowedNodes && allowedNodes.length > 0 && disallowedNodes.length > 0) throw new Error("Cannot combine allowedNodes with disallowedNodes");
+	for (const [key, value] of Object.entries(text)) {
+		if (key === "text") continue;
+		if (allowedNodes) {
+			if (!allowedNodes.includes(key) && value) return false;
+		} else if (disallowedNodes?.includes(key) && value) return false;
+	}
+	if (allowNode?.serialize) return allowNode.serialize(text);
+	return true;
+};
+const shouldIncludeNode$2 = (node, options) => {
+	const { allowedNodes, allowNode, disallowedNodes } = options;
+	if (!node.type) return true;
+	if (allowedNodes && disallowedNodes && allowedNodes.length > 0 && disallowedNodes.length > 0) throw new Error("Cannot combine allowedNodes with disallowedNodes");
+	if (allowedNodes) {
+		if (!allowedNodes.includes(node.type)) return false;
+	} else if (disallowedNodes?.includes(node.type)) return false;
+	if (allowNode?.serialize) return allowNode.serialize(node);
+	return true;
+};
+
+//#endregion
+//#region src/lib/serializer/serializeMdWithSourceMap.ts
+const collectSlateText = (node) => {
+	if (typeof node === "string") return node;
+	if (node?.text != null) return node.text;
+	if (Array.isArray(node?.children)) return node.children.map(collectSlateText).join("");
+	return "";
+};
+const comparePaths = (a, b) => {
+	const len = Math.min(a.length, b.length);
+	for (let i = 0; i < len; i++) if (a[i] !== b[i]) return a[i] - b[i];
+	return a.length - b.length;
+};
+const isPathPrefix = (prefix, path) => prefix.length < path.length && prefix.every((part, index) => path[index] === part);
+const toPathKey = (path) => path.join(".");
+const annotatePaths = (node, path) => {
+	if (node == null || typeof node !== "object") return node;
+	const clone = {
+		...node,
+		__sourceMapPath: path
+	};
+	if (Array.isArray(node.children)) clone.children = node.children.map((child, i) => annotatePaths(child, [...path, i]));
+	return clone;
+};
+const MDX_MDAST_TYPES = new Set(["mdxJsxFlowElement", "mdxJsxTextElement"]);
+const propagateMdxFlag = (node) => {
+	if (!node || typeof node !== "object") return;
+	if (node.data?.sourceMap) node.data.sourceMap.containsMdx = true;
+	if (Array.isArray(node.children)) for (const child of node.children) propagateMdxFlag(child);
+};
+const SEGMENT_SKIP_TYPES = new Set([
+	"table",
+	"tr",
+	KEYS.table,
+	KEYS.tr,
+	"column_group",
+	"column",
+	KEYS.columnGroup,
+	KEYS.column
+]);
+const MEDIA_TYPES = new Set([
+	"img",
+	"image",
+	"media_embed",
+	"video",
+	"audio",
+	"file",
+	"excalidraw",
+	KEYS.img,
+	KEYS.mediaEmbed,
+	KEYS.video,
+	KEYS.audio,
+	KEYS.file,
+	KEYS.excalidraw
+]);
+const slateNodeKind = (node, editor) => {
+	if (node.listStyleType) return "list_item";
+	const key = getPluginKey(editor, node.type) ?? node.type;
+	if (KEYS.heading.includes(key) || key === "heading") return "heading";
+	if (key === KEYS.blockquote) return "blockquote";
+	if (key === KEYS.codeBlock || key === "code_block") return "code_block";
+	if (key === KEYS.td || key === KEYS.th) return "table_cell";
+	if (MEDIA_TYPES.has(key)) return "media";
+	const pType = getPluginType(editor, KEYS.p) ?? KEYS.p;
+	if (node.type === pType) return "paragraph";
+	if (SEGMENT_SKIP_TYPES.has(key)) return null;
+	if (Array.isArray(node.children)) return "block";
+	return null;
+};
+const buildSource = (node, editor) => {
+	if (!node || typeof node !== "object" || !Array.isArray(node.children)) return null;
+	const kind = slateNodeKind(node, editor);
+	if (!kind) return null;
+	const path = Array.isArray(node.__sourceMapPath) ? node.__sourceMapPath : null;
+	if (!path) return null;
+	const text = collectSlateText(node);
+	return {
+		containsMdx: false,
+		kind,
+		nodeId: typeof node.id === "string" ? node.id : void 0,
+		path,
+		pathKey: toPathKey(path),
+		text
+	};
+};
+const attachSource = (mdastNode, source) => {
+	if (!source || !mdastNode || typeof mdastNode !== "object") return mdastNode;
+	mdastNode.data = {
+		...mdastNode.data ?? {},
+		sourceMap: source
+	};
+	return mdastNode;
+};
 const shouldIncludeText = (text, options) => {
 	const { allowedNodes, allowNode, disallowedNodes } = options;
 	if (allowedNodes && disallowedNodes && allowedNodes.length > 0 && disallowedNodes.length > 0) throw new Error("Cannot combine allowedNodes with disallowedNodes");
@@ -653,6 +770,507 @@ const shouldIncludeNode$1 = (node, options) => {
 	if (allowNode?.serialize) return allowNode.serialize(node);
 	return true;
 };
+/**
+* After building a table mdast node, attach sourceMap to individual cells by
+* walking the Slate table and mdast table in parallel.
+*/
+const attachTableCellSources = (mdastTable, slateTable, editor) => {
+	const mdastRows = mdastTable.children || [];
+	const slateRows = slateTable.children || [];
+	for (let r = 0; r < Math.min(mdastRows.length, slateRows.length); r++) {
+		const mdastCells = mdastRows[r]?.children || [];
+		const slateCells = slateRows[r]?.children || [];
+		for (let c = 0; c < Math.min(mdastCells.length, slateCells.length); c++) {
+			const source = buildSource(slateCells[c], editor);
+			if (source) attachSource(mdastCells[c], source);
+		}
+	}
+};
+/**
+* Custom serializers (e.g. MDX components) build their own mdast subtree,
+* bypassing convertNodesWithSource. Walk Slate and mdast element children
+* in parallel (by position) and attach sourceMap data so the handler
+* wrappers capture per-child segments during serialization.
+*
+* Position-based matching works because custom serializers preserve child
+* order. We filter to element children only (skip text/leaf nodes) in both
+* trees before zipping.
+*/
+/**
+* Walk the mdast list tree and attach sources from the flat Slate list
+* paragraphs. Slate uses flat paragraphs with `listStyleType` while mdast
+* nests them as list > listItem > paragraph. We walk both in document order
+* to zip them correctly.
+*/
+const attachListSources = (mdastList, slateListItems, editor, insideMdx) => {
+	let slateIdx = 0;
+	const walkList = (list) => {
+		if (!Array.isArray(list.children)) return;
+		for (const listItem of list.children) {
+			if (listItem.type !== "listItem" || !Array.isArray(listItem.children)) continue;
+			for (const child of listItem.children) if (child.type === "list") walkList(child);
+			else if (slateIdx < slateListItems.length) {
+				const slateChild = slateListItems[slateIdx++];
+				const source = buildSource(slateChild, editor);
+				if (source) {
+					if (insideMdx) source.containsMdx = true;
+					attachSource(child, source);
+				}
+			}
+		}
+	};
+	walkList(mdastList);
+};
+const attachDescendantSources = (mdastNode, slateNode, editor, insideMdx) => {
+	if (!insideMdx && !MDX_MDAST_TYPES.has(mdastNode?.type ?? "")) return;
+	const slateChildren = slateNode?.children;
+	const mdastChildren = mdastNode?.children;
+	if (!Array.isArray(slateChildren) || !Array.isArray(mdastChildren)) return;
+	const slateElements = slateChildren.filter((c) => c?.type && Array.isArray(c.children));
+	const mdastElements = mdastChildren.filter((c) => c.type && c.type !== "text");
+	let si = 0;
+	for (const mdastChild of mdastElements) {
+		if (mdastChild.type === "list") {
+			const listRun = [];
+			while (si < slateElements.length && slateElements[si].listStyleType) {
+				listRun.push(slateElements[si]);
+				si++;
+			}
+			attachListSources(mdastChild, listRun, editor, insideMdx);
+			continue;
+		}
+		if (si >= slateElements.length) break;
+		const slateChild = slateElements[si];
+		si++;
+		const isMdx = insideMdx || MDX_MDAST_TYPES.has(mdastChild.type ?? "");
+		const source = buildSource(slateChild, editor);
+		if (source) {
+			if (isMdx) source.containsMdx = true;
+			attachSource(mdastChild, source);
+		}
+		if (mdastChild.type === "table") attachTableCellSources(mdastChild, slateChild, editor);
+		else if (insideMdx || MDX_MDAST_TYPES.has(mdastChild.type ?? "")) attachDescendantSources(mdastChild, slateChild, editor, isMdx);
+	}
+};
+const buildMdastNodeWithSource = (node, options, isBlock = false) => {
+	let mdastNode = buildMdastNode(node, options, isBlock);
+	if (!mdastNode) {
+		const text = collectSlateText(node);
+		if (text.trim()) mdastNode = {
+			children: [{
+				type: "text",
+				value: text
+			}],
+			type: "paragraph"
+		};
+		else mdastNode = {
+			type: "html",
+			value: `<!-- ${node.type ?? "unknown"} -->`
+		};
+	}
+	if (mdastNode?.type === "table") {
+		attachTableCellSources(mdastNode, node, options.editor);
+		return mdastNode;
+	}
+	const source = buildSource(node, options.editor);
+	const isMdxOutput = MDX_MDAST_TYPES.has(mdastNode?.type ?? "");
+	if (!source) {
+		if (isMdxOutput) propagateMdxFlag(mdastNode);
+		attachDescendantSources(mdastNode, node, options.editor, isMdxOutput);
+		return mdastNode;
+	}
+	if (isMdxOutput) source.containsMdx = true;
+	if (source.kind === "blockquote" && Array.isArray(mdastNode?.children) && mdastNode.children[0]) {
+		attachSource(mdastNode.children[0], source);
+		return mdastNode;
+	}
+	attachSource(mdastNode, source);
+	attachDescendantSources(mdastNode, node, options.editor, isMdxOutput);
+	return mdastNode;
+};
+const convertNodesWithSource = (nodes, options, isBlock = false) => {
+	const mdastNodes = [];
+	let textQueue = [];
+	const listBlock = [];
+	for (let i = 0; i <= nodes.length; i++) {
+		const n = nodes[i];
+		if (n && TextApi.isText(n)) {
+			if (shouldIncludeText(n, options)) textQueue.push(n);
+			continue;
+		}
+		if (textQueue.length > 0) mdastNodes.push(...convertTextsSerialize(textQueue, options));
+		textQueue = [];
+		if (!n) continue;
+		if (!shouldIncludeNode$1(n, options)) continue;
+		const pType = getPluginType(options.editor, KEYS.p) ?? KEYS.p;
+		if (n?.type === pType && "listStyleType" in n) {
+			listBlock.push(n);
+			const next = nodes[i + 1];
+			const isNextIndent = next && next.type === pType && "listStyleType" in next;
+			const firstList = listBlock.at(0);
+			const hasDifferentListStyle = isNextIndent && firstList && next.listStyleType !== firstList.listStyleType && next.indent === firstList.indent;
+			if (!isNextIndent || hasDifferentListStyle) {
+				mdastNodes.push(listToMdastTreeWithSource(listBlock, options));
+				listBlock.length = 0;
+			}
+			continue;
+		}
+		const node = buildMdastNodeWithSource(n, options, isBlock);
+		if (node) mdastNodes.push(node);
+	}
+	return mdastNodes;
+};
+const listToMdastTreeWithSource = (nodes, options) => {
+	const root = {
+		children: [],
+		ordered: nodes[0].listStyleType === "decimal",
+		spread: options.spread ?? false,
+		start: nodes[0].listStart,
+		type: "list"
+	};
+	const indentStack = [{
+		indent: nodes[0].indent,
+		list: root,
+		parent: null,
+		styleType: nodes[0].listStyleType
+	}];
+	for (let i = 0; i < nodes.length; i++) {
+		const node = nodes[i];
+		const currentIndent = node.indent;
+		while (indentStack.length > 1 && indentStack.at(-1).indent > currentIndent) indentStack.pop();
+		let stackTop = indentStack.at(-1);
+		if (stackTop.indent === currentIndent && stackTop.styleType !== node.listStyleType && !!stackTop.parent) {
+			const siblingList = {
+				children: [],
+				ordered: node.listStyleType === "decimal",
+				spread: options.spread ?? false,
+				start: node.listStart,
+				type: "list"
+			};
+			stackTop.parent.children.push(siblingList);
+			indentStack[indentStack.length - 1] = {
+				indent: currentIndent,
+				list: siblingList,
+				parent: stackTop.parent,
+				styleType: node.listStyleType
+			};
+			stackTop = indentStack.at(-1);
+		}
+		const paragraph = {
+			children: convertNodesWithSource(node.children, options),
+			type: "paragraph"
+		};
+		attachSource(paragraph, buildSource(node, options.editor));
+		const listItem = {
+			checked: null,
+			children: [paragraph],
+			spread: options.spread ?? false,
+			type: "listItem"
+		};
+		if (node.listStyleType === "todo" && node.checked !== void 0) listItem.checked = node.checked;
+		stackTop.list.children.push(listItem);
+		const nextNode = nodes[i + 1];
+		if (nextNode && nextNode.indent > currentIndent) {
+			const nestedList = {
+				children: [],
+				ordered: nextNode.listStyleType === "decimal",
+				spread: options.spread ?? false,
+				start: nextNode.listStart,
+				type: "list"
+			};
+			listItem.children.push(nestedList);
+			indentStack.push({
+				indent: nextNode.indent,
+				list: nestedList,
+				parent: listItem,
+				styleType: nextNode.listStyleType
+			});
+		}
+	}
+	return root;
+};
+const collectExtensionHandlers = (extensions, into) => {
+	if (!extensions) return into;
+	for (const ext of extensions) {
+		if (!ext) continue;
+		if (Array.isArray(ext)) {
+			collectExtensionHandlers(ext, into);
+			continue;
+		}
+		if (Array.isArray(ext.extensions)) collectExtensionHandlers(ext.extensions, into);
+		if (ext.handlers) Object.assign(into, ext.handlers);
+	}
+	return into;
+};
+/**
+* Strip `handlers` from extension objects so that `toMarkdown`'s `configure()`
+* won't overwrite our wrapped handlers while keeping `unsafe`, `join`, etc.
+*/
+const stripExtensionHandlers = (extensions) => extensions.map((ext) => {
+	if (!ext) return ext;
+	if (Array.isArray(ext)) return stripExtensionHandlers(ext);
+	if (typeof ext !== "object") return ext;
+	const { handlers: _h, ...rest } = ext;
+	if (Array.isArray(rest.extensions)) rest.extensions = stripExtensionHandlers(rest.extensions);
+	return rest;
+});
+const serializeMdWithSourceMap = (editor, options) => {
+	const mergedOptions = getMergedOptionsSerialize(editor, options);
+	const mdast = {
+		children: convertNodesWithSource((mergedOptions.value ?? editor.children).map((child, index) => annotatePaths(child, [index])), mergedOptions, true),
+		type: "root"
+	};
+	const extensionProcessor = unified().use(mergedOptions.remarkPlugins ?? []);
+	try {
+		extensionProcessor.freeze();
+	} catch {}
+	const extensions = extensionProcessor.data("toMarkdownExtensions") ?? [];
+	const handlers = { ...defaultHandlers };
+	collectExtensionHandlers(extensions, handlers);
+	const segments = [];
+	const wrappedHandlers = {};
+	const pushSegment = (source, emitted, startLine, endLine) => {
+		segments.push({
+			containsMdx: source.containsMdx,
+			endLine,
+			kind: source.kind,
+			markdown: emitted,
+			nodeId: source.nodeId,
+			path: source.path,
+			pathKey: source.pathKey,
+			startLine,
+			text: source.text
+		});
+	};
+	for (const [type, handler] of Object.entries(handlers)) wrappedHandlers[type] = (node, parent, state, info) => {
+		const startLine = info.now.line;
+		const emitted = handler(node, parent, state, info);
+		const source = node?.data?.sourceMap;
+		if (source && emitted.trim()) pushSegment(source, emitted, startLine, startLine + (emitted.split(/\r?\n|\r/g).length - 1));
+		if (type === "table" && Array.isArray(node?.children)) for (let r = 0; r < node.children.length; r++) {
+			const line = r === 0 ? startLine : startLine + 1 + r;
+			const cells = node.children[r]?.children;
+			if (!Array.isArray(cells)) continue;
+			for (const cell of cells) {
+				const cellSource = cell?.data?.sourceMap;
+				if (cellSource) pushSegment(cellSource, emitted, line, line);
+			}
+		}
+		return emitted;
+	};
+	const markdown = toMarkdown(mdast, {
+		emphasis: "_",
+		...mergedOptions.remarkStringifyOptions ?? {},
+		extensions: stripExtensionHandlers(extensions),
+		handlers: wrappedHandlers
+	});
+	const deduped = /* @__PURE__ */ new Map();
+	for (const seg of segments) {
+		const existing = deduped.get(seg.pathKey);
+		const span = seg.endLine - seg.startLine;
+		const existingSpan = existing ? existing.endLine - existing.startLine : Number.POSITIVE_INFINITY;
+		if (!existing || span <= existingSpan) deduped.set(seg.pathKey, seg);
+	}
+	const ordered = Array.from(deduped.values()).sort((a, b) => comparePaths(a.path, b.path));
+	return {
+		allSegments: ordered,
+		markdown,
+		segments: ordered.filter((seg) => !ordered.some((other) => other !== seg && isPathPrefix(seg.path, other.path)))
+	};
+};
+
+//#endregion
+//#region src/lib/serializer/resolveSelectionLines.ts
+const MDX_TAG_RE = /<[a-zA-Z_][\w.-]*/;
+/** `a` is an ancestor-or-self of `b`: a's path is a prefix of (or equal to) b's. */
+const isAncestorOrSelf = (a, b) => a.length <= b.length && a.every((v, i) => b[i] === v);
+const comparePoints = (a, b) => {
+	const len = Math.max(a.path.length, b.path.length);
+	for (let i = 0; i < len; i++) {
+		const av = a.path[i] ?? 0;
+		const bv = b.path[i] ?? 0;
+		if (av !== bv) return av - bv;
+	}
+	return a.offset - b.offset;
+};
+/**
+* Find the segment covering the start of a selection at `path`.
+*
+* 1. Ancestor-or-self: segment whose path is a prefix of `path` (most specific wins)
+* 2. First descendant: `path` is a prefix of segment's path (container selection)
+*/
+const findStartSegment = (segments, path) => {
+	let best = null;
+	let bestLen = -1;
+	for (const seg of segments) if (isAncestorOrSelf(seg.path, path) && seg.path.length > bestLen) {
+		best = seg;
+		bestLen = seg.path.length;
+	}
+	if (best) return best;
+	for (const seg of segments) if (isAncestorOrSelf(path, seg.path)) return seg;
+	return null;
+};
+/**
+* Find the segment covering the end of a selection at `path`.
+*
+* Same as findStartSegment but for descendant matches picks the LAST one
+* (the container's last child segment).
+*/
+const findEndSegment = (segments, path) => {
+	let best = null;
+	let bestLen = -1;
+	for (const seg of segments) if (isAncestorOrSelf(seg.path, path) && seg.path.length > bestLen) {
+		best = seg;
+		bestLen = seg.path.length;
+	}
+	if (best) return best;
+	let last = null;
+	for (const seg of segments) if (isAncestorOrSelf(path, seg.path)) last = seg;
+	return last;
+};
+/** Recursively compute the total text length of a Slate node. */
+const getTextLength = (node) => {
+	if (typeof node?.text === "string") return node.text.length;
+	if (Array.isArray(node?.children)) return node.children.reduce((sum, child) => sum + getTextLength(child), 0);
+	return 0;
+};
+/** Walk the editor tree to reach the node at `path`. */
+const getNodeAtPath = (editor, path) => {
+	let node = { children: editor.children };
+	for (const idx of path) {
+		if (!node?.children?.[idx]) return null;
+		node = node.children[idx];
+	}
+	return node;
+};
+/**
+* Compute the absolute character offset within a segment's text.
+*
+* Given a segment at `segPath` (e.g. [1,3,0] = a paragraph) and a selection
+* point at `selPath` (e.g. [1,3,0,1] = second text node) with `selOffset`,
+* sum up text lengths of all Slate nodes preceding the selection point within
+* the segment, then add `selOffset`.
+*/
+const computeAbsoluteOffset = (editor, segPath, selPath, selOffset) => {
+	const segNode = getNodeAtPath(editor, segPath);
+	if (!segNode) return null;
+	const remainingPath = selPath.slice(segPath.length);
+	if (remainingPath.length === 0) {
+		let textOffset = 0;
+		const children = segNode.children ?? [];
+		for (let i = 0; i < Math.min(selOffset, children.length); i++) textOffset += getTextLength(children[i]);
+		return textOffset;
+	}
+	let current = segNode;
+	let accumulated = 0;
+	for (const childIdx of remainingPath) {
+		const children = current.children ?? [];
+		for (let i = 0; i < childIdx && i < children.length; i++) accumulated += getTextLength(children[i]);
+		if (!children[childIdx]) return null;
+		current = children[childIdx];
+	}
+	return accumulated + selOffset;
+};
+/**
+* Given a segment and an absolute text offset, determine which line within
+* the segment the offset falls on.
+*/
+const offsetToLine = (segText, segStartLine, absOffset) => {
+	const clamped = Math.max(0, Math.min(absOffset, segText.length));
+	return segStartLine + (segText.slice(0, clamped).match(/\n/g) ?? []).length;
+};
+/**
+* Whether a segment supports sub-line narrowing. Only for kinds where text
+* content lines map 1:1 to markdown output lines (no structural wrappers
+* like code fences, MDX tags, or table delimiters).
+*/
+const NARROWABLE_KINDS = new Set([
+	"paragraph",
+	"heading",
+	"list_item",
+	"blockquote"
+]);
+const canNarrow = (seg) => NARROWABLE_KINDS.has(seg.kind);
+const extractLines = (md, start, end) => md.split("\n").slice(start - 1, end).join("\n");
+/**
+* Resolve which markdown lines correspond to a Plate editor selection
+* using the source-map path mapping (no text matching).
+*
+* 1. Serializes editor to markdown with source-map segments
+* 2. Finds the segment matching the anchor path (longest prefix)
+* 3. Finds the segment matching the focus path
+* 4. Narrows to sub-line precision using selection offsets
+* 5. Returns the line range and extracted markdown
+*/
+/**
+* When the selection lands on a container path (e.g. clicking an MDX label),
+* look up the container segment in `allSegments` to include the MDX wrapper
+* lines (opening/closing tags) rather than just the inner content.
+*/
+const tryContainerExpand = ({ allSegments, leafSeg, selPath, currentLine, direction }) => {
+	if (!leafSeg) return currentLine;
+	if (selPath.length >= leafSeg.path.length) return currentLine;
+	let containerSeg = null;
+	let containerLen = -1;
+	for (const seg of allSegments) if (isAncestorOrSelf(seg.path, selPath) && seg.path.length > containerLen && seg !== leafSeg) {
+		containerSeg = seg;
+		containerLen = seg.path.length;
+	}
+	for (const seg of allSegments) if (seg.path.length === selPath.length && seg.path.every((v, i) => selPath[i] === v)) {
+		containerSeg = seg;
+		break;
+	}
+	if (!containerSeg) return currentLine;
+	return direction === "start" ? Math.min(currentLine, containerSeg.startLine) : Math.max(currentLine, containerSeg.endLine);
+};
+const resolveSelectionByPath = (editor, selection, options) => {
+	const { allSegments, markdown, segments } = serializeMdWithSourceMap(editor, options);
+	const [start, end] = comparePoints(selection.anchor, selection.focus) <= 0 ? [selection.anchor, selection.focus] : [selection.focus, selection.anchor];
+	const startSeg = findStartSegment(segments, start.path);
+	const endSeg = findEndSegment(segments, end.path);
+	if (!startSeg && !endSeg) return {
+		containsMdx: false,
+		endLine: 1,
+		extractedMarkdown: "",
+		markdown,
+		segments,
+		startLine: 1
+	};
+	let startLine = startSeg?.startLine ?? endSeg.startLine;
+	let endLine = endSeg?.endLine ?? startSeg.endLine;
+	if (startSeg && startSeg.endLine > startSeg.startLine && canNarrow(startSeg)) {
+		const absOffset = computeAbsoluteOffset(editor, startSeg.path, start.path, start.offset);
+		if (absOffset !== null) startLine = offsetToLine(startSeg.text, startSeg.startLine, absOffset);
+	}
+	if (endSeg && endSeg.endLine > endSeg.startLine && canNarrow(endSeg)) {
+		const absOffset = computeAbsoluteOffset(editor, endSeg.path, end.path, end.offset);
+		if (absOffset !== null) endLine = offsetToLine(endSeg.text, endSeg.startLine, absOffset);
+	}
+	startLine = tryContainerExpand({
+		allSegments,
+		currentLine: startLine,
+		direction: "start",
+		leafSeg: startSeg,
+		selPath: start.path
+	});
+	endLine = tryContainerExpand({
+		allSegments,
+		currentLine: endLine,
+		direction: "end",
+		leafSeg: endSeg,
+		selPath: end.path
+	});
+	if (startLine > endLine) [startLine, endLine] = [endLine, startLine];
+	const extractedMarkdown = extractLines(markdown, startLine, endLine);
+	return {
+		containsMdx: extractedMarkdown.includes("<") && MDX_TAG_RE.test(extractedMarkdown),
+		endLine,
+		extractedMarkdown,
+		markdown,
+		segments,
+		startLine
+	};
+};
 
 //#endregion
 //#region src/lib/serializer/serializeInlineMd.ts
@@ -1934,4 +2552,4 @@ const remarkMention = () => (tree) => {
 };
 
 //#endregion
-export { MarkdownPlugin, REMARK_MDX_TAG, basicMarkdownMarks, buildMdastNode, buildRules, buildSlateNode, columnRules, convertChildrenDeserialize, convertNodesDeserialize, convertNodesSerialize, convertTextsDeserialize, convertTextsSerialize, customMdxDeserialize, defaultRules, deserializeInlineMd, deserializeMd, fontRules, getCustomMark, getDeserializerByKey, getMergedOptionsDeserialize, getMergedOptionsSerialize, getRemarkPluginsWithoutMdx, getSerializerByKey, getStyleValue, htmlToJsx, listToMdastTree, markdownToAstProcessor, markdownToSlateNodes, markdownToSlateNodesSafely, mdastToPlate, mdastToSlate, mediaRules, parseAttributes, parseMarkdownBlocks, plateToMdast, propsToAttributes, remarkMdx, remarkMention, serializeInlineMd, serializeMd, splitIncompleteMdx, stripMarkdown, stripMarkdownBlocks, stripMarkdownInline, tagRemarkPlugin, unreachable, wrapWithBlockId };
+export { MarkdownPlugin, REMARK_MDX_TAG, basicMarkdownMarks, buildMdastNode, buildRules, buildSlateNode, columnRules, convertChildrenDeserialize, convertNodesDeserialize, convertNodesSerialize, convertTextsDeserialize, convertTextsSerialize, customMdxDeserialize, defaultRules, deserializeInlineMd, deserializeMd, fontRules, getCustomMark, getDeserializerByKey, getMergedOptionsDeserialize, getMergedOptionsSerialize, getRemarkPluginsWithoutMdx, getSerializerByKey, getStyleValue, htmlToJsx, listToMdastTree, markdownToAstProcessor, markdownToSlateNodes, markdownToSlateNodesSafely, mdastToPlate, mdastToSlate, mediaRules, parseAttributes, parseMarkdownBlocks, plateToMdast, propsToAttributes, remarkMdx, remarkMention, resolveSelectionByPath, serializeInlineMd, serializeMd, serializeMdWithSourceMap, splitIncompleteMdx, stripMarkdown, stripMarkdownBlocks, stripMarkdownInline, tagRemarkPlugin, unreachable, wrapWithBlockId };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lofcz/platejs-markdown",
-  "version": "52.3.6",
+  "version": "52.3.9",
   "description": "Markdown serializer plugin for Plate",
   "keywords": [
     "markdown",
@@ -33,6 +33,7 @@
   "dependencies": {
     "lodash": "^4.17.23",
     "marked": "^15.0.12",
+    "mdast-util-to-markdown": "^2.1.2",
     "mdast-util-math": "3.0.0",
     "mdast-util-mdx": "3.0.0",
     "react-compiler-runtime": "^1.0.0",
@@ -48,8 +49,8 @@
     "@types/unist": "^3.0.3",
     "remark-gfm": "4.0.1",
     "remark-math": "6.0.0",
-    "@plate/scripts": "1.0.0",
-    "platejs": "npm:@lofcz/platejs@52.3.6"
+    "platejs": "npm:@lofcz/platejs@52.3.6",
+    "@plate/scripts": "1.0.0"
   },
   "peerDependencies": {
     "platejs": ">=52.0.11",