@lofcz/platejs-markdown 53.1.1 → 53.1.4

package/dist/index.d.ts

@@ -77,9 +77,60 @@ type ResolveSelectionByPathResult = {
   endLine: number;
   extractedMarkdown: string;
   markdown: string;
+  /**
+   * `false` when neither endpoint of the selection mapped to any segment
+   * (e.g. stale paths after a concurrent edit). The line numbers in this
+   * case are placeholders (1, 1) and the extracted markdown is empty.
+   * Callers must check this flag before using the result; the previous
+   * silent default produced invalid line-1 references.
+   */
+  resolved: boolean;
   segments: MarkdownSourceMapSegment[];
   startLine: number;
 };
+/**
+ * Order two Slate selection points in document order.
+ *
+ * Slate selection points come in two flavours that previously got compared
+ * incompatibly:
+ *
+ * - *Element-level*: `path` ends at an element, `offset` is the boundary
+ *   index between its children (0 = before the first child, N = after the
+ *   N-th child).
+ * - *Leaf-level*: `path` descends into a text leaf, `offset` is a character
+ *   index within that text.
+ *
+ * The previous implementation padded the shorter path with `0`s and then
+ * fell back to comparing offsets — which only works when both points are
+ * at the same depth. For mixed-depth points like `[3] offset 2`
+ * (≈ "before child 2 of [3]") vs `[3, 1] offset 5` (≈ "inside child 1 of
+ * [3]"), it returned the wrong order silently because the offsets are not
+ * commensurate.
+ *
+ * Fix: when the shorter point is element-level, expand it to the leaf-level
+ * coordinate space by treating its offset as the next path step ("before
+ * child `offset`"), then continue path comparison. Offsets are only
+ * compared when both points are at identical depth.
+ */
+declare const comparePoints: (a: SelectionPoint, b: SelectionPoint) => number;
+/**
+ * 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)
+ */
+declare const findStartSegment: (segments: MarkdownSourceMapSegment[], path: number[]) => MarkdownSourceMapSegment | null;
+/**
+ * Find the segment covering the end of a selection at `path`.
+ *
+ * Same as findStartSegment but for descendant matches picks the segment
+ * with the LARGEST `endLine` (the container's deepest/latest child
+ * segment). The previous implementation returned the last segment by
+ * iteration order, which only happened to work because `allSegments` is
+ * sorted by path today — any caller passing an unsorted array would
+ * silently get the wrong range end.
+ */
+declare const findEndSegment: (segments: MarkdownSourceMapSegment[], path: number[]) => MarkdownSourceMapSegment | null;
 declare const resolveSelectionByPath: (editor: SlateEditor, selection: SelectionRange, options?: Omit<SerializeMdOptions, "editor">) => ResolveSelectionByPathResult;
 //#endregion
 //#region src/lib/serializer/serializeInlineMd.d.ts
@@ -536,4 +587,4 @@ declare const tagRemarkPlugin: (pluginFn: any, tag: string) => {
 };
 declare const getRemarkPluginsWithoutMdx: (plugins: Plugin[]) => Plugin[];
 //#endregion
-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 };
+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, comparePoints, convertChildrenDeserialize, convertNodesDeserialize, convertNodesSerialize, convertTextsDeserialize, convertTextsSerialize, customMdxDeserialize, defaultRules, deserializeInlineMd, deserializeMd, findEndSegment, findStartSegment, 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

@@ -115,25 +115,50 @@ const getCustomMark = (options) => {
 //#region src/lib/rules/utils/parseAttributes.ts
 function parseAttributes(attributes) {
 	const props = {};
-	if (attributes && attributes.length > 0) attributes.forEach((attr) => {
-		if (attr.name && attr.value !== void 0) {
-			let value = attr.value;
+	if (!attributes || attributes.length === 0) return props;
+	for (const attr of attributes) {
+		if (!attr?.name) continue;
+		const raw = attr.value;
+		if (raw === void 0) continue;
+		if (raw === null) {
+			props[attr.name] = true;
+			continue;
+		}
+		if (typeof raw === "object") {
+			props[attr.name] = raw;
+			continue;
+		}
+		if (typeof raw === "string") {
 			try {
-				value = JSON.parse(attr.value);
-			} catch (_error) {
-				value = attr.value;
+				props[attr.name] = JSON.parse(raw);
+			} catch {
+				props[attr.name] = raw;
 			}
-			props[attr.name] = value;
+			continue;
 		}
-	});
+		props[attr.name] = raw;
+	}
 	return props;
 }
 function propsToAttributes(props) {
-	return Object.entries(props).map(([name, value]) => ({
-		name,
-		type: "mdxJsxAttribute",
-		value: typeof value === "string" || value?.type === "mdxJsxAttributeValueExpression" ? value : JSON.stringify(value)
-	}));
+	const out = [];
+	for (const [name, value] of Object.entries(props)) {
+		if (value === void 0 || value === null) continue;
+		if (value === true) {
+			out.push({
+				name,
+				type: "mdxJsxAttribute",
+				value: null
+			});
+			continue;
+		}
+		out.push({
+			name,
+			type: "mdxJsxAttribute",
+			value: typeof value === "string" || value?.type === "mdxJsxAttributeValueExpression" ? value : JSON.stringify(value)
+		});
+	}
+	return out;
 }
 
 //#endregion
@@ -519,12 +544,14 @@ function listToMdastTree(nodes, options, isBlock = false) {
 			};
 			stackTop = indentStack.at(-1);
 		}
+		const listItemParagraph = {
+			children: convertNodesSerialize(node.children, options),
+			type: "paragraph"
+		};
+		if (Array.isArray(node.__sourceMapPath)) listItemParagraph.__sourceMapSlatePath = node.__sourceMapPath;
 		const listItem = {
 			checked: null,
-			children: [{
-				children: convertNodesSerialize(node.children, options),
-				type: "paragraph"
-			}],
+			children: [listItemParagraph],
 			spread: options.spread ?? false,
 			type: "listItem"
 		};
@@ -565,12 +592,14 @@ function processListWithBlockIds(nodes, options) {
 			start: node.listStyleType === "decimal" ? i + 1 : void 0,
 			type: "list"
 		};
+		const singleParagraph = {
+			children: convertNodesSerialize(node.children, options),
+			type: "paragraph"
+		};
+		if (Array.isArray(node.__sourceMapPath)) singleParagraph.__sourceMapSlatePath = node.__sourceMapPath;
 		const listItem = {
 			checked: null,
-			children: [{
-				children: convertNodesSerialize(node.children, options),
-				type: "paragraph"
-			}],
+			children: [singleParagraph],
 			spread: options.spread ?? false,
 			type: "listItem"
 		};
@@ -621,6 +650,23 @@ const convertNodesSerialize = (nodes, options, isBlock = false) => {
 	}
 	return mdastNodes;
 };
+/**
+* Mirror the Slate `__sourceMapPath` annotation onto the produced mdast node.
+*
+* This breadcrumb lets `attachDescendantSources` (in
+* `serializeMdWithSourceMap`) match mdast children back to their originating
+* Slate child by *path* instead of by array position. Without it, any custom
+* MDX serializer that injects, drops, or reorders mdast children would
+* silently shift the source-map zipper and assign each Slate child the line
+* range of a different mdast node.
+*
+* The property is a plain own-property on the mdast object — invisible to
+* `mdast-util-to-markdown`, which only consumes the documented mdast fields.
+*/
+const tagWithSlatePath = (mdastNode, slateNode) => {
+	if (mdastNode && typeof mdastNode === "object" && Array.isArray(slateNode?.__sourceMapPath)) mdastNode.__sourceMapSlatePath = slateNode.__sourceMapPath;
+	return mdastNode;
+};
 const buildMdastNode = (node, options, isBlock = false) => {
 	const editor = options.editor;
 	let key = getPluginKey(editor, node.type) ?? node.type;
@@ -629,8 +675,8 @@ const buildMdastNode = (node, options, isBlock = false) => {
 	const nodeParser = getSerializerByKey(key, options);
 	if (nodeParser) {
 		const mdastNode = nodeParser(node, options);
-		if (options.withBlockId && node.id && isBlock) return wrapWithBlockId(mdastNode, node.id);
-		return mdastNode;
+		if (options.withBlockId && node.id && isBlock) return tagWithSlatePath(wrapWithBlockId(mdastNode, node.id), node);
+		return tagWithSlatePath(mdastNode, node);
 	}
 	unreachable(node);
 };
@@ -723,6 +769,9 @@ const slateNodeKind = (node, editor) => {
 	const pType = getPluginType(editor, KEYS.p) ?? KEYS.p;
 	if (node.type === pType) return "paragraph";
 	if (SEGMENT_SKIP_TYPES.has(key)) return null;
+	try {
+		if (editor?.api?.isInline?.(node)) return null;
+	} catch {}
 	if (Array.isArray(node.children)) return "block";
 	return null;
 };
@@ -805,14 +854,23 @@ const attachTableCellSources = (mdastTable, slateTable, editor) => {
 * to zip them correctly.
 */
 const attachListSources = (mdastList, slateListItems, editor, insideMdx) => {
+	const slateByPath = /* @__PURE__ */ new Map();
+	for (const item of slateListItems) if (Array.isArray(item?.__sourceMapPath)) slateByPath.set(toPathKey(item.__sourceMapPath), item);
 	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++];
+			for (const child of listItem.children) {
+				if (child.type === "list") {
+					walkList(child);
+					continue;
+				}
+				const taggedPath = child.__sourceMapSlatePath;
+				let slateChild = null;
+				if (Array.isArray(taggedPath)) slateChild = slateByPath.get(toPathKey(taggedPath)) ?? null;
+				if (!slateChild && slateIdx < slateListItems.length) slateChild = slateListItems[slateIdx++];
+				if (!slateChild) continue;
 				const source = buildSource(slateChild, editor);
 				if (source) {
 					if (insideMdx) source.containsMdx = true;
@@ -823,35 +881,78 @@ const attachListSources = (mdastList, slateListItems, editor, insideMdx) => {
 	};
 	walkList(mdastList);
 };
+/**
+* Count the number of Slate list-paragraph slots a mdast list tree needs.
+*
+* Each non-`list` child of a `listItem` corresponds to exactly one Slate
+* list paragraph; nested `list` nodes recurse. This lets us consume exactly
+* the right slice of consecutive Slate list paragraphs for a given mdast
+* list, instead of greedily swallowing every list-styled Slate sibling.
+*/
+const countMdastListSlots = (list) => {
+	if (!list || !Array.isArray(list.children)) return 0;
+	let count = 0;
+	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") count += countMdastListSlots(child);
+		else count += 1;
+	}
+	return count;
+};
+const pathsEqual = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
 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");
+	const consumedSlateIndices = /* @__PURE__ */ new Set();
+	const attachSingleByMdast = (mdastChild, slateChild) => {
+		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);
+	};
+	for (const mdastChild of mdastChildren) {
+		if (!mdastChild || !mdastChild.type || mdastChild.type === "text") continue;
+		const taggedPath = mdastChild.__sourceMapSlatePath;
+		if (!Array.isArray(taggedPath)) continue;
+		const slateIdx = slateElements.findIndex((c) => Array.isArray(c.__sourceMapPath) && pathsEqual(c.__sourceMapPath, taggedPath));
+		if (slateIdx === -1) continue;
+		consumedSlateIndices.add(slateIdx);
+		attachSingleByMdast(mdastChild, slateElements[slateIdx]);
+	}
 	let si = 0;
-	for (const mdastChild of mdastElements) {
+	const advanceToUnconsumed = () => {
+		while (si < slateElements.length && consumedSlateIndices.has(si)) si++;
+	};
+	for (const mdastChild of mdastChildren) {
+		if (!mdastChild || !mdastChild.type || mdastChild.type === "text") continue;
+		if (Array.isArray(mdastChild.__sourceMapSlatePath)) continue;
 		if (mdastChild.type === "list") {
+			const slotsNeeded = countMdastListSlots(mdastChild);
 			const listRun = [];
-			while (si < slateElements.length && slateElements[si].listStyleType) {
+			for (let k = 0; k < slotsNeeded; k++) {
+				advanceToUnconsumed();
+				if (si >= slateElements.length) break;
+				if (!slateElements[si].listStyleType) break;
 				listRun.push(slateElements[si]);
+				consumedSlateIndices.add(si);
 				si++;
 			}
 			attachListSources(mdastChild, listRun, editor, insideMdx);
 			continue;
 		}
+		advanceToUnconsumed();
 		if (si >= slateElements.length) break;
 		const slateChild = slateElements[si];
+		consumedSlateIndices.add(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);
+		attachSingleByMdast(mdastChild, slateChild);
 	}
 };
 const buildMdastNodeWithSource = (node, options, isBlock = false) => {
@@ -1048,7 +1149,7 @@ const serializeMdWithSourceMap = (editor, options) => {
 		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 (source && emitted.trim()) pushSegment(source, emitted, startLine, startLine + (emitted.replace(/(?:\r?\n|\r)+$/g, "").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;
@@ -1086,14 +1187,44 @@ const serializeMdWithSourceMap = (editor, options) => {
 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);
+/**
+* Order two Slate selection points in document order.
+*
+* Slate selection points come in two flavours that previously got compared
+* incompatibly:
+*
+* - *Element-level*: `path` ends at an element, `offset` is the boundary
+*   index between its children (0 = before the first child, N = after the
+*   N-th child).
+* - *Leaf-level*: `path` descends into a text leaf, `offset` is a character
+*   index within that text.
+*
+* The previous implementation padded the shorter path with `0`s and then
+* fell back to comparing offsets — which only works when both points are
+* at the same depth. For mixed-depth points like `[3] offset 2`
+* (≈ "before child 2 of [3]") vs `[3, 1] offset 5` (≈ "inside child 1 of
+* [3]"), it returned the wrong order silently because the offsets are not
+* commensurate.
+*
+* Fix: when the shorter point is element-level, expand it to the leaf-level
+* coordinate space by treating its offset as the next path step ("before
+* child `offset`"), then continue path comparison. Offsets are only
+* compared when both points are at identical depth.
+*/
 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;
+	const aPath = a.path;
+	const bPath = b.path;
+	const aLen = aPath.length;
+	const bLen = bPath.length;
+	const common = Math.min(aLen, bLen);
+	for (let i = 0; i < common; i++) if (aPath[i] !== bPath[i]) return aPath[i] - bPath[i];
+	if (aLen === bLen) return a.offset - b.offset;
+	if (aLen < bLen) {
+		if (a.offset !== bPath[common]) return a.offset - bPath[common];
+		return -1;
 	}
-	return a.offset - b.offset;
+	if (aPath[common] !== b.offset) return aPath[common] - b.offset;
+	return 1;
 };
 /**
 * Find the segment covering the start of a selection at `path`.
@@ -1115,8 +1246,12 @@ const findStartSegment = (segments, path) => {
 /**
 * 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).
+* Same as findStartSegment but for descendant matches picks the segment
+* with the LARGEST `endLine` (the container's deepest/latest child
+* segment). The previous implementation returned the last segment by
+* iteration order, which only happened to work because `allSegments` is
+* sorted by path today — any caller passing an unsorted array would
+* silently get the wrong range end.
 */
 const findEndSegment = (segments, path) => {
 	let best = null;
@@ -1126,9 +1261,12 @@ const findEndSegment = (segments, path) => {
 		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;
+	let latest = null;
+	for (const seg of segments) {
+		if (!isAncestorOrSelf(path, seg.path)) continue;
+		if (!latest || seg.endLine > latest.endLine) latest = seg;
+	}
+	return latest;
 };
 /** Recursively compute the total text length of a Slate node. */
 const getTextLength = (node) => {
@@ -1228,13 +1366,14 @@ const tryContainerExpand = ({ allSegments, leafSeg, selPath, currentLine, direct
 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);
+	const startSeg = findStartSegment(segments, start.path) ?? findStartSegment(allSegments, start.path);
+	const endSeg = findEndSegment(segments, end.path) ?? findEndSegment(allSegments, end.path);
 	if (!startSeg && !endSeg) return {
 		containsMdx: false,
 		endLine: 1,
 		extractedMarkdown: "",
 		markdown,
+		resolved: false,
 		segments,
 		startLine: 1
 	};
@@ -1269,6 +1408,7 @@ const resolveSelectionByPath = (editor, selection, options) => {
 		endLine,
 		extractedMarkdown,
 		markdown,
+		resolved: true,
 		segments,
 		startLine
 	};
@@ -2618,4 +2758,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, resolveSelectionByPath, serializeInlineMd, serializeMd, serializeMdWithSourceMap, splitIncompleteMdx, stripMarkdown, stripMarkdownBlocks, stripMarkdownInline, tagRemarkPlugin, unreachable, wrapWithBlockId };
+export { MarkdownPlugin, REMARK_MDX_TAG, basicMarkdownMarks, buildMdastNode, buildRules, buildSlateNode, columnRules, comparePoints, convertChildrenDeserialize, convertNodesDeserialize, convertNodesSerialize, convertTextsDeserialize, convertTextsSerialize, customMdxDeserialize, defaultRules, deserializeInlineMd, deserializeMd, findEndSegment, findStartSegment, 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": "53.1.1",
+  "version": "53.1.4",
   "description": "Markdown serializer plugin for Plate",
   "keywords": [
     "markdown",
@@ -52,8 +52,8 @@
     "remark-gfm": "4.0.1",
     "remark-math": "6.0.0",
     "@plate/scripts": "1.0.0",
-    "@platejs/footnote": "npm:@lofcz/platejs-footnote@53.0.0",
-    "platejs": "npm:@lofcz/platejs@53.1.1"
+    "platejs": "npm:@lofcz/platejs@53.1.1",
+    "@platejs/footnote": "npm:@lofcz/platejs-footnote@53.0.0"
   },
   "peerDependencies": {
     "platejs": ">=53.0.0",