markdown-to-jsx

type ASTNode =
    | BlockQuoteNode
    | BreakLineNode
    | BreakThematicNode
    | CodeBlockNode
    | CodeInlineNode
    | FootnoteNode
    | FootnoteReferenceNode
    | FrontmatterNode
    | GFMTaskNode
    | HeadingNode
    | HTMLCommentNode
    | ImageNode
    | LinkNode
    | OrderedListNode
    | UnorderedListNode
    | ParagraphNode
    | ReferenceNode
    | ReferenceCollectionNode
    | TableNode
    | TextNode
    | FormattedTextNode
    | HTMLNode
    | HTMLSelfClosingNode;

type ASTRender = (
    ast: MarkdownToJSX.ASTNode | MarkdownToJSX.ASTNode[],
    state: MarkdownToJSX.State
) => React.ReactNode;

type CreateElement = typeof React.createElement;

type HTMLTags = keyof React.JSX.IntrinsicElements & (string & {});

type Options = Partial<{
    /**
     * Ultimate control over the output of all rendered JSX.
     */
    createElement: (
        tag: Parameters<CreateElement>[0],
        props: React.JSX.IntrinsicAttributes,
        ...children: React.ReactNode[]
    ) => React.ReactNode;
    /**
     * Disable frontmatter detection at the start of the document.
     * When `true`, `---` at position 0 will be parsed as a thematic break
     * instead of being treated as a YAML frontmatter delimiter.
     */
    disableFrontmatter: boolean;
    /**
     * The library automatically generates an anchor tag for bare URLs included in the markdown
     * document, but this behavior can be disabled if desired.
     */
    disableAutoLink: boolean;
    /**
     * Disable the compiler's best-effort transcription of provided raw HTML
     * into JSX-equivalent. This is the functionality that prevents the need to
     * use `dangerouslySetInnerHTML` in React.
     */
    disableParsingRawHTML: boolean;
    /**
     * Disable the compiler's parsing of HTML blocks.
     */
    ignoreHTMLBlocks?: boolean;
    /**
     * Enable GFM tagfilter extension to filter potentially dangerous HTML tags.
     * When enabled, the following tags are escaped: title, textarea, style, xmp,
     * iframe, noembed, noframes, script, plaintext.
     * https://github.github.com/gfm/#disallowed-raw-html-extension-
     * @default true
     */
    tagfilter?: boolean;
    /**
     * Forces the compiler to have space between hash sign and the header text which
     * is explicitly stated in the most of the markdown specs.
     * https://github.github.com/gfm/#atx-heading
     * `The opening sequence of # characters must be followed by a space or by the end of line.`
     */
    enforceAtxHeadings: boolean;
    /**
     * **⚠️ SECURITY WARNING: STRONGLY DISCOURAGED FOR USER INPUTS**
     *
     * When enabled, attempts to eval expressions in JSX props that cannot be serialized
     * as JSON (functions, variables, complex expressions). This uses `eval()` which can
     * execute arbitrary code.
     *
     * **ONLY use this option when:**
     * - The markdown source is completely trusted (e.g., your own documentation)
     * - You control all JSX components and their props
     * - The content is NOT user-generated or user-editable
     *
     * **DO NOT use this option when:**
     * - Processing user-submitted markdown
     * - Rendering untrusted content
     * - Building public-facing applications with user content
     *
     * Example unsafe input: `<Component onClick={() => fetch('/admin/delete-all')} />`
     *
     * When disabled (default), unserializable expressions remain as strings that can be
     * safely inspected or handled on a case-by-case basis via custom renderRule logic.
     *
     * @default false
     */
    evalUnserializableExpressions?: boolean;
    /**
     * Forces the compiler to always output content with a block-level wrapper
     * (`<p>` or any block-level syntax your markdown already contains.)
     */
    forceBlock: boolean;
    /**
     * Forces the compiler to always output content with an inline wrapper (`<span>`)
     */
    forceInline: boolean;
    /**
     * Forces the compiler to wrap results, even if there is only a single
     * child or no children.
     */
    forceWrapper: boolean;
    /**
     * Selectively control the output of particular HTML tags as they would be
     * emitted by the compiler.
     */
    overrides: Overrides;
    /**
     * Allows for full control over rendering of particular rules.
     * For example, to implement a LaTeX renderer such as `react-katex`:
     *
     * ```
     * renderRule(next, node, renderChildren, state) {
     *   if (node.type === RuleType.codeBlock && node.lang === 'latex') {
     *     return (
     *       <TeX as="div" key={state.key}>
     *         {String.raw`${node.text}`}
     *       </TeX>
     *     )
     *   }
     *
     *   return next();
     * }
     * ```
     *
     * Thar be dragons obviously, but you can do a lot with this
     * (have fun!) To see how things work internally, check the `render`
     * method in source for a particular rule.
     */
    renderRule: (
        next: () => React.ReactNode,
        node: ASTNode,
        renderChildren: ASTRender,
        state: State
    ) => React.ReactNode;
    /**
		* Override the built-in sanitizer function for URLs, etc if desired. The built-in version is available as a library
		export called `sanitizer`.
		*/
    sanitizer: (value: string, tag: string, attribute: string) => string | null;
    /**
     * Override normalization of non-URI-safe characters for use in generating
     * HTML IDs for anchor linking purposes.
     */
    slugify: (input: string, defaultFn: (input: string) => string) => string;
    /**
     * Declare the type of the wrapper to be used when there are multiple
     * children to render. Set to `null` to get an array of children back
     * without any wrapper, or use `React.Fragment` to get a React element
     * that won't show up in the DOM.
     */
    wrapper: React.ElementType | null;
    /**
     * Props to apply to the wrapper element.
     */
    wrapperProps?: React.JSX.IntrinsicAttributes;
    /**
     * Preserve frontmatter in the output by rendering it as a <pre> element.
     * By default, frontmatter is parsed but not rendered.
     * @default false
     */
    preserveFrontmatter?: boolean;
    /**
     * Optimize rendering for streaming scenarios where markdown content arrives
     * incrementally (e.g., from LLM APIs). When enabled, incomplete inline syntax
     * is suppressed to avoid displaying raw markdown characters while waiting
     * for the closing delimiter to arrive.
     *
     * Fenced code blocks render normally with content visible as it streams.
     *
     * @default false
     *
     * @example
     * ```tsx
     * // Streaming markdown example
     * function StreamingMarkdown({ content }) {
     *   return (
     *     <Markdown options={{ optimizeForStreaming: true }}>
     *       {content}
     *     </Markdown>
     *   )
     * }
     * ```
     */
    optimizeForStreaming?: boolean;
}>;

type Override =
    | RequireAtLeastOne<{
          component: React.ElementType;
          props: Object;
      }>
    | React.ElementType;

type Overrides = { [tag in HTMLTags]?: Override } & {
    [customComponent: string]: Override;
};

type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<
    T,
    Exclude<keyof T, Keys>
> &
    {
        [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
    }[Keys];

type State = {
    /** true if the current content is inside anchor link grammar */
    inAnchor?: boolean;
    /** true if inside a blockquote */
    inBlockQuote?: boolean;
    /** true if parsing in an HTML context */
    inHTML?: boolean;
    /** true if in a list */
    inList?: boolean;
    /** true if parsing in an inline context (subset of rules around formatting and links) */
    inline?: boolean;
    /** use this for the `key` prop */
    key?: string | number;
    /** reference definitions (footnotes are stored with '^' prefix) */
    refs?: {
        [key: string]: {
            target: string;
            title: string;
        };
    };
    /** current recursion depth during rendering */
    renderDepth?: number;
    /** internal: block parse recursion depth */
    _depth?: number;
    /** internal: disable setext heading detection (lazy blockquote continuation) */
    _noSetext?: boolean;
    /** internal: HTML nesting depth for stack overflow protection */
    _htmlDepth?: number;
    /** internal: set by collectReferenceDefinitions when input ends inside an unclosed fence */
    _endsInsideFence?: boolean;
};

type TextFormattedNode = FormattedTextNode;