@lofcz/platejs-markdown 52.3.6 → 52.3.8

package/dist/index.d.ts

@@ -43,6 +43,26 @@ declare function listToMdastTree(nodes: TListElement[], options: SerializeMdOpti
 //#region src/lib/serializer/serializeInlineMd.d.ts
 declare const serializeInlineMd: (editor: SlateEditor, options?: SerializeMdOptions) => string;
 //#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 = {
+  markdown: string;
+  segments: MarkdownSourceMapSegment[];
+};
+declare const serializeMdWithSourceMap: (editor: SlateEditor, options?: Omit<SerializeMdOptions, "editor">) => SerializeMdSourceMapResult;
+//#endregion
 //#region src/lib/serializer/wrapWithBlockId.d.ts
 /**
  * Wraps an mdast node with a block element containing an ID attribute. Used for
@@ -494,4 +514,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, 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, serializeInlineMd, serializeMd, serializeMdWithSourceMap, splitIncompleteMdx, stripMarkdown, stripMarkdownBlocks, stripMarkdownInline, tagRemarkPlugin, type unistLib, unreachable, wrapWithBlockId };

package/dist/index.js

@@ -3,6 +3,7 @@ import "mdast-util-mdx";
 import kebabCase from "lodash/kebabCase.js";
 import remarkStringify from "remark-stringify";
 import { unified } from "unified";
+import { defaultHandlers, toMarkdown } from "mdast-util-to-markdown";
 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,7 +632,7 @@ const buildMdastNode = (node, options, isBlock = false) => {
 	}
 	unreachable(node);
 };
-const shouldIncludeText = (text, options) => {
+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)) {
@@ -643,7 +644,7 @@ const shouldIncludeText = (text, options) => {
 	if (allowNode?.serialize) return allowNode.serialize(text);
 	return true;
 };
-const shouldIncludeNode$1 = (node, options) => {
+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");
@@ -693,6 +694,363 @@ const slateToMdast = ({ children, options }) => {
 	};
 };
 
+//#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);
+	if (!text.trim() && kind !== "media" && kind !== "block") return null;
+	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");
+	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$1 = (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;
+};
+/**
+* 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);
+		}
+	}
+};
+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);
+	if (!source) {
+		if (mdastNode && MDX_MDAST_TYPES.has(mdastNode.type ?? "")) propagateMdxFlag(mdastNode);
+		return mdastNode;
+	}
+	if (MDX_MDAST_TYPES.has(mdastNode?.type ?? "")) {
+		source.containsMdx = true;
+		if (Array.isArray(mdastNode?.children)) for (const child of mdastNode.children) propagateMdxFlag(child);
+	}
+	if (source.kind === "blockquote" && Array.isArray(mdastNode?.children) && mdastNode.children[0]) {
+		attachSource(mdastNode.children[0], source);
+		return mdastNode;
+	}
+	return attachSource(mdastNode, source);
+};
+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 {
+		markdown,
+		segments: ordered.filter((seg) => !ordered.some((other) => other !== seg && isPathPrefix(seg.path, other.path)))
+	};
+};
+
 //#endregion
 //#region src/lib/rules/defaultRules.ts
 const LEADING_NEWLINE_REGEX = /^\n/;
@@ -1934,4 +2292,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, 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.8",
   "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",