markdown-to-jsx

var parseMetrics: {
    blockParsers: {
        [key: string]: { attempts: number; hits: number; hitTimings: number[] };
    };
    inlineParsers: {
        [key: string]: { attempts: number; hits: number; hitTimings: number[] };
    };
    totalOperations: number;
    blockParseIterations: number;
    inlineParseIterations: number;
};

var parseMetricsStartTimes: Map<string, number>;

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;
    /**
     * 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;
    /**
     * 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;
    /**
     * 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: HTMLTags, 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;
}>;

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?: React.Key;
    /** reference definitions (footnotes are stored with '^' prefix) */
    refs?: {
        [key: string]: {
            target: string;
            title: string | undefined;
        };
    };
    /** current recursion depth during rendering */
    renderDepth?: number;
};