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.
     * @lang zh 对所有渲染的 JSX 输出的最终控制。
     * @lang hi सभी रेंडर किए गए 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.
     * @lang zh 库会自动为 Markdown 文档中包含的裸 URL 生成锚点标签，但可以根据需要禁用此行为。
     * @lang hi लाइब्रेरी markdown दस्तावेज़ में शामिल नंगे URLs के लिए स्वचालित रूप से एक एंकर टैग जेनरेट करती है, लेकिन यदि वांछित हो तो इस व्यवहार को अक्षम किया जा सकता है।
     */
    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.
     * @lang zh 禁用编译器将提供的原始 HTML 转换为 JSX 等效项的最佳努力。此功能可避免在 React 中使用 `dangerouslySetInnerHTML`。
     * @lang hi कंपाइलर के प्रदान किए गए raw HTML को JSX-समतुल्य में ट्रांसक्राइब करने के सर्वोत्तम प्रयास को अक्षम करें। यह वह कार्यक्षमता है जो React में `dangerouslySetInnerHTML` का उपयोग करने की आवश्यकता को रोकती है।
     */
    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-
     * @lang zh 启用 GFM tagfilter 扩展以过滤潜在危险的 HTML 标签。启用后，以下标签将被转义：title、textarea、style、xmp、iframe、noembed、noframes、script、plaintext。
     * @lang hi संभावित खतरनाक HTML टैग्स को फ़िल्टर करने के लिए GFM tagfilter एक्सटेंशन सक्षम करें। सक्षम होने पर, निम्नलिखित टैग्स एस्केप किए जाते हैं: title, textarea, style, xmp, iframe, noembed, noframes, script, plaintext।
     * @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.`
     * @lang zh 强制编译器在井号和标题文本之间有空格，这在大多数 Markdown 规范中都有明确规定。
     * @lang hi कंपाइलर को हैश चिह्न और हेडर टेक्स्ट के बीच स्थान रखने के लिए बाध्य करता है, जो अधिकांश markdown विनिर्देशों में स्पष्ट रूप से कहा गया है。
     */
    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.
     *
     * @lang zh **⚠️ 安全警告：强烈建议不要用于用户输入**
     *
     * 启用后，尝试计算 JSX 属性中无法序列化为 JSON 的表达式（函数、变量、复杂表达式）。这使用 `eval()`，可能会执行任意代码。
     *
     * **仅在以下情况下使用此选项：**
     * - Markdown 源完全可信（例如，您自己的文档）
     * - 您控制所有 JSX 组件及其属性
     * - 内容不是用户生成或用户可编辑的
     *
     * **在以下情况下不要使用此选项：**
     * - 处理用户提交的 Markdown
     * - 渲染不可信内容
     * - 构建面向公众的用户内容应用程序
     *
     * 不安全的输入示例：`<Component onClick={() => fetch('/admin/delete-all')} />`
     *
     * 禁用时（默认），不可序列化的表达式保持为字符串，可以通过自定义 renderRule 逻辑安全地检查或逐例处理。
     *
     * @lang hi **⚠️ सुरक्षा चेतावनी: उपयोगकर्ता इनपुट के लिए अत्यधिक हतोत्साहित**
     *
     * सक्षम होने पर, JSX props में expressions को eval करने का प्रयास करता है जिन्हें JSON के रूप में सीरियलाइज़ नहीं किया जा सकता है (फ़ंक्शन, वेरिएबल, जटिल expressions)। यह `eval()` का उपयोग करता है जो मनमाने कोड को निष्पादित कर सकता है।
     *
     * **केवल निम्नलिखित स्थितियों में इस विकल्प का उपयोग करें:**
     * - Markdown स्रोत पूरी तरह से विश्वसनीय है (उदाहरण के लिए, आपका अपना दस्तावेज़ीकरण)
     * - आप सभी JSX कंपोनेंट्स और उनके props को नियंत्रित करते हैं
     * - सामग्री उपयोगकर्ता-जनित या उपयोगकर्ता-संपादन योग्य नहीं है
     *
     * **निम्नलिखित स्थितियों में इस विकल्प का उपयोग न करें:**
     * - उपयोगकर्ता-सबमिट किए गए markdown को प्रोसेस कर रहे हों
     * - अविश्वसनीय सामग्री रेंडर कर रहे हों
     * - उपयोगकर्ता सामग्री वाले सार्वजनिक-सामना करने वाले एप्लिकेशन बना रहे हों
     *
     * असुरक्षित इनपुट उदाहरण: `<Component onClick={() => fetch('/admin/delete-all')} />`
     *
     * अक्षम होने पर (डिफ़ॉल्ट), अनसीरियलाइज़ेबल expressions स्ट्रिंग्स के रूप में रहते हैं जिन्हें कस्टम renderRule लॉजिक के माध्यम से सुरक्षित रूप से जांचा जा सकता है या केस-बाई-केस हैंडल किया जा सकता है।
     *
     * @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.)
     * @lang zh 强制编译器始终使用块级包装器输出内容（`<p>` 或您的 Markdown 已包含的任何块级语法）。
     * @lang hi कंपाइलर को हमेशा ब्लॉक-स्तरीय रैपर के साथ सामग्री आउटपुट करने के लिए बाध्य करता है (`<p>` या आपके markdown में पहले से मौजूद कोई भी ब्लॉक-स्तरीय सिंटैक्स)।
     */
    forceBlock: boolean;
    /**
     * Forces the compiler to always output content with an inline wrapper (`<span>`)
     * @lang zh 强制编译器始终使用内联包装器（`<span>`）输出内容
     * @lang hi कंपाइलर को हमेशा इनलाइन रैपर (`<span>`) के साथ सामग्री आउटपुट करने के लिए बाध्य करता है
     */
    forceInline: boolean;
    /**
     * Forces the compiler to wrap results, even if there is only a single
     * child or no children.
     * @lang zh 强制编译器包装结果，即使只有一个子元素或没有子元素。
     * @lang hi कंपाइलर को परिणामों को रैप करने के लिए बाध्य करता है, भले ही केवल एक चाइल्ड हो या कोई चाइल्ड न हो।
     */
    forceWrapper: boolean;
    /**
     * Selectively control the output of particular HTML tags as they would be
     * emitted by the compiler.
     * @lang zh 选择性地控制特定 HTML 标签的输出，就像编译器会发出的一样。
     * @lang hi चुनिंदा रूप से विशिष्ट HTML टैग्स के आउटपुट को नियंत्रित करें जैसा कि कंपाइलर द्वारा उत्सर्जित किया जाएगा।
     */
    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.
     * @lang zh 允许完全控制特定规则的渲染。例如，要实现像 `react-katex` 这样的 LaTeX 渲染器：
     *
     * 显然有风险，但您可以用它做很多事情（玩得开心！）要了解内部工作原理，请查看源代码中特定规则的 `render` 方法。
     * @lang hi विशिष्ट नियमों के रेंडरिंग पर पूर्ण नियंत्रण की अनुमति देता है। उदाहरण के लिए, `react-katex` जैसे LaTeX रेंडरर को लागू करने के लिए:
     *
     * स्पष्ट रूप से जोखिम हैं, लेकिन आप इसके साथ बहुत कुछ कर सकते हैं (मज़े करें!) आंतरिक रूप से चीजें कैसे काम करती हैं यह देखने के लिए, किसी विशिष्ट नियम के लिए स्रोत में `render` विधि देखें।
     */
    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`.
		* @lang zh 如果需要，覆盖内置的 URL 清理函数等。内置版本可作为名为 `sanitizer` 的库导出使用。
		* @lang hi यदि वांछित हो तो URLs आदि के लिए बिल्ट-इन सैनिटाइज़र फ़ंक्शन को ओवरराइड करें। बिल्ट-इन संस्करण `sanitizer` नामक लाइब्रेरी export के रूप में उपलब्ध है।
		*/
    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.
     * @lang zh 覆盖非 URI 安全字符的规范化，用于生成用于锚点链接的 HTML ID。
     * @lang hi एंकर लिंकिंग उद्देश्यों के लिए HTML IDs जेनरेट करने में उपयोग के लिए गैर-URI-सुरक्षित वर्णों के सामान्यीकरण को ओवरराइड करें।
     */
    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.
     * @lang zh 声明在有多个子元素要渲染时使用的包装器类型。设置为 `null` 以在没有包装器的情况下返回子元素数组，或使用 `React.Fragment` 获取不会出现在 DOM 中的 React 元素。
     * @lang hi रैपर के प्रकार को घोषित करें जब कई children को रेंडर करना हो। बिना किसी रैपर के children की एक सरणी वापस पाने के लिए `null` पर सेट करें, या DOM में दिखाई न देने वाला React एलिमेंट प्राप्त करने के लिए `React.Fragment` का उपयोग करें।
     */
    wrapper: React.ElementType | null;
    /**
     * Props to apply to the wrapper element.
     * @lang zh 应用于包装元素的属性。
     * @lang hi रैपर एलिमेंट पर लागू करने के लिए props।
     */
    wrapperProps?: React.JSX.IntrinsicAttributes;
    /**
     * Preserve frontmatter in the output by rendering it as a <pre> element.
     * By default, frontmatter is parsed but not rendered.
     * @lang zh 通过将其渲染为 <pre> 元素来保留输出中的前置元数据。默认情况下，前置元数据会被解析但不会渲染。
     * @lang hi इसे <pre> एलिमेंट के रूप में रेंडर करके आउटपुट में फ्रंटमैटर को संरक्षित करें। डिफ़ॉल्ट रूप से, फ्रंटमैटर को पार्स किया जाता है लेकिन रेंडर नहीं किया जाता है।
     * @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 */
    /** @lang zh 如果当前内容在锚点链接语法内，则为 true */
    /** @lang hi true यदि वर्तमान सामग्री एंकर लिंक व्याकरण के अंदर है */
    inAnchor?: boolean;
    /** true if inside a blockquote */
    /** @lang zh 如果在引用块内，则为 true */
    /** @lang hi true यदि ब्लॉककोट के अंदर है */
    inBlockQuote?: boolean;
    /** true if parsing in an HTML context */
    /** @lang zh 如果在 HTML 上下文中解析，则为 true */
    /** @lang hi true यदि HTML संदर्भ में पार्स कर रहे हैं */
    inHTML?: boolean;
    /** true if in a list */
    /** @lang zh 如果在列表中，则为 true */
    /** @lang hi true यदि सूची में है */
    inList?: boolean;
    /** true if parsing in an inline context (subset of rules around formatting and links) */
    /** @lang zh 如果在内联上下文中解析（围绕格式和链接的规则子集），则为 true */
    /** @lang hi true यदि इनलाइन संदर्भ में पार्स कर रहे हैं (फ़ॉर्मेटिंग और लिंक के आसपास के नियमों का उपसमुच्चय) */
    inline?: boolean;
    /** use this for the `key` prop */
    /** @lang zh 用于 `key` 属性 */
    /** @lang hi `key` prop के लिए इसका उपयोग करें */
    key?: string | number;
    /** reference definitions (footnotes are stored with '^' prefix) */
    /** @lang zh 引用定义（脚注以 '^' 前缀存储） */
    /** @lang hi संदर्भ परिभाषाएं (फ़ुटनोट्स '^' उपसर्ग के साथ संग्रहीत हैं) */
    refs?: {
        [key: string]: {
            target: string;
            title: string | undefined;
        };
    };
    /** current recursion depth during rendering */
    /** @lang zh 渲染期间的当前递归深度 */
    /** @lang hi रेंडरिंग के दौरान वर्तमान पुनरावृत्ति गहराई */
    renderDepth?: number;
};