markdown-to-jsx 8.0.0 → 9.0.0

package/dist/index.d.ts

@@ -1,412 +1,342 @@
+import * as React2 from "react";
+import * as React from "react";
 /**
- * markdown-to-jsx is a fork of
- * [simple-markdown v0.2.2](https://github.com/Khan/simple-markdown)
- * from Khan Academy. Thank you Khan devs for making such an awesome
- * and extensible parsing infra... without it, half of the
- * optimizations here wouldn't be feasible. 🙏🏼
- */
-import * as React from 'react';
-import { type RuleType as RuleTypeValue } from './match';
-export declare const RuleType: {
-    readonly blockQuote: "0";
-    readonly breakLine: "1";
-    readonly breakThematic: "2";
-    readonly codeBlock: "3";
-    readonly codeFenced: "4";
-    readonly codeInline: "5";
-    readonly footnote: "6";
-    readonly footnoteReference: "7";
-    readonly gfmTask: "8";
-    readonly heading: "9";
-    readonly headingSetext: "10";
-    readonly htmlBlock: "11";
-    readonly htmlComment: "12";
-    readonly htmlSelfClosing: "13";
-    readonly image: "14";
-    readonly link: "15";
-    readonly linkAngleBraceStyleDetector: "16";
-    readonly linkBareUrlDetector: "17";
-    readonly linkMailtoDetector: "18";
-    readonly newlineCoalescer: "19";
-    readonly orderedList: "20";
-    readonly paragraph: "21";
-    readonly ref: "22";
-    readonly refImage: "23";
-    readonly refLink: "24";
-    readonly table: "25";
-    readonly tableSeparator: "26";
-    readonly text: "27";
-    readonly textEscaped: "28";
-    readonly textFormatted: "34";
-    readonly unorderedList: "30";
+* Analogous to `node.type`. Please note that the values here may change at any time,
+* so do not hard code against the value directly.
+*/
+declare const RuleTypeConst: {
+	readonly blockQuote: 0;
+	readonly breakLine: 1;
+	readonly breakThematic: 2;
+	readonly codeBlock: 3;
+	readonly codeInline: 4;
+	readonly footnote: 5;
+	readonly footnoteReference: 6;
+	readonly frontmatter: 7;
+	readonly gfmTask: 8;
+	readonly heading: 9;
+	readonly htmlBlock: 10;
+	readonly htmlComment: 11;
+	readonly htmlSelfClosing: 12;
+	readonly image: 13;
+	readonly link: 14;
+	readonly orderedList: 15;
+	readonly paragraph: 16;
+	readonly ref: 17;
+	readonly refCollection: 18;
+	readonly table: 19;
+	readonly text: 20;
+	readonly textFormatted: 21;
+	readonly unorderedList: 22;
 };
-export type RuleType = RuleTypeValue;
-declare const Priority: {
-    /**
-     * anything that must scan the tree before everything else
-     */
-    MAX: number;
-    /**
-     * scans for block-level constructs
-     */
-    HIGH: number;
-    /**
-     * inline w/ more priority than other inline
-     */
-    MED: number;
-    /**
-     * inline elements
-     */
-    LOW: number;
-    /**
-     * bare text and stuff that is considered leftovers
-     */
-    MIN: number;
-};
-export declare function slugify(str: string): string;
-export declare function sanitizer(input: string): string;
-export declare function compiler(markdown: string, options: MarkdownToJSX.Options & {
-    wrapper: null;
-}): React.ReactNode[];
-export declare function compiler(markdown: string, options?: MarkdownToJSX.Options): React.JSX.Element;
+type RuleTypeValue = (typeof RuleTypeConst)[keyof typeof RuleTypeConst];
 /**
- * A simple HOC for easy React use. Feed the markdown content as a direct child
- * and the rest is taken care of automatically.
- */
-declare const Markdown: React.FC<Omit<React.HTMLAttributes<Element>, 'children'> & {
-    children?: string | null;
-    options?: MarkdownToJSX.Options;
-}>;
-export declare namespace MarkdownToJSX {
-    /**
-     * RequireAtLeastOne<{ ... }> <- only requires at least one key
-     */
-    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];
-    export type CreateElement = typeof React.createElement;
-    export type HTMLTags = keyof React.JSX.IntrinsicElements;
-    export type State = {
-        /** true if the current content is inside anchor link grammar */
-        inAnchor?: boolean;
-        /** true if parsing in an HTML context */
-        inHTML?: 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;
-        /** current recursion depth during rendering */
-        renderDepth?: number;
-    };
-    export interface BlockQuoteNode {
-        alert?: string;
-        children: MarkdownToJSX.ASTNode[];
-        type: typeof RuleType.blockQuote;
-    }
-    export interface BreakLineNode {
-        type: typeof RuleType.breakLine;
-    }
-    export interface BreakThematicNode {
-        type: typeof RuleType.breakThematic;
-    }
-    export interface CodeBlockNode {
-        type: typeof RuleType.codeBlock;
-        attrs?: React.JSX.IntrinsicAttributes;
-        lang?: string;
-        text: string;
-    }
-    export interface CodeFencedNode {
-        type: typeof RuleType.codeFenced;
-    }
-    export interface CodeInlineNode {
-        type: typeof RuleType.codeInline;
-        text: string;
-    }
-    export interface FootnoteNode {
-        type: typeof RuleType.footnote;
-    }
-    export interface FootnoteReferenceNode {
-        type: typeof RuleType.footnoteReference;
-        target: string;
-        text: string;
-    }
-    export interface GFMTaskNode {
-        type: typeof RuleType.gfmTask;
-        completed: boolean;
-    }
-    export interface HeadingNode {
-        type: typeof RuleType.heading;
-        children: MarkdownToJSX.ASTNode[];
-        id: string;
-        level: 1 | 2 | 3 | 4 | 5 | 6;
-    }
-    export interface HeadingSetextNode {
-        type: typeof RuleType.headingSetext;
-    }
-    export interface HTMLCommentNode {
-        type: typeof RuleType.htmlComment;
-    }
-    export interface ImageNode {
-        type: typeof RuleType.image;
-        alt?: string;
-        target: string;
-        title?: string;
-    }
-    export interface LinkNode {
-        type: typeof RuleType.link;
-        children: MarkdownToJSX.ASTNode[];
-        target: string;
-        title?: string;
-    }
-    export interface LinkAngleBraceNode {
-        type: typeof RuleType.linkAngleBraceStyleDetector;
-    }
-    export interface LinkBareURLNode {
-        type: typeof RuleType.linkBareUrlDetector;
-    }
-    export interface LinkMailtoNode {
-        type: typeof RuleType.linkMailtoDetector;
-    }
-    export interface OrderedListNode {
-        type: typeof RuleType.orderedList;
-        items: MarkdownToJSX.ASTNode[][];
-        ordered: true;
-        start?: number;
-    }
-    export interface UnorderedListNode {
-        type: typeof RuleType.unorderedList;
-        items: MarkdownToJSX.ASTNode[][];
-        ordered: false;
-    }
-    export interface NewlineNode {
-        type: typeof RuleType.newlineCoalescer;
-    }
-    export interface ParagraphNode {
-        type: typeof RuleType.paragraph;
-        children: MarkdownToJSX.ASTNode[];
-    }
-    export interface ReferenceNode {
-        type: typeof RuleType.ref;
-    }
-    export interface ReferenceImageNode {
-        type: typeof RuleType.refImage;
-        alt?: string;
-        ref: string;
-    }
-    export interface ReferenceLinkNode {
-        type: typeof RuleType.refLink;
-        children: MarkdownToJSX.ASTNode[];
-        fallbackChildren: string;
-        ref: string;
-    }
-    export interface TableNode {
-        type: typeof RuleType.table;
-        /**
-         * alignment for each table column
-         */
-        align: ('left' | 'right' | 'center')[];
-        cells: MarkdownToJSX.ASTNode[][][];
-        header: MarkdownToJSX.ASTNode[][];
-    }
-    export interface TableSeparatorNode {
-        type: typeof RuleType.tableSeparator;
-    }
-    export interface TextNode {
-        type: typeof RuleType.text;
-        text: string;
-    }
-    export interface FormattedTextNode {
-        type: typeof RuleType.textFormatted;
-        /**
-         * the corresponding html tag
-         */
-        tag: string;
-        children: MarkdownToJSX.ASTNode[];
-    }
-    export interface EscapedTextNode {
-        type: typeof RuleType.textEscaped;
-    }
-    export interface HTMLNode {
-        type: typeof RuleType.htmlBlock;
-        attrs: React.JSX.IntrinsicAttributes;
-        children?: ReturnType<MarkdownToJSX.NestedParser> | undefined;
-        noInnerParse: Boolean;
-        tag: MarkdownToJSX.HTMLTags;
-        text?: string | undefined;
-    }
-    export interface HTMLSelfClosingNode {
-        type: typeof RuleType.htmlSelfClosing;
-        attrs: React.JSX.IntrinsicAttributes;
-        tag: string;
-    }
-    export type ASTNode = 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 | FormattedTextNode | EscapedTextNode | HTMLNode | HTMLSelfClosingNode;
-    export type NestedParser = (input: string, state?: MarkdownToJSX.State) => MarkdownToJSX.ASTNode[];
-    export type Parser<ParserOutput> = (capture: RegExpMatchArray, nestedParse: NestedParser, state?: MarkdownToJSX.State) => ParserOutput;
-    export type RuleOutput = (ast: MarkdownToJSX.ASTNode | MarkdownToJSX.ASTNode[], state: MarkdownToJSX.State) => React.ReactNode;
-    export type Rule<ParserOutput = MarkdownToJSX.ASTNode> = {
-        _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;
-    };
-    export type Rules = {
-        [K in ASTNode['type']]: K extends typeof RuleType.table ? Rule<Extract<ASTNode, {
-            type: K | typeof RuleType.paragraph;
-        }>> : Rule<Extract<ASTNode, {
-            type: K;
-        }>>;
-    };
-    export type Override = RequireAtLeastOne<{
-        component: React.ElementType;
-        props: Object;
-    }> | React.ElementType;
-    export type Overrides = {
-        [tag in HTMLTags]?: Override;
-    } & {
-        [customComponent: string]: Override;
-    };
-    export type Options = Partial<{
-        /**
-         * When true, returns the parsed AST instead of rendered JSX.
-         * Footnotes are not automatically appended; the consumer handles them.
-         */
-        ast: boolean;
-        /**
-         * 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: ASTNode, 
-        /** 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;
-        /**
-         * Props to apply to the wrapper element.
-         */
-        wrapperProps?: React.JSX.IntrinsicAttributes;
-    }>;
-    export {};
+* markdown-to-jsx types and interfaces
+*/
+declare namespace MarkdownToJSX {
+	/**
+	* RequireAtLeastOne<{ ... }> <- only requires at least one key
+	*/
+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 CreateElement = typeof React.createElement;
+	type HTMLTags = keyof React.JSX.IntrinsicElements & (string & {});
+	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;
+	};
+	interface BlockQuoteNode {
+		alert?: string;
+		children: MarkdownToJSX.ASTNode[];
+		type: typeof RuleType2.blockQuote;
+	}
+	interface BreakLineNode {
+		type: typeof RuleType2.breakLine;
+	}
+	interface BreakThematicNode {
+		type: typeof RuleType2.breakThematic;
+	}
+	interface CodeBlockNode {
+		type: typeof RuleType2.codeBlock;
+		attrs?: React.JSX.IntrinsicAttributes;
+		lang?: string;
+		text: string;
+	}
+	interface CodeInlineNode {
+		type: typeof RuleType2.codeInline;
+		text: string;
+	}
+	interface FootnoteNode {
+		type: typeof RuleType2.footnote;
+	}
+	interface FootnoteReferenceNode {
+		type: typeof RuleType2.footnoteReference;
+		target: string;
+		text: string;
+	}
+	interface FrontmatterNode {
+		type: typeof RuleType2.frontmatter;
+		text: string;
+	}
+	interface GFMTaskNode {
+		type: typeof RuleType2.gfmTask;
+		completed: boolean;
+	}
+	interface HeadingNode {
+		type: typeof RuleType2.heading;
+		children: MarkdownToJSX.ASTNode[];
+		id: string;
+		level: 1 | 2 | 3 | 4 | 5 | 6;
+	}
+	interface HTMLCommentNode {
+		type: typeof RuleType2.htmlComment;
+		text: string;
+	}
+	interface ImageNode {
+		type: typeof RuleType2.image;
+		alt?: string;
+		target: string;
+		title?: string;
+	}
+	interface LinkNode {
+		type: typeof RuleType2.link;
+		children: MarkdownToJSX.ASTNode[];
+		target: string | null;
+		title?: string;
+	}
+	interface OrderedListNode {
+		type: typeof RuleType2.orderedList;
+		items: MarkdownToJSX.ASTNode[][];
+		start?: number;
+	}
+	interface UnorderedListNode {
+		type: typeof RuleType2.unorderedList;
+		items: MarkdownToJSX.ASTNode[][];
+	}
+	interface ParagraphNode {
+		type: typeof RuleType2.paragraph;
+		children: MarkdownToJSX.ASTNode[];
+	}
+	interface ReferenceNode {
+		type: typeof RuleType2.ref;
+	}
+	interface ReferenceCollectionNode {
+		type: typeof RuleType2.refCollection;
+		refs: {
+			[key: string]: {
+				target: string;
+				title: string | undefined;
+			};
+		};
+	}
+	interface TableNode {
+		type: typeof RuleType2.table;
+		/**
+		* alignment for each table column
+		*/
+		align: ("left" | "right" | "center")[];
+		cells: MarkdownToJSX.ASTNode[][][];
+		header: MarkdownToJSX.ASTNode[][];
+	}
+	interface TextNode {
+		type: typeof RuleType2.text;
+		text: string;
+	}
+	interface FormattedTextNode {
+		type: typeof RuleType2.textFormatted;
+		/**
+		* the corresponding html tag
+		*/
+		tag: string;
+		children: MarkdownToJSX.ASTNode[];
+	}
+	interface HTMLNode {
+		type: typeof RuleType2.htmlBlock;
+		attrs?: Record<string, any>;
+		children?: ASTNode[] | undefined;
+		noInnerParse?: Boolean;
+		tag: string;
+		text?: string | undefined;
+	}
+	interface HTMLSelfClosingNode {
+		type: typeof RuleType2.htmlSelfClosing;
+		attrs?: Record<string, any>;
+		isClosingTag?: boolean;
+		tag: string;
+	}
+	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 Override = RequireAtLeastOne<{
+		component: React.ElementType;
+		props: Object;
+	}> | React.ElementType;
+	type Overrides = { [tag in HTMLTags]? : Override } & {
+		[customComponent: string]: Override;
+	};
+	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
+		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;
+	}>;
+	{}
+	;
+}
+declare const RuleType2: typeof RuleTypeConst;
+type RuleType2 = RuleTypeValue;
+declare global {
+	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;
+	} | null;
+	var parseMetricsStartTimes: Map<string, number> | null;
 }
-export default Markdown;
+/**
+* Given a markdown string, return an abstract syntax tree (AST) of the markdown.
+*
+* The first node in the AST is a reference collection node. This node contains all the
+* reference definitions found in the markdown. These reference definitions are used to
+* resolve reference links and images in the markdown.
+*
+* @param source - The markdown string to parse.
+* @param options - The options for the parser.
+* @returns The AST of the markdown.
+*/
+declare function parser(source: string, options?: MarkdownToJSX.Options): MarkdownToJSX.ASTNode[];
+declare function sanitizer(input: string): string | null;
+declare function slugify(str: string): string;
+declare function compiler(markdown?: string, options?: MarkdownToJSX.Options): React2.ReactNode;
+/**
+* A simple HOC for easy React use. Feed the markdown content as a direct child
+* and the rest is taken care of automatically.
+*/
+declare const Markdown: React2.FC<Omit<React2.HTMLAttributes<Element>, "children"> & {
+	children?: string | null;
+	options?: MarkdownToJSX.Options;
+}>;
+export { slugify, sanitizer, parser, Markdown as default, compiler, RuleType2 as RuleType, MarkdownToJSX, Markdown };