markdown-to-jsx

type CreateElement = typeof React.createElement;

type HTMLTags = keyof React.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: 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;
    /**
     * 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.ReactNode,
        /** 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.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;
}>;

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: (typeof Priority)[keyof typeof Priority];
    _parse: MarkdownToJSX.Parser<Omit<ParserOutput, 'type'>>;
    /**
     * Optional fast check that can quickly determine if this rule
     * should even be attempted. Should check the start of the source string
     * for quick patterns without expensive regex operations.
     *
     * @param source The input source string (already trimmed of leading whitespace)
     * @param state Current parser state
     * @returns true if the rule should be attempted, false to skip
     */
    _qualify?: string[] | ((source: string, state: MarkdownToJSX.State) => boolean);
    _render?: (
        node: ParserOutput,
        /**
         * Continue rendering AST nodes if applicable.
         */
        render: RuleOutput,
        state?: MarkdownToJSX.State
    ) => React.ReactNode;
};

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

type Rules = {
    [K in ParserResult['type']]: K extends typeof RuleType.table
        ? Rule<
              Extract<
                  ParserResult,
                  {
                      type: K | typeof 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;
    /** used for lookbacks */
    prevCapture?: string;
    /** true if parsing in inline context w/o links */
    simple?: boolean;
};