markdown-to-jsx

blockQuote = '0'

breakLine = '1'

breakThematic = '2'

codeBlock = '3'

codeFenced = '4'

codeInline = '5'

footnote = '6'

footnoteReference = '7'

gfmTask = '8'

heading = '9'

headingSetext = '10'

htmlBlock = '11'

htmlComment = '12'

htmlSelfClosing = '13'

image = '14'

link = '15'

linkAngleBraceStyleDetector = '16'

linkBareUrlDetector = '17'

linkMailtoDetector = '18'

newlineCoalescer = '19'

orderedList = '20'

paragraph = '21'

ref = '22'

refImage = '23'

refLink = '24'

table = '25'

tableSeparator = '26'

text = '27'

textBolded = '28'

textEmphasized = '29'

textEscaped = '30'

textMarked = '31'

textStrikethroughed = '32'

unorderedList = '33'

type CreateElement = typeof React.createElement;

type HTMLTags = keyof JSX.IntrinsicElements;

type NestedParser = (
    input: string,
    state?: MarkdownToJSX.State
) => MarkdownToJSX.ParserResult[];

type Options = Partial<{
    /**
     * Ultimate control over the output of all rendered JSX.
     */
    createElement: (
        tag: Parameters<CreateElement>[0],
        props: JSX.IntrinsicAttributes,
        ...children: React.ReactChild[]
    ) => React.ReactChild;
    /**
     * 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;
    /**
     * 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;
    /**
     * Supply additional HTML entity: unicode replacement mappings.
     *
     * Pass only the inner part of the entity as the key,
     * e.g. `&le;` -> `{ "le": "\u2264" }`
     *
     * By default
     * the following entities are replaced with their unicode equivalents:
     *
     * ```
     * &amp;
     * &apos;
     * &gt;
     * &lt;
     * &nbsp;
     * &quot;
     * ```
     */
    namedCodesToUnicode: {
        [key: string]: string;
    };
    /**
     * 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: (
        /** Resume normal processing, call this function as a fallback if you are not returning custom JSX. */
        next: () => React.ReactChild,
        /** the current AST node, use `RuleType` against `node.type` for identification */
        node: ParserResult,
        /** use as `renderChildren(node.children)` for block nodes */
        renderChildren: RuleOutput,
        /** contains `key` which should be supplied to the topmost JSX element */
        state: State
    ) => React.ReactChild;
    /**
     * Override normalization of non-URI-safe characters for use in generating
     * HTML IDs for anchor linking purposes.
     */
    slugify: (source: 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;
}>;

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

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

type Parser<ParserOutput> = (
    capture: RegExpMatchArray,
    nestedParse: NestedParser,
    state?: MarkdownToJSX.State
) => ParserOutput;

type ParserResult =
    | BlockQuoteNode
    | BreakLineNode
    | BreakThematicNode
    | CodeBlockNode
    | CodeFencedNode
    | CodeInlineNode
    | FootnoteNode
    | FootnoteReferenceNode
    | GFMTaskNode
    | HeadingNode
    | HeadingSetextNode
    | HTMLCommentNode
    | ImageNode
    | LinkNode
    | LinkAngleBraceNode
    | LinkBareURLNode
    | LinkMailtoNode
    | OrderedListNode
    | UnorderedListNode
    | NewlineNode
    | ParagraphNode
    | ReferenceNode
    | ReferenceImageNode
    | ReferenceLinkNode
    | TableNode
    | TableSeparatorNode
    | TextNode
    | BoldTextNode
    | ItalicTextNode
    | EscapedTextNode
    | MarkedTextNode
    | StrikethroughTextNode
    | HTMLNode
    | HTMLSelfClosingNode;

type Rule<ParserOutput = MarkdownToJSX.ParserResult> = {
    match: (
        source: string,
        state: MarkdownToJSX.State,
        prevCapturedString?: string
    ) => RegExpMatchArray;
    order: Priority;
    parse: MarkdownToJSX.Parser<Omit<ParserOutput, 'type'>>;
    render?: (
        node: ParserOutput,
        /**
         * Continue rendering AST nodes if applicable.
         */
        render: RuleOutput,
        state?: MarkdownToJSX.State
    ) => React.ReactChild;
};

type RuleOutput = (
    ast: MarkdownToJSX.ParserResult | MarkdownToJSX.ParserResult[],
    state: MarkdownToJSX.State
) => JSX.Element;

type Rules = {
    [K in ParserResult['type']]: K extends RuleType.table
        ? Rule<
              Extract<
                  ParserResult,
                  {
                      type: K | RuleType.paragraph;
                  }
              >
          >
        : Rule<
              Extract<
                  ParserResult,
                  {
                      type: K;
                  }
              >
          >;
};

type State = {
    /** true if the current content is inside anchor link grammar */
    inAnchor?: boolean;
    /** true if parsing in an inline context (subset of rules around formatting and links) */
    inline?: boolean;
    /** true if in a table */
    inTable?: boolean;
    /** use this for the `key` prop */
    key?: React.Key;
    /** true if in a list */
    list?: boolean;
    /** true if parsing in inline context w/o links */
    simple?: boolean;
};