markdown2typst 0.1.6 → 0.1.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "markdown2typst",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "A comprehensive JavaScript library for converting Markdown to Typst code",
   "type": "module",
   "main": "./dist/markdown2typst.js",

package/src/block-renderer.ts

@@ -97,22 +97,8 @@ export function renderBlock(
  * @returns Rendered Typst math block
  */
 function renderMathBlock(node: MathNode, indentLevel: number, context: RenderContext): string {
-	// Reconstruct the full LaTeX string.
-	// If a LaTeX environment is adjacent to $$, remark-math treats the adjacent text as `meta`,
-	// and may absorb the trailing $$ into `value` if it's on the same line as the environment closure.
-	let rawLatex = node.value || '';
-	const meta = (node as any).meta;
-	if (meta) {
-		rawLatex = meta + (rawLatex ? '\n' + rawLatex : '');
-	}
-
-	// Check if the closing $$ was absorbed into the value
-	if (rawLatex.endsWith('$$')) {
-		rawLatex = rawLatex.slice(0, -2);
-	}
-
 	// Convert LaTeX to Typst math syntax
-	const value = rawLatex.trim();
+	const value = node.value.trim();
 	try {
 		const typstMath = tex2typst(value);
 		return indentLines(`$ ${typstMath} $`, indentLevel);

package/src/parser.ts

@@ -8,6 +8,7 @@ import remarkFrontmatter from 'remark-frontmatter';
 import remarkGfm from 'remark-gfm';
 import remarkMath from 'remark-math';
 import remarkParse from 'remark-parse';
+import { remarkFixAdjacentMath } from './remark-fix-math.js';
 import type { Root } from 'mdast';
 import type { ErrorCallback } from './types.js';
 import { ErrorSeverity } from './types.js';
@@ -31,7 +32,8 @@ export function parseMarkdown(markdown: string, onError?: ErrorCallback): Root {
 			.use(remarkParse)
 			.use(remarkFrontmatter, ['yaml'])
 			.use(remarkGfm, { singleTilde: false })
-			.use(remarkMath);
+			.use(remarkMath)
+			.use(remarkFixAdjacentMath);
 
 		const parsedTree = processor.parse(markdown);
 		const tree = processor.runSync(parsedTree) as Root;

package/src/remark-fix-math.ts

@@ -0,0 +1,68 @@
+import { visit } from 'unist-util-visit';
+import { unified } from 'unified';
+import remarkParse from 'remark-parse';
+import remarkMath from 'remark-math';
+import remarkGfm from 'remark-gfm';
+
+/**
+ * Remark plugin to fix math blocks that swallowed adjacent text because 
+ * of a missing newline before the closing $$.
+ */
+export function remarkFixAdjacentMath() {
+	return (tree: any) => {
+		// First pass: fix the nodes and store the extracted nodes
+		visit(tree, 'math', (node: any) => {
+			let value = node.value || '';
+			const meta = node.meta;
+			
+			// Reconstruct the full string because remark-math treats adjacent text as meta
+			if (meta) {
+				value = meta + (value ? '\n' + value : '');
+				node.meta = null; // Clear meta since it was actually part of the math
+			}
+			
+			// Look for the first occurrence of $$ in the value
+			const match = value.match(/\$\$/);
+			
+			if (match) {
+				// Found a stray $$ inside the math block!
+				// This means the math block swallowed the closing delimiter and everything after it.
+				
+				const splitIndex = match.index;
+				const mathContent = value.substring(0, splitIndex);
+				const remainder = value.substring(splitIndex + 2); // skip $$
+				
+				// Fix the math node
+				node.value = mathContent.trim();
+				
+				// We need to append the remainder as new parsed markdown nodes after this node
+				if (remainder.trim().length > 0) {
+					// Parse the remainder with full features
+					const processor = unified()
+						.use(remarkParse)
+						.use(remarkGfm, { singleTilde: false })
+						.use(remarkMath)
+						// Notice we also recursively apply this plugin in case the remainder has more adjacent math
+						.use(remarkFixAdjacentMath);
+					
+					const remainderAst = processor.parse(remainder.trim());
+					const remainderTree = processor.runSync(remainderAst);
+					
+					// Store the nodes to be inserted
+					node.data = node.data || {};
+					node.data.insertAfter = (remainderTree as any).children;
+				}
+			} else {
+				node.value = value.trim();
+			}
+		});
+
+		// Second pass: insert the extracted nodes
+		visit(tree, (node: any, index: number | undefined, parent: any) => {
+			if (node.data && node.data.insertAfter && parent && index !== undefined) {
+				parent.children.splice(index + 1, 0, ...node.data.insertAfter);
+				delete node.data.insertAfter;
+			}
+		});
+	};
+}