safe-mdx 1.5.0 → 1.6.0

package/package.json

@@ -1,12 +1,18 @@
 {
   "name": "safe-mdx",
-  "version": "1.5.0",
-  "private": false,
-  "description": "Render MDX in React without eval",
-  "repository": "https://github.com/holocron-hq/safe-mdx",
+  "version": "1.6.0",
+  "description": "Render MDX in React without eval, works in Cloudflare Workers and Vercel Edge",
   "type": "module",
+  "main": "./dist/safe-mdx.js",
   "types": "./dist/safe-mdx.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/holocron-hq/safe-mdx"
+  },
+  "homepage": "https://github.com/holocron-hq/safe-mdx",
+  "bugs": "https://github.com/holocron-hq/safe-mdx/issues",
   "exports": {
+    "./package.json": "./package.json",
     ".": {
       "types": "./dist/safe-mdx.d.ts",
       "default": "./dist/safe-mdx.js"
@@ -24,15 +30,29 @@
       "browser": "./dist/html/domparser-browser.js",
       "default": "./dist/html/domparser.js"
     },
-    "./src/*": "./src/*.tsx",
-    "./package.json": "./package.json"
+    "./src": {
+      "types": "./src/safe-mdx.tsx",
+      "default": "./src/safe-mdx.tsx"
+    },
+    "./src/*": {
+      "types": "./src/*.tsx",
+      "default": "./src/*.tsx"
+    }
   },
   "files": [
     "dist",
     "src"
   ],
   "keywords": [
-    "mdx"
+    "mdx",
+    "react",
+    "server-components",
+    "rsc",
+    "safe",
+    "no-eval",
+    "cloudflare-workers",
+    "edge",
+    "markdown"
   ],
   "author": "remorses <beats.by.morse@gmail.com>",
   "license": "MIT",
@@ -59,6 +79,7 @@
     "@changesets/cli": "^2.28.1",
     "@tailwindcss/typography": "^0.5.16",
     "@tailwindcss/vite": "^4.1.11",
+    "@types/escodegen": "^0.0.10",
     "@types/estree-jsx": "^1.0.5",
     "@types/mdast": "^4.0.0",
     "@types/node": "^22.15.17",
@@ -68,12 +89,14 @@
     "@vitejs/plugin-react": "^4.7.0",
     "@vitest/coverage-v8": "^1.6.0",
     "dedent": "^1.5.1",
+    "escodegen": "^2.1.0",
     "importmap-vite-plugin": "^0.0.0",
     "mdast-util-mdx-jsx": "^3.2.0",
     "react": "^19.2.1",
     "react-dom": "^19.2.1",
     "remark-parse": "^11.0.0",
     "remark-stringify": "^11.0.0",
+    "rimraf": "^6.0.1",
     "tailwindcss": "^4.1.11",
     "typescript": "5.8.3",
     "vite": "^6.2.6",

package/src/esm-parser.test.ts

@@ -1,7 +1,7 @@
 import { expect, test, describe } from 'vitest'
-import { parseEsmImports, extractComponentInfo } from './esm-parser.js'
-import { mdxParse, extractImports, resolveModulePath } from './parse.js'
-import type { SafeMdxError } from './safe-mdx.js'
+import { parseEsmImports, extractComponentInfo } from './esm-parser.ts'
+import { mdxParse, extractImports, resolveModulePath } from './parse.ts'
+import type { SafeMdxError } from './safe-mdx.tsx'
 
 describe('parseEsmImports', () => {
     test('parses default imports from HTTPS URLs', () => {

package/src/esm-parser.ts

@@ -1,4 +1,4 @@
-import type { SafeMdxError } from './safe-mdx.js'
+import type { SafeMdxError } from './safe-mdx.tsx'
 
 export interface ParsedImport {
     componentName: string
@@ -83,9 +83,9 @@ export function parseEsmImports(
  * Extracts component info from an import map entry
  */
 export function extractComponentInfo(importInfo: string): { importUrl: string; componentName: string } {
-    const [importUrl, componentName] = importInfo.includes('#') 
-        ? importInfo.split('#') 
-        : [importInfo, 'default']
+    const parts = importInfo.split('#')
+    const importUrl = parts[0] ?? importInfo
+    const componentName = importInfo.includes('#') ? (parts[1] ?? 'default') : 'default'
     
     return { importUrl, componentName }
 }

package/src/html/html-and-md.test.ts

@@ -55,7 +55,7 @@ async function htmlToMdxString({
                     parent &&
                     typeof index === 'number'
                 ) {
-                    const htmlValue = node.value as string
+                    const htmlValue = node.value
 
                     // Parse HTML to MDX AST with processor for markdown parsing
                     const mdxNodes = parseHtmlToMdxAst({
@@ -77,7 +77,7 @@ async function htmlToMdxString({
 
                     // Replace the HTML node with the MDX nodes
                     if (mdxNodes.length === 1) {
-                        parent.children[index] = mdxNodes[0]
+                        parent.children[index] = mdxNodes[0]!
                     } else if (mdxNodes.length > 1) {
                         parent.children.splice(index, 1, ...mdxNodes)
                     } else {

package/src/html/html-to-mdx-ast.test.ts

@@ -5,14 +5,14 @@ import {
     parseHtmlToMdxAst,
     htmlToMdxAst,
     remarkMdxJsxNormalize,
-} from './html-to-mdx-ast.js'
+} from './html-to-mdx-ast.ts'
 import { unified } from 'unified'
 import remarkMdx from 'remark-mdx'
 import remarkStringify from 'remark-stringify'
 import remarkParse from 'remark-parse'
 import type { RootContent } from 'mdast'
-import { mdxParse } from '../parse.js'
-import { MdastToJsx } from '../safe-mdx.js'
+import { mdxParse } from '../parse.ts'
+import { MdastToJsx } from '../safe-mdx.tsx'
 
 // Default components for testing
 const components = {

package/src/html/html-to-mdx-ast.ts

@@ -6,9 +6,9 @@ import type {
 } from 'mdast-util-mdx-jsx'
 import type { Processor } from 'unified'
 import { unified } from 'unified'
-import { convertAttributeNameToJSX } from './convert-attributes.js'
-import { parseHTML } from './domparser.js'
-import { remarkMdxJsxNormalize } from './remark-mdx-jsx-normalize.js'
+import { convertAttributeNameToJSX } from './convert-attributes.ts'
+import { parseHTML } from './domparser.ts'
+import { remarkMdxJsxNormalize } from './remark-mdx-jsx-normalize.ts'
 
 // Re-export the normalize plugin
 export { remarkMdxJsxNormalize }
@@ -77,7 +77,7 @@ function deindent(text: string): string {
     for (const line of lines) {
         if (line.trim()) {
             const match = line.match(/^(\s*)/)
-            if (match) {
+            if (match?.[1] != null) {
                 minIndent = Math.min(minIndent, match[1].length)
             }
         }

package/src/parse.ts

@@ -5,7 +5,7 @@ import { Root, RootContent } from 'mdast'
 import { remark } from 'remark'
 import remarkGfm from 'remark-gfm'
 import remarkMdx from 'remark-mdx'
-import { parseHtmlToMdxAst, remarkMdxJsxNormalize } from './html/html-to-mdx-ast.js'
+import { parseHtmlToMdxAst, remarkMdxJsxNormalize } from './html/html-to-mdx-ast.ts'
 
 export { parseHtmlToMdxAst, remarkMdxJsxNormalize }
 
@@ -95,6 +95,7 @@ export function remarkMarkAndUnravel() {
 
                 while (++offset < children.length) {
                     const child = children[offset]
+                    if (!child) continue
 
                     if (
                         child.type === 'mdxJsxTextElement' ||
@@ -122,6 +123,7 @@ export function remarkMarkAndUnravel() {
 
                     while (++offset < children.length) {
                         const child = children[offset]
+                        if (!child) continue
 
                         if (child.type === 'mdxJsxTextElement') {
                             // @ts-expect-error: mutate because it is faster; content model is fine.

package/src/safe-mdx.bench.tsx

@@ -1,6 +1,6 @@
 import { bench, describe } from 'vitest'
-import { mdxParse } from './parse.js'
-import { MdastToJsx } from './safe-mdx.js'
+import { mdxParse } from './parse.ts'
+import { MdastToJsx } from './safe-mdx.tsx'
 
 let longMdxContent = await fetch(
     'https://raw.githubusercontent.com/colinhacks/zod/0a49fa39348b7c72b19ddedc3b0f879bd395304b/packages/docs/content/packages/v3.mdx',

package/src/safe-mdx.test.tsx

@@ -1,11 +1,12 @@
 import dedent from 'dedent'
+import { generate } from 'escodegen'
 import React from 'react'
 import { renderToStaticMarkup } from 'react-dom/server'
 import { expect, test } from 'vitest'
 import { z } from 'zod'
-import { mdxParse } from './parse.js'
-import { MdastToJsx, mdastBfs, type ComponentPropsSchema } from './safe-mdx.js'
-import { completeJsxTags } from './streaming.js'
+import { mdxParse } from './parse.ts'
+import { MdastToJsx, mdastBfs, type ComponentPropsSchema, type EvaluateOptions } from './safe-mdx.tsx'
+import { completeJsxTags } from './streaming.tsx'
 
 const components = {
     Heading({ level, children, ...props }) {
@@ -19,9 +20,9 @@ const components = {
     },
 }
 
-function render(code, componentPropsSchema?: ComponentPropsSchema, allowClientEsmImports?: boolean, addMarkdownLineNumbers?: boolean) {
+function render(code, componentPropsSchema?: ComponentPropsSchema, allowClientEsmImports?: boolean, addMarkdownLineNumbers?: boolean, scope?: Record<string, any>, evaluateOptions?: EvaluateOptions) {
     const mdast = mdxParse(code)
-    const visitor = new MdastToJsx({ markdown: code, mdast, components, componentPropsSchema, allowClientEsmImports, addMarkdownLineNumbers })
+    const visitor = new MdastToJsx({ markdown: code, mdast, components, componentPropsSchema, allowClientEsmImports, addMarkdownLineNumbers, scope, evaluateOptions })
     const result = visitor.run()
     const html = renderToStaticMarkup(result)
     // console.log(JSON.stringify(result, null, 2))
@@ -531,6 +532,7 @@ test('props parsing', () => {
           {
             "line": 9,
             "message": "Unsupported jsx component SomeComponent in attribute",
+            "type": "missing-component",
           },
           {
             "line": 9,
@@ -2297,8 +2299,8 @@ test('mdx jsx with unknown components are ignored', () => {
     
     // Check that errors were generated for unknown components
     expect(errors).toHaveLength(2)
-    expect(errors[0].message).toContain('Unsupported jsx component CustomElement')
-    expect(errors[1].message).toContain('Unsupported jsx component AnotherUnknown')
+    expect(errors[0]!.message).toContain('Unsupported jsx component CustomElement')
+    expect(errors[1]!.message).toContain('Unsupported jsx component AnotherUnknown')
     
     expect(result).toMatchInlineSnapshot(`
       <React.Fragment>
@@ -3053,12 +3055,12 @@ test('ESM imports error handling', () => {
     expect(visitor.errors.length).toBe(4)
     
     // First two errors are for invalid imports
-    expect(visitor.errors[0].message).toContain('Invalid import URL')
-    expect(visitor.errors[1].message).toContain('Invalid import URL')
+    expect(visitor.errors[0]!.message).toContain('Invalid import URL')
+    expect(visitor.errors[1]!.message).toContain('Invalid import URL')
     
     // Last two errors are for unsupported components
-    expect(visitor.errors[2].message).toContain('Unsupported jsx component Button')
-    expect(visitor.errors[3].message).toContain('Unsupported jsx component Component')
+    expect(visitor.errors[2]!.message).toContain('Unsupported jsx component Button')
+    expect(visitor.errors[3]!.message).toContain('Unsupported jsx component Component')
 })
 
 test('jsx components in attributes', () => {
@@ -3216,6 +3218,7 @@ test("jsx components in attributes error handling", () => {
         {
           "line": 3,
           "message": "Unsupported jsx component UnsupportedComponent in attribute",
+          "type": "missing-component",
         },
         {
           "line": 3,
@@ -3689,3 +3692,164 @@ test('modules prop: unresolved import produces error', () => {
       ]
     `)
 })
+
+test('modules prop: rendering a subset of mdast with import nodes prepended resolves components', () => {
+    // Simulates the pattern used by holocron: the full mdast is split into
+    // sections, and import nodes (mdxjsEsm) are prepended to each section's
+    // nodes so SafeMdxRenderer can resolve imported components.
+    function CustomHero({ title }: { title: string }) {
+        return <div data-testid="hero">{title}</div>
+    }
+
+    const code = dedent`
+        import { CustomHero } from './components/hero'
+
+        # Main content
+
+        <CustomHero title="Hello" />
+    `
+    const mdast = mdxParse(code)
+
+    // Split: extract import nodes and content nodes separately
+    const importNodes = mdast.children.filter((node) => node.type === 'mdxjsEsm')
+    const contentNodes = mdast.children.filter((node) => node.type !== 'mdxjsEsm')
+
+    // Render only content nodes WITH import nodes prepended
+    const syntheticRoot = { type: 'root' as const, children: [...importNodes, ...contentNodes] }
+    const visitor = new MdastToJsx({
+        markdown: code,
+        mdast: syntheticRoot,
+        components,
+        modules: {
+            './components/hero.tsx': { CustomHero },
+        },
+        baseUrl: './',
+    })
+    const result = visitor.run()
+    const html = renderToStaticMarkup(result)
+    expect(html).toContain('data-testid="hero"')
+    expect(html).toContain('Hello')
+    expect(visitor.errors).toMatchInlineSnapshot(`[]`)
+})
+
+test('modules prop: rendering subset WITHOUT import nodes fails to resolve components', () => {
+    // Demonstrates the bug: if import nodes are NOT prepended, the component
+    // is not found and a missing-component error is produced.
+    function CustomHero({ title }: { title: string }) {
+        return <div data-testid="hero">{title}</div>
+    }
+
+    const code = dedent`
+        import { CustomHero } from './components/hero'
+
+        <CustomHero title="Hello" />
+    `
+    const mdast = mdxParse(code)
+
+    // Only render the JSX node WITHOUT the import node
+    const contentNodes = mdast.children.filter((node) => node.type !== 'mdxjsEsm')
+    const syntheticRoot = { type: 'root' as const, children: contentNodes }
+    const visitor = new MdastToJsx({
+        markdown: code,
+        mdast: syntheticRoot,
+        components,
+        modules: {
+            './components/hero.tsx': { CustomHero },
+        },
+        baseUrl: './',
+    })
+    const result = visitor.run()
+    const html = renderToStaticMarkup(result)
+    // Without import nodes, the component is not resolved
+    expect(html).not.toContain('data-testid="hero"')
+    expect(visitor.errors).toMatchInlineSnapshot(`
+      [
+        {
+          "line": 3,
+          "message": "Unsupported jsx component CustomHero",
+          "type": "missing-component",
+        },
+      ]
+    `)
+})
+
+test('scope with function in jsx prop receiving object arg', () => {
+    const scope = {
+        formatTitle: (opts: { text: string; uppercase?: boolean }) => {
+            return opts.uppercase ? opts.text.toUpperCase() : opts.text
+        },
+    }
+
+    const code = dedent`
+        <Heading level={1} title={formatTitle({ text: "hello world", uppercase: true })}>Content</Heading>
+    `
+
+    const { html, errors } = render(code, undefined, undefined, undefined, scope)
+    expect(errors).toMatchInlineSnapshot(`[]`)
+    expect(html).toMatchInlineSnapshot(`"<h1 title="HELLO WORLD">Content</h1>"`)
+})
+
+test('scope with variables and functions in inline expressions', () => {
+    const scope = {
+        greeting: 'Hello',
+        getName: (user: { first: string; last: string }) => `${user.first} ${user.last}`,
+    }
+
+    const code = dedent`
+        {greeting} {getName({ first: "John", last: "Doe" })}
+    `
+
+    const { html, errors } = render(code, undefined, undefined, undefined, scope)
+    expect(errors).toMatchInlineSnapshot(`[]`)
+    expect(html).toMatchInlineSnapshot(`"HelloJohn Doe"`)
+})
+
+test('scope with function in spread attribute', () => {
+    const scope = {
+        getProps: (config: { level: number }) => ({ level: config.level }),
+    }
+
+    const code = dedent`
+        <Heading {...getProps({ level: 2 })}>Spread test</Heading>
+    `
+
+    const { html, errors } = render(code, undefined, undefined, undefined, scope)
+    expect(errors).toMatchInlineSnapshot(`[]`)
+    expect(html).toMatchInlineSnapshot(`"<h1>Spread test</h1>"`)
+})
+
+test('scope with .map and arrow function callback fails without generate', () => {
+    const scope = {
+        items: [{ name: 'Alice' }, { name: 'Bob' }, { name: 'Charlie' }],
+    }
+
+    const code = dedent`
+        {items.map(item => item.name).join(", ")}
+    `
+
+    const { html, errors } = render(code, undefined, undefined, undefined, scope)
+    expect(errors).toMatchInlineSnapshot(`
+      [
+        {
+          "line": 1,
+          "message": "Failed to evaluate expression: items.map(item => item.name).join(", "). Expected options.generate to be the "generate" function from "escodegen"",
+          "type": "expression",
+        },
+      ]
+    `)
+    expect(html).toMatchInlineSnapshot(`""`)
+})
+
+test('scope with .map and arrow function callback works with generate', () => {
+    const scope = {
+        items: [{ name: 'Alice' }, { name: 'Bob' }, { name: 'Charlie' }],
+    }
+
+    const code = dedent`
+        {items.map(item => item.name).join(", ")}
+    `
+
+    const { html, errors } = render(code, undefined, undefined, undefined, scope, { generate })
+    expect(errors).toMatchInlineSnapshot(`[]`)
+    expect(html).toMatchInlineSnapshot(`"Alice, Bob, Charlie"`)
+})

package/src/safe-mdx.tsx

@@ -8,10 +8,10 @@ import type { MdxJsxFlowElement, MdxJsxTextElement } from 'mdast-util-mdx-jsx'
 
 import { Fragment, ReactNode } from 'react'
 import { DynamicEsmComponent } from 'safe-mdx/client'
-import { extractComponentInfo, parseEsmImports } from './esm-parser.js'
-import { resolveModulePath, type EagerModules } from './parse.js'
-import { htmlToMdxAst } from './html/html-to-mdx-ast.js'
-import { validHtmlElements, nativeTags } from './html/valid-html-elements.js'
+import { extractComponentInfo, parseEsmImports } from './esm-parser.ts'
+import { resolveModulePath, type EagerModules } from './parse.ts'
+import { htmlToMdxAst } from './html/html-to-mdx-ast.ts'
+import { validHtmlElements, nativeTags } from './html/valid-html-elements.ts'
 
 export type MyRootContent = RootContent | Root
 
@@ -46,6 +46,18 @@ export type CreateElementFunction = (
     ...children: ReactNode[]
 ) => ReactNode
 
+export interface EvaluateOptions {
+    /** Enable function calls in expressions. Automatically enabled when `scope` is provided. */
+    functions?: boolean
+    /** Pass `escodegen.generate` to support inline function expressions
+     *  like arrow functions in `.map(x => x.name)`. Requires `functions: true`. */
+    generate?: (ast: any) => string
+    /** Force logical operators (`&&`, `||`) to return booleans. */
+    booleanLogicalOperators?: boolean
+    /** Throw when variables referenced in expressions are undefined. */
+    strict?: boolean
+}
+
 export const SafeMdxRenderer = React.memo(function SafeMdxRenderer({
     components,
     markdown = '',
@@ -58,6 +70,8 @@ export const SafeMdxRenderer = React.memo(function SafeMdxRenderer({
     modules,
     baseUrl,
     onError,
+    scope,
+    evaluateOptions,
 }: {
     components?: ComponentsMap
     markdown?: string
@@ -77,6 +91,15 @@ export const SafeMdxRenderer = React.memo(function SafeMdxRenderer({
     /** Called for each error during rendering (missing components, invalid props, failed expressions).
      *  Throw inside this callback to stop rendering on first error. */
     onError?: (error: SafeMdxError) => void
+    /** Variables and functions available in MDX expressions.
+     *  When scope contains functions, function calls in expressions are
+     *  automatically enabled. */
+    scope?: Record<string, any>
+    /** Options passed to `eval-estree-expression` for expression evaluation.
+     *  Pass `{ functions: true }` to enable function calls, or
+     *  `{ functions: true, generate: escodegen.generate }` to also support
+     *  inline arrow functions and callbacks like `.map(x => x.name)`. */
+    evaluateOptions?: EvaluateOptions
 }) {
     const visitor = new MdastToJsx({
         markdown,
@@ -90,6 +113,8 @@ export const SafeMdxRenderer = React.memo(function SafeMdxRenderer({
         modules,
         baseUrl,
         onError,
+        scope,
+        evaluateOptions,
     })
     const result = visitor.run()
     return result
@@ -110,6 +135,8 @@ export class MdastToJsx {
     modules?: EagerModules
     baseUrl?: string
     onError?: (error: SafeMdxError) => void
+    scope?: Record<string, any>
+    evaluateOptions?: EvaluateOptions
 
     constructor({
         markdown: code = '',
@@ -123,6 +150,8 @@ export class MdastToJsx {
         modules,
         baseUrl,
         onError,
+        scope,
+        evaluateOptions,
     }: {
         markdown?: string
         mdast: MyRootContent
@@ -140,6 +169,15 @@ export class MdastToJsx {
         /** Called for each error during rendering (missing components, invalid props, failed expressions).
          *  Throw inside this callback to stop rendering on first error. */
         onError?: (error: SafeMdxError) => void
+        /** Variables and functions available in MDX expressions.
+         *  When scope contains functions, function calls in expressions are
+         *  automatically enabled. */
+        scope?: Record<string, any>
+        /** Options passed to `eval-estree-expression` for expression evaluation.
+         *  Pass `{ functions: true }` to enable function calls, or
+         *  `{ functions: true, generate: escodegen.generate }` to also support
+         *  inline arrow functions and callbacks like `.map(x => x.name)`. */
+        evaluateOptions?: EvaluateOptions
     }) {
         this.str = code
 
@@ -158,6 +196,8 @@ export class MdastToJsx {
         this.modules = modules
         this.baseUrl = baseUrl
         this.onError = onError
+        this.scope = scope
+        this.evaluateOptions = evaluateOptions
 
         this.c = {
             ...Object.fromEntries(
@@ -488,6 +528,15 @@ export class MdastToJsx {
         return null
     }
 
+    evaluateExpression(expression: any) {
+        const hasScope = this.scope && Object.keys(this.scope).length > 0
+        const context = hasScope ? this.scope : undefined
+        const options = hasScope || this.evaluateOptions
+            ? { ...(hasScope ? { functions: true } : {}), ...this.evaluateOptions }
+            : undefined
+        return Evaluate.evaluate.sync(expression, context, options)
+    }
+
     getJsxAttrs(
         node: MdxJsxFlowElement | MdxJsxTextElement,
         onError: (err: SafeMdxError) => void = console.error,
@@ -500,14 +549,15 @@ export class MdastToJsx {
                 if (attr.data?.estree) {
                     try {
                         const program = attr.data.estree
+                        const firstBody = program.body?.[0]
                         if (
-                            program.body?.length > 0 &&
-                            program.body[0].type === 'ExpressionStatement'
+                            firstBody &&
+                            firstBody.type === 'ExpressionStatement'
                         ) {
-                            const expression = program.body[0].expression
+                            const expression = firstBody.expression
                             try {
                                 const result =
-                                    Evaluate.evaluate.sync(expression)
+                                    this.evaluateExpression(expression)
 
                                 // Handle spread syntax - merge the evaluated object
                                 if (
@@ -597,11 +647,12 @@ export class MdastToJsx {
                     try {
                         // Extract the expression from the Program body
                         const program = v.data.estree
+                        const firstBody = program.body?.[0]
                         if (
-                            program.body?.length > 0 &&
-                            program.body[0].type === 'ExpressionStatement'
+                            firstBody &&
+                            firstBody.type === 'ExpressionStatement'
                         ) {
-                            const expression = program.body[0].expression
+                            const expression = firstBody.expression
 
                             // Check if this is a JSX element
                             if (expression.type === 'JSXElement') {
@@ -620,7 +671,7 @@ export class MdastToJsx {
                             try {
                                 // Evaluate the expression synchronously
                                 const result =
-                                    Evaluate.evaluate.sync(expression)
+                                    this.evaluateExpression(expression)
                                 attrsList.push([attr.name, result])
                                 continue
                             } catch (error) {
@@ -653,7 +704,7 @@ export class MdastToJsx {
     }
 
     run() {
-        const res = this.mdastTransformer(this.mdast, 'root') as ReactNode
+        const res = this.mdastTransformer(this.mdast, 'root')
         if (Array.isArray(res) && res.length === 1) {
             return res[0]
         }
@@ -669,7 +720,7 @@ export class MdastToJsx {
         if (this.renderNode) {
             const customResult = this.renderNode(
                 node,
-                (n: MyRootContent) => this.mdastTransformer(n, node.type),
+                (n) => this.mdastTransformer(n, node.type),
             )
             if (customResult !== undefined) {
                 return customResult
@@ -723,15 +774,16 @@ export class MdastToJsx {
                     try {
                         // Extract the expression from the Program body
                         const program = node.data.estree
+                        const firstBody = program.body?.[0]
                         if (
-                            program.body?.length > 0 &&
-                            program.body[0].type === 'ExpressionStatement'
+                            firstBody &&
+                            firstBody.type === 'ExpressionStatement'
                         ) {
-                            const expression = program.body[0].expression
+                            const expression = firstBody.expression
                             try {
                                 // Evaluate the expression synchronously
                                 const result =
-                                    Evaluate.evaluate.sync(expression)
+                                    this.evaluateExpression(expression)
                                 return result
                             } catch (error) {
                                 this.pushError({
@@ -1060,9 +1112,6 @@ export class MdastToJsx {
     }
 }
 
-function isTruthy<T>(val: T | undefined | null | false): val is T {
-    return Boolean(val)
-}
 
 function accessWithDot(obj, path: string) {
     return path
@@ -1093,14 +1142,6 @@ export function mdastBfs(
     return result
 }
 
-function safeJsonParse(str: string) {
-    try {
-        return JSON.parse(str)
-    } catch (err) {
-        return null
-    }
-}
-
 type ComponentsMap = { [k in (typeof nativeTags)[number]]?: any } & {
     [key: string]: any
 }