satteri 0.1.1 → 0.2.0

package/dist/hast/hast-reader.js

@@ -34,6 +34,12 @@ const MDX_ATTR_SPREAD = 3;
 //   Total: 52 bytes
 const FIELD = {
     node_type: 4,
+    start_offset: 12,
+    end_offset: 16,
+    start_line: 20,
+    start_column: 24,
+    end_line: 28,
+    end_column: 32,
     children_start: 36,
     children_count: 40,
     data_offset: 44,
@@ -102,6 +108,27 @@ export class HastReader {
         const bytes = new Uint8Array(this.#view.buffer, this.#view.byteOffset + sourceOffset + offset, len);
         return this.#textDecoder.decode(bytes);
     }
+    /** Get position data for a node. */
+    getPosition(nodeId) {
+        const base = this.#header.nodesOffset + nodeId * this.#header.nodeStructSize;
+        const v = this.#view;
+        const startLine = v.getUint32(base + FIELD.start_line, true);
+        const startOffset = v.getUint32(base + FIELD.start_offset, true);
+        if (startLine === 0 && startOffset === 0)
+            return undefined;
+        return {
+            start: {
+                offset: startOffset,
+                line: startLine,
+                column: v.getUint32(base + FIELD.start_column, true),
+            },
+            end: {
+                offset: v.getUint32(base + FIELD.end_offset, true),
+                line: v.getUint32(base + FIELD.end_line, true),
+                column: v.getUint32(base + FIELD.end_column, true),
+            },
+        };
+    }
     /** Get the node_type byte for a given node ID. */
     getNodeType(nodeId) {
         const { nodesOffset, nodeStructSize } = this.#header;

package/dist/hast/hast-visitor.d.ts

@@ -15,19 +15,19 @@ export interface HastDiagnostic {
 export interface HastVisitorContext {
     readonly source: string;
     readonly filename: string;
-    removeNode(node: HastNode): void;
-    replaceNode(node: HastNode, newNode: HastNode): void;
-    insertBefore(node: HastNode, newNode: HastNode): void;
-    insertAfter(node: HastNode, newNode: HastNode): void;
-    wrapNode(node: HastNode, parentNode: HastNode): void;
-    prependChild(node: HastNode, childNode: HastNode): void;
-    appendChild(node: HastNode, childNode: HastNode): void;
-    setProperty(node: HastNode, key: string, value: unknown): void;
+    removeNode(node: Readonly<HastNode>): void;
+    replaceNode(node: Readonly<HastNode>, newNode: HastNode): void;
+    insertBefore(node: Readonly<HastNode>, newNode: HastNode): void;
+    insertAfter(node: Readonly<HastNode>, newNode: HastNode): void;
+    wrapNode(node: Readonly<HastNode>, parentNode: HastNode): void;
+    prependChild(node: Readonly<HastNode>, childNode: HastNode): void;
+    appendChild(node: Readonly<HastNode>, childNode: HastNode): void;
+    setProperty(node: Readonly<HastNode>, key: string, value: unknown): void;
     /** Collect the concatenated text of all descendant text nodes (like DOM textContent). */
-    textContent(node: HastNode): string;
+    textContent(node: Readonly<HastNode>): string;
     report(opts: {
         message: string;
-        node?: HastNode;
+        node?: Readonly<HastNode>;
         severity?: "error" | "warning" | "info";
     }): void;
     getDiagnostics(): HastDiagnostic[];
@@ -35,9 +35,9 @@ export interface HastVisitorContext {
 /** A filtered visitor: Rust filters by tag/component name, only matched nodes cross the boundary. */
 export interface HastFilteredVisitor<N extends HastNode = HastNode> {
     filter: string[];
-    visit(node: N, ctx: HastVisitorContext): HastNode | void | Promise<HastNode | void>;
+    visit(node: Readonly<N>, ctx: HastVisitorContext): HastNode | void | Promise<HastNode | void>;
 }
-type HastVisitorFn<N extends HastNode = HastNode> = (node: N, ctx: HastVisitorContext) => HastNode | void | Promise<HastNode | void>;
+type HastVisitorFn<N extends HastNode = HastNode> = (node: Readonly<N>, ctx: HastVisitorContext) => HastNode | void | Promise<HastNode | void>;
 export interface HastVisitorInstance {
     element?: HastFilteredVisitor<Element> | HastFilteredVisitor<Element>[];
     mdxJsxFlowElement?: HastFilteredVisitor<MdxJsxFlowElementHast> | HastFilteredVisitor<MdxJsxFlowElementHast>[];

package/dist/hast/hast-visitor.js

@@ -1,7 +1,7 @@
 import { materializeHastNode } from "./hast-materializer.js";
 import { HastReader, HAST_ELEMENT, HAST_TEXT, HAST_COMMENT, HAST_RAW, HAST_MDX_JSX_ELEMENT, HAST_MDX_JSX_TEXT_ELEMENT, HAST_MDX_FLOW_EXPRESSION, HAST_MDX_TEXT_EXPRESSION, HAST_MDX_ESM, } from "./hast-reader.js";
 import { CommandBuffer } from "../command-buffer.js";
-import { walkHandle, applyCommandsToHandle, serializeHandle, textContentHandle, getNodeData as napiGetNodeData, parseExpression as napiParseExpression, } from "../../index.js";
+import { walkHandle, applyCommandsToHandle, serializeHandle, textContentHandle, getNodeData as napiGetNodeData, parseExpression as napiParseExpression, } from "#binding";
 /** Maps HastNode objects to their arena node IDs without Object.defineProperty overhead. */
 const nodeIdMap = new WeakMap();
 /** Attach `parseExpression()` to an MDX expression node. */
@@ -374,7 +374,8 @@ function readMatchedNode(view, buf, offset, nodeId, nodeType, resolver) {
         nodeType === HAST_COMMENT ||
         nodeType === HAST_RAW ||
         nodeType === HAST_MDX_FLOW_EXPRESSION ||
-        nodeType === HAST_MDX_TEXT_EXPRESSION) {
+        nodeType === HAST_MDX_TEXT_EXPRESSION ||
+        nodeType === HAST_MDX_ESM) {
         return readTextFromBinary(view, buf, offset, nodeId, nodeType);
     }
     else if (nodeType === HAST_MDX_JSX_ELEMENT || nodeType === HAST_MDX_JSX_TEXT_ELEMENT) {

package/dist/index.d.ts

@@ -1,6 +1,14 @@
-export { compileMarkdownToHtml, compileMdxToJs } from "./compile.js";
-export type { CompileOptions, OptimizeStaticConfig } from "./compile.js";
+export { markdownToHtml, mdxToJs, markdownToMdast, mdxToMdast, markdownToHast, mdxToHast, } from "./compile.js";
+export type { CompileOptions, MdxCompileOptions, OptimizeStaticConfig, Features, } from "./compile.js";
 export { defineMdastPlugin, defineHastPlugin } from "./plugin.js";
 export type { MdastPluginDefinition, HastPluginDefinition } from "./plugin.js";
 export type { HastVisitorInstance, HastVisitorContext, HastFilteredVisitor, EstreeProgram, } from "./hast/hast-visitor.js";
 export type { MdastNode, HastNode, Position, Point, MdxJsxAttributeNode, MdxJsxExpressionAttributeNode, MdxJsxAttributeValueExpressionNode, MdxJsxAttributeUnion, } from "./types.js";
+export { visitMdastHandle, resolveMdastSubscriptions } from "./mdast/mdast-visitor.js";
+export type { MdastPluginInstance } from "./mdast/mdast-visitor.js";
+export { visitHastHandle, resolveSubscriptions as resolveHastSubscriptions, } from "./hast/hast-visitor.js";
+export { MdastReader } from "./mdast/mdast-reader.js";
+export { materializeMdastTree } from "./mdast/mdast-materializer.js";
+export { HastReader } from "./hast/hast-reader.js";
+export { materializeHastTree } from "./hast/hast-materializer.js";
+export { createMdastHandle, createMdxMdastHandle, createHastHandle, createMdxHastHandle, convertMdastToHastHandle, serializeMdastHandle, serializeHandle, renderHandle, compileHandle, dropHandle, applyCommandsToMdastHandle, applyCommandsAndConvertToHastHandle, getHandleSource, } from "#binding";

package/dist/index.js

@@ -1,4 +1,13 @@
 // Public API: compile functions
-export { compileMarkdownToHtml, compileMdxToJs } from "./compile.js";
+export { markdownToHtml, mdxToJs, markdownToMdast, mdxToMdast, markdownToHast, mdxToHast, } from "./compile.js";
 // Plugin definitions
 export { defineMdastPlugin, defineHastPlugin } from "./plugin.js";
+// Visitor pipeline (for manual plugin execution)
+export { visitMdastHandle, resolveMdastSubscriptions } from "./mdast/mdast-visitor.js";
+export { visitHastHandle, resolveSubscriptions as resolveHastSubscriptions, } from "./hast/hast-visitor.js";
+// Step-by-step API: readers, materializers, and handle functions
+export { MdastReader } from "./mdast/mdast-reader.js";
+export { materializeMdastTree } from "./mdast/mdast-materializer.js";
+export { HastReader } from "./hast/hast-reader.js";
+export { materializeHastTree } from "./hast/hast-materializer.js";
+export { createMdastHandle, createMdxMdastHandle, createHastHandle, createMdxHastHandle, convertMdastToHastHandle, serializeMdastHandle, serializeHandle, renderHandle, compileHandle, dropHandle, applyCommandsToMdastHandle, applyCommandsAndConvertToHastHandle, getHandleSource, } from "#binding";

package/dist/mdast/mdast-materializer.d.ts

@@ -1,9 +1,9 @@
 import type { MdastNode } from "../types.js";
-import type { ArenaReader } from "./mdast-reader.js";
+import type { MdastReader } from "./mdast-reader.js";
 export declare const TYPE_NAMES: Record<number, string>;
 /**
  * Materialize a single MDAST node from a binary buffer as a lazy JS object.
  */
-export declare function materializeNode(reader: ArenaReader, nodeId: number): MdastNode;
+export declare function materializeNode(reader: MdastReader, nodeId: number): MdastNode;
 /** Materialize the full tree from root (nodeId=0). */
-export declare function materializeTree(reader: ArenaReader): MdastNode;
+export declare function materializeMdastTree(reader: MdastReader): MdastNode;

package/dist/mdast/mdast-materializer.js

@@ -156,6 +156,6 @@ export function materializeNode(reader, nodeId) {
     return node;
 }
 /** Materialize the full tree from root (nodeId=0). */
-export function materializeTree(reader) {
+export function materializeMdastTree(reader) {
     return materializeNode(reader, 0);
 }

package/dist/mdast/mdast-reader.d.ts

@@ -36,7 +36,7 @@ export declare const NodeType: Readonly<{
     readonly MdxjsEsm: 104;
 }>;
 export declare const NodeTypeName: Record<number, string>;
-export declare class ArenaReader {
+export declare class MdastReader {
     #private;
     constructor(buffer: ArrayBuffer | Uint8Array);
     get nodeCount(): number;

package/dist/mdast/mdast-reader.js

@@ -84,7 +84,7 @@ const FIELD = {
 //   source_offset: u32     @ 40
 //   Total: 44 bytes
 const MAGIC = 0x5241444d; // "MDAR" bytes [0x4d,0x44,0x41,0x52] read as little-endian u32
-export class ArenaReader {
+export class MdastReader {
     #view;
     #header;
     #textDecoder;

package/dist/mdast/mdast-visitor.d.ts

@@ -15,22 +15,22 @@ export declare class MdastVisitorContext {
     readonly source: string;
     readonly filename: string;
     constructor(handle: MdastHandle, source: string, filename: string);
-    removeNode(node: MdastNode): void;
-    insertBefore(node: MdastNode, newNode: MdastNode): void;
-    insertAfter(node: MdastNode, newNode: MdastNode): void;
-    wrapNode(node: MdastNode, parentNode: MdastNode): void;
-    prependChild(node: MdastNode, childNode: MdastNode): void;
-    appendChild(node: MdastNode, childNode: MdastNode): void;
-    replaceNode(node: MdastNode, newNode: MdastNode): void;
-    setProperty(node: MdastNode, key: string, value: unknown): void;
+    removeNode(node: Readonly<MdastNode>): void;
+    insertBefore(node: Readonly<MdastNode>, newNode: MdastNode): void;
+    insertAfter(node: Readonly<MdastNode>, newNode: MdastNode): void;
+    wrapNode(node: Readonly<MdastNode>, parentNode: MdastNode): void;
+    prependChild(node: Readonly<MdastNode>, childNode: MdastNode): void;
+    appendChild(node: Readonly<MdastNode>, childNode: MdastNode): void;
+    replaceNode(node: Readonly<MdastNode>, newNode: MdastNode): void;
+    setProperty<N extends MdastNode, K extends keyof N & string>(node: Readonly<N>, key: K, value: N[K]): void;
     /** Collect the concatenated text of all descendant text nodes (like mdast-util-to-string). */
-    textContent(node: MdastNode, options?: {
+    textContent(node: Readonly<MdastNode>, options?: {
         includeImageAlt?: boolean;
         includeHtml?: boolean;
     }): string;
     report({ message, node, severity, }: {
         message: string;
-        node?: MdastNode;
+        node?: Readonly<MdastNode>;
         severity?: "error" | "warning" | "info";
     }): void;
     /** Get the binary command buffer for all mutations recorded via context methods. */
@@ -42,7 +42,7 @@ type MdastVisitorResult = MdastNode | {
 } | {
     rawHtml: string;
 } | undefined | null | void;
-type MdastVisitorFn<N extends MdastNode = MdastNode> = (node: N, context: MdastVisitorContext) => MdastVisitorResult | Promise<MdastVisitorResult>;
+type MdastVisitorFn<N extends MdastNode = MdastNode> = (node: Readonly<N>, context: MdastVisitorContext) => MdastVisitorResult | Promise<MdastVisitorResult>;
 export interface MdastPluginInstance {
     root?: MdastVisitorFn<Root>;
     paragraph?: MdastVisitorFn<Paragraph>;

package/dist/mdast/mdast-visitor.js

@@ -1,7 +1,7 @@
 import { materializeNode, TYPE_NAMES } from "./mdast-materializer.js";
-import { ArenaReader } from "./mdast-reader.js";
+import { MdastReader } from "./mdast-reader.js";
 import { CommandBuffer, classifyReturn } from "../command-buffer.js";
-import { walkMdastHandle, serializeMdastHandle, getNodeData as napiGetNodeData, setNodeData, mdastTextContentHandle, } from "../../index.js";
+import { walkMdastHandle, serializeMdastHandle, getNodeData as napiGetNodeData, mdastTextContentHandle, } from "#binding";
 const MutationType = {
     Replace: "replace",
     Remove: "remove",
@@ -86,6 +86,11 @@ export class MdastVisitorContext {
         this.#commandBuffer.replace(nid(node), newNode);
     }
     setProperty(node, key, value) {
+        if (key === "data") {
+            // data is stored as JSON in the arena, serialize it for the command buffer
+            this.#commandBuffer.setProperty(nid(node), key, value != null ? JSON.stringify(value) : null);
+            return;
+        }
         this.#commandBuffer.setProperty(nid(node), key, value);
     }
     /** Collect the concatenated text of all descendant text nodes (like mdast-util-to-string). */
@@ -164,7 +169,7 @@ function rstr(buf, off, len) {
 /**
  * Lazy child materializer for the MDAST handle walk path.
  * Serializes the handle once on first child access, then materializes
- * children via ArenaReader + materializeNode.
+ * children via MdastReader + materializeNode.
  */
 class MdastLazyChildResolver {
     #handle;
@@ -174,7 +179,7 @@ class MdastLazyChildResolver {
     }
     #ensure() {
         if (!this.#reader) {
-            this.#reader = new ArenaReader(serializeMdastHandle(this.#handle));
+            this.#reader = new MdastReader(serializeMdastHandle(this.#handle));
         }
         return this.#reader;
     }
@@ -209,7 +214,7 @@ class MdastLazyChildResolver {
  *   [node_data: u32+bytes][position: 6×u32 = 24B][child_count: u16][child_ids: N×u32][type-specific data]
  */
 const encoder = new TextEncoder();
-function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, dirtyData, resolver) {
+function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, resolver) {
     let pos = dataOffset;
     // Node data (JSON bytes), always first
     const dataJsonLen = ru32(view, pos);
@@ -452,26 +457,9 @@ function readMdastMatchedNode(view, buf, dataOffset, nodeId, nodeType, dirtyData
         // strong(12), break(14), tableRow(22), tableCell(23), delete(24): no extra data
     }
     mdastNodeIdMap.set(node, nodeId);
-    // Read inline node_data JSON from the end of the data section.
-    // The Rust serializer always appends [json_len: u32][json_bytes...] at the end.
-    // We need to find it by reading from dataEnd backwards.
-    // Actually, we read it at `dataOffset + dataLen - (4 + jsonDataLen)` but we don't
-    // know jsonDataLen yet. Instead, the data section ends with [len: u32][bytes...],
-    // so we scan from the current end of type-specific data.
-    // For simplicity, we'll handle this in the caller which knows the full data_len.
-    // Set up data getter/setter that tracks dirty entries
-    let currentData = initialData;
-    Object.defineProperty(node, "data", {
-        get() {
-            return currentData;
-        },
-        set(value) {
-            currentData = value;
-            dirtyData.set(nodeId, value);
-        },
-        configurable: true,
-        enumerable: true,
-    });
+    if (initialData) {
+        node.data = initialData;
+    }
     return node;
 }
 /** Apply a sync visitor result to the return buffer.
@@ -505,7 +493,6 @@ function applyMdastVisitResult(result, nodeId, returnBuffer, originalNode) {
 export function visitMdastHandle(handle, plugin, subs, source, filename) {
     const context = new MdastVisitorContext(handle, source, filename);
     const returnBuffer = new CommandBuffer();
-    const dirtyData = new Map();
     const resolver = new MdastLazyChildResolver(handle);
     const rustSubs = subs.map((s) => ({ nodeType: s.nodeType, tagFilter: [] }));
     const matchBuf = walkMdastHandle(handle, rustSubs);
@@ -518,7 +505,7 @@ export function visitMdastHandle(handle, plugin, subs, source, filename) {
         const subIndex = matchBuf[indexBase + 4];
         const dataOffset = ru32(matchView, indexBase + 6);
         const sub = subs[subIndex];
-        const node = readMdastMatchedNode(matchView, matchBuf, dataOffset, nodeId, sub.nodeType, dirtyData, resolver);
+        const node = readMdastMatchedNode(matchView, matchBuf, dataOffset, nodeId, sub.nodeType, resolver);
         const result = sub.visitFn.call(plugin, node, context);
         if (result instanceof Promise) {
             deferred ??= [];
@@ -533,16 +520,12 @@ export function visitMdastHandle(handle, plugin, subs, source, filename) {
             for (const { nodeId, result, originalNode } of results) {
                 applyMdastVisitResult(result, nodeId, returnBuffer, originalNode);
             }
-            return finalizeMdastVisit(handle, context, returnBuffer, dirtyData);
+            return finalizeMdastVisit(handle, context, returnBuffer);
         });
     }
-    return finalizeMdastVisit(handle, context, returnBuffer, dirtyData);
+    return finalizeMdastVisit(handle, context, returnBuffer);
 }
-function finalizeMdastVisit(handle, context, returnBuffer, dirtyData) {
-    for (const [id, value] of dirtyData) {
-        const json = value ? JSON.stringify(value) : "";
-        setNodeData(handle, id, encoder.encode(json));
-    }
+function finalizeMdastVisit(handle, context, returnBuffer) {
     const { merged, hasMutations } = mergeAndReset(returnBuffer, context);
     return { commandBuffer: merged, diagnostics: context.getDiagnostics(), hasMutations };
 }

package/dist/plugin.d.ts

@@ -1,12 +1,10 @@
 import type { MdastPluginInstance } from "./mdast/mdast-visitor.js";
 import type { HastVisitorInstance } from "./hast/hast-visitor.js";
-export interface MdastPluginDefinition {
+export type MdastPluginDefinition = MdastPluginInstance & {
     name: string;
-    createOnce(): MdastPluginInstance;
-}
-export interface HastPluginDefinition {
+};
+export type HastPluginDefinition = HastVisitorInstance & {
     name: string;
-    createOnce(): HastVisitorInstance;
-}
+};
 export declare function defineMdastPlugin(definition: MdastPluginDefinition): MdastPluginDefinition;
 export declare function defineHastPlugin(definition: HastPluginDefinition): HastPluginDefinition;

package/dist/plugin.js

@@ -2,17 +2,11 @@ export function defineMdastPlugin(definition) {
     if (!definition.name) {
         throw new Error("Plugin definition must have a name");
     }
-    if (typeof definition.createOnce !== "function") {
-        throw new Error("Plugin definition must have a createOnce function");
-    }
     return definition;
 }
 export function defineHastPlugin(definition) {
     if (!definition.name) {
         throw new Error("Plugin definition must have a name");
     }
-    if (typeof definition.createOnce !== "function") {
-        throw new Error("Plugin definition must have a createOnce function");
-    }
     return definition;
 }

package/dist/types.js

@@ -1,5 +1 @@
-// Shared types for the satteri JS layer.
-//
-// Uses standard @types/mdast, @types/hast, and mdast-util-mdx-* packages
-// for AST node types. Extension types (toml, math, raw) are augmented here.
 export {};

package/index.d.ts

@@ -16,7 +16,7 @@ export declare function applyCommandsToMdastHandle(handle: ArenaHandle, commandB
 export declare function compileHandle(handle: ArenaHandle, options?: JsMdxOptions | undefined | null): string
 
 /** Compile MDX source directly to JavaScript. */
-export declare function compileMdx(source: string, options?: JsMdxOptions | undefined | null): string
+export declare function compileMdx(source: string, options?: JsMdxOptions | undefined | null, features?: JsFeatures | undefined | null): string
 
 /** Convert an MDAST handle to a HAST handle. The MDAST handle is consumed (emptied). */
 export declare function convertMdastToHastHandle(handle: ArenaHandle): ArenaHandle
@@ -25,16 +25,16 @@ export declare function convertMdastToHastHandle(handle: ArenaHandle): ArenaHand
  * Parse markdown source and convert to HAST. Returns an opaque handle.
  * The arena stays in Rust memory, no buffer is copied to JS.
  */
-export declare function createHastHandle(source: string): ArenaHandle
+export declare function createHastHandle(source: string, features?: JsFeatures | undefined | null): ArenaHandle
 
 /** Parse markdown source into an MDAST arena handle. */
-export declare function createMdastHandle(source: string): ArenaHandle
+export declare function createMdastHandle(source: string, features?: JsFeatures | undefined | null): ArenaHandle
 
 /** Parse MDX source and convert to HAST. Returns an opaque handle. */
-export declare function createMdxHastHandle(source: string): ArenaHandle
+export declare function createMdxHastHandle(source: string, features?: JsFeatures | undefined | null): ArenaHandle
 
 /** Parse MDX source into an MDAST arena handle. */
-export declare function createMdxMdastHandle(source: string): ArenaHandle
+export declare function createMdxMdastHandle(source: string, features?: JsFeatures | undefined | null): ArenaHandle
 
 /**
  * Release the arena memory held by a handle. The handle becomes empty
@@ -48,6 +48,33 @@ export declare function getHandleSource(handle: ArenaHandle): string
 /** Read the node_data JSON blob for a node. Returns null if none is set. */
 export declare function getNodeData(handle: ArenaHandle, nodeId: number): string | null
 
+/** Feature toggles for the Markdown/MDX parser, passed from JavaScript. */
+export interface JsFeatures {
+  /**
+   * GFM: tables, footnotes, strikethrough, task lists, blockquote tags.
+   * Default: true.
+   */
+  gfm?: boolean
+  /** Frontmatter: YAML (`--- ... ---`) and TOML (`+++ ... +++`). Default: true. */
+  frontmatter?: boolean
+  /** Math blocks and inline math (`$$ ... $$`, `$ ... $`). Default: true. */
+  math?: boolean
+  /** Heading attributes (`# text { #id .class }`). Default: true. */
+  headingAttributes?: boolean
+  /** Colon-delimited container directive blocks (`:::`). Default: false. */
+  directive?: boolean
+  /** Superscript (`^super^`). Default: false. */
+  superscript?: boolean
+  /** Subscript (`~sub~`). Default: false. */
+  subscript?: boolean
+  /** Obsidian-style wikilinks (`[[link]]`). Default: false. */
+  wikilinks?: boolean
+  /** Smart punctuation (ligatures, smart quotes). Default: false. */
+  smartPunctuation?: boolean
+  /** Definition lists. Default: false. */
+  definitionList?: boolean
+}
+
 /** MDX compile options passed from JavaScript. */
 export interface JsMdxOptions {
   /**
@@ -55,6 +82,28 @@ export interface JsMdxOptions {
    * into raw HTML strings using the specified component and prop.
    */
   optimizeStatic?: JsOptimizeStaticConfig
+  /**
+   * Place to import automatic JSX runtimes from (e.g. "react", "preact").
+   * Default: "react".
+   */
+  jsxImportSource?: string
+  /** Whether to keep JSX instead of compiling it away. Default: false. */
+  jsx?: boolean
+  /** JSX runtime: "automatic" (default) or "classic". */
+  jsxRuntime?: string
+  /**
+   * Whether to add extra info to error messages and use the development
+   * JSX runtime. Default: false.
+   */
+  development?: boolean
+  /** Place to import a provider from (e.g. "@mdx-js/react"). */
+  providerImportSource?: string
+  /** Pragma for JSX in classic runtime (default: "React.createElement"). */
+  pragma?: string
+  /** Pragma for JSX fragments in classic runtime (default: "React.Fragment"). */
+  pragmaFrag?: string
+  /** Where to import the pragma from in classic runtime (default: "react"). */
+  pragmaImportSource?: string
 }
 
 /** Static optimization config passed from JavaScript. */
@@ -99,7 +148,7 @@ export declare function parseExpression(source: string): string | null
  * Parse Markdown source and return HTML string directly.
  * Uses pulldown-cmark's streaming renderer, skipping the arena entirely.
  */
-export declare function parseToHtml(source: string): string
+export declare function parseToHtml(source: string, features?: JsFeatures | undefined | null): string
 
 /** Render a handle's HAST arena to HTML. Does not consume the handle. */
 export declare function renderHandle(handle: ArenaHandle): string