@ai-matrx/rich-content 0.0.0-stage → 0.2.2

package/dist/markdown-core/MarkdownCoreServer.js

@@ -0,0 +1,26 @@
+import { jsx } from "react/jsx-runtime";
+import "server-only";
+import ReactMarkdown from "react-markdown";
+import "katex/dist/katex.min.css";
+import { MARKDOWN_PRESETS, prepareCoreSource, rehypeWithNumbering, remarkWithNumbering } from "./markdown-core-presets.js";
+import { withCoreSyntaxElements } from "./syntax/elements/core-syntax-elements.js";
+function MarkdownCoreServer({
+  children,
+  preset = "gfm",
+  components,
+  numbering
+}) {
+  const plugins = MARKDOWN_PRESETS[preset];
+  return /* @__PURE__ */ jsx(
+    ReactMarkdown,
+    {
+      remarkPlugins: remarkWithNumbering(plugins.remark, numbering),
+      rehypePlugins: rehypeWithNumbering(plugins.rehype, numbering),
+      components: withCoreSyntaxElements(components),
+      children: prepareCoreSource(children, preset, numbering)
+    }
+  );
+}
+export {
+  MarkdownCoreServer as default
+};

package/dist/markdown-core/heading-anchors-context.d.ts

@@ -0,0 +1,2 @@
+export declare const HeadingAnchorsProvider: import("react").Provider<boolean>;
+export declare function useHeadingAnchors(): boolean;

package/dist/markdown-core/heading-anchors-context.js

@@ -0,0 +1,11 @@
+"use client";
+import { createContext, useContext } from "react";
+const HeadingAnchorsContext = createContext(true);
+const HeadingAnchorsProvider = HeadingAnchorsContext.Provider;
+function useHeadingAnchors() {
+  return useContext(HeadingAnchorsContext);
+}
+export {
+  HeadingAnchorsProvider,
+  useHeadingAnchors
+};

package/dist/markdown-core/heading-anchors-props.d.ts

@@ -0,0 +1,2 @@
+/** True for the element props of a heading hover anchor. */
+export declare function isHeadingAnchorProps(props: object): boolean;

package/dist/markdown-core/heading-anchors-props.js

@@ -0,0 +1,6 @@
+function isHeadingAnchorProps(props) {
+  return "data-heading-anchor" in props;
+}
+export {
+  isHeadingAnchorProps
+};

package/dist/markdown-core/markdown-core-html.d.ts

@@ -0,0 +1,3 @@
+import type { Root } from "hast";
+/** Markdown → the core's HTML tree (unsanitized; sanitize before serializing). */
+export declare function markdownToHast(markdown: string): Root;

package/dist/markdown-core/markdown-core-html.js

@@ -0,0 +1,33 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remarkRehype from "remark-rehype";
+import rehypeRaw from "rehype-raw";
+import { MARKDOWN_PRESETS, prepareCoreSource } from "./markdown-core-presets.js";
+const PRESET = "gfm";
+const processor = unified().use(remarkParse).use(MARKDOWN_PRESETS[PRESET].remark ?? []).use(remarkRehype, { allowDangerousHtml: true }).use(rehypeRaw).use(MARKDOWN_PRESETS[PRESET].rehype ?? []);
+const HEADING = /^h[1-6]$/;
+function dropHeadingAnchors(nodes) {
+  return nodes.filter((node) => {
+    if (node.type !== "element" || node.tagName !== "a") return true;
+    const href = String(node.properties?.href ?? "");
+    return !(href.startsWith("#") && node.children.length === 0);
+  }).map((node) => {
+    if (node.type === "element") {
+      const id = node.properties?.id;
+      if (HEADING.test(node.tagName) && typeof id === "string" && id.startsWith("user-content-")) {
+        delete node.properties.id;
+      }
+      node.children = dropHeadingAnchors(node.children);
+    }
+    return node;
+  });
+}
+function markdownToHast(markdown) {
+  const source = prepareCoreSource(markdown, PRESET);
+  const tree = processor.runSync(processor.parse(source));
+  tree.children = dropHeadingAnchors(tree.children);
+  return tree;
+}
+export {
+  markdownToHast
+};

package/dist/markdown-core/markdown-core-presets.d.ts

@@ -0,0 +1,22 @@
+import "katex/contrib/mhchem";
+import type { DocumentNumbering } from "./syntax/document-numbering.js";
+import type { Options } from "react-markdown";
+import type { MarkdownPreset } from "./markdown-core-types.js";
+export type MarkdownPluginSet = {
+    remark: Options["remarkPlugins"];
+    rehype: Options["rehypePlugins"];
+    /** Math-capable presets run the ONE math normalizer on their source. */
+    math: boolean;
+};
+/** Module-scope arrays so plugin identity is stable across renders. */
+export declare const MARKDOWN_PRESETS: Record<MarkdownPreset, MarkdownPluginSet>;
+/**
+ * A preset's remark list with the document-wide numbering handed to the
+ * extended-syntax pass, so every block of a split document numbers figures,
+ * tables and equations the same way. No numbering → the module-scope list.
+ */
+export declare function remarkWithNumbering(remark: Options["remarkPlugins"], numbering: DocumentNumbering | null | undefined): Options["remarkPlugins"];
+/** A preset's rehype list with the document-wide numbering (footnotes) handed to the extended-syntax pass. */
+export declare function rehypeWithNumbering(rehype: Options["rehypePlugins"], numbering: DocumentNumbering | null | undefined): Options["rehypePlugins"];
+/** The source a preset parses: math presets run the one normalizer. */
+export declare function prepareCoreSource(source: string, preset: MarkdownPreset, numbering?: DocumentNumbering | null): string;

package/dist/markdown-core/markdown-core-presets.js

@@ -0,0 +1,118 @@
+import remarkGfm from "remark-gfm";
+import remarkTableCodePipes from "./syntax/remark-table-code-pipes.js";
+import remarkInlineOnly from "./syntax/remark-inline-only.js";
+import remarkBreaks from "remark-breaks";
+import remarkMath from "./math/vendor/remark-math.js";
+import rehypeKatex from "./math/vendor/rehype-katex.js";
+import rehypeRaw from "rehype-raw";
+import remarkMatrxVariable from "../display/chat-markdown/matrx-variables/remarkMatrxVariable.js";
+import remarkMatrxCite from "../display/chat-markdown/citations/remarkMatrxCite.js";
+import rehypeSafeRawHtml from "../display/chat-markdown/rehypeSafeRawHtml.js";
+import remarkMatrxPageBreak, {
+  isolatePageBreakLines
+} from "../display/chat-markdown/page-break/remarkMatrxPageBreak.js";
+import remarkFrontmatter from "remark-frontmatter";
+import remarkDirective from "remark-directive";
+import { remarkDefinitionList } from "remark-definition-list";
+import remarkGemoji from "remark-gemoji";
+import rehypeSlug from "rehype-slug";
+import "katex/contrib/mhchem";
+import remarkMatrxSyntax from "./syntax/remark-matrx-syntax.js";
+import rehypeMatrxSyntax from "./syntax/rehype-matrx-syntax.js";
+import { rewriteContainerSpellings } from "./syntax/prepare-syntax-source.js";
+import { collectLinkDefinitions, fenceLineKinds, resolveReferenceLinks } from "@ai-matrx/content-ir/source";
+import {
+  normalizeMathDelimiters,
+  REHYPE_KATEX_OPTIONS,
+  REMARK_MATH_OPTIONS
+} from "./math-normalizer.js";
+const MATH = [remarkMath, REMARK_MATH_OPTIONS];
+const KATEX = [rehypeKatex, REHYPE_KATEX_OPTIONS];
+const PAGE_BREAK = remarkMatrxPageBreak;
+const GFM = [remarkGfm, { singleTilde: false }];
+const SYNTAX_PARSE = [[remarkFrontmatter, ["yaml", "toml"]], remarkDirective, remarkDefinitionList];
+const SYNTAX_TRANSFORM = [remarkTableCodePipes, remarkMatrxSyntax, remarkGemoji];
+const SYNTAX_REHYPE = [rehypeSlug, rehypeMatrxSyntax];
+const MARKDOWN_PRESETS = {
+  plain: { remark: [], rehype: [], math: false },
+  gfm: { remark: [GFM, ...SYNTAX_PARSE, PAGE_BREAK, ...SYNTAX_TRANSFORM], rehype: [...SYNTAX_REHYPE], math: false },
+  "gfm-breaks": {
+    remark: [GFM, remarkBreaks, ...SYNTAX_PARSE, PAGE_BREAK, ...SYNTAX_TRANSFORM],
+    rehype: [...SYNTAX_REHYPE],
+    math: false
+  },
+  math: { remark: [MATH, PAGE_BREAK], rehype: [KATEX], math: true },
+  "gfm-math": {
+    remark: [GFM, MATH, ...SYNTAX_PARSE, PAGE_BREAK, ...SYNTAX_TRANSFORM],
+    rehype: [...SYNTAX_REHYPE, KATEX],
+    math: true
+  },
+  rich: {
+    remark: [GFM, remarkBreaks, MATH, ...SYNTAX_PARSE, PAGE_BREAK, ...SYNTAX_TRANSFORM],
+    rehype: [...SYNTAX_REHYPE, KATEX],
+    math: true
+  },
+  chat: {
+    remark: [
+      GFM,
+      remarkBreaks,
+      MATH,
+      ...SYNTAX_PARSE,
+      remarkMatrxVariable,
+      remarkMatrxCite,
+      PAGE_BREAK,
+      ...SYNTAX_TRANSFORM
+    ],
+    // Parse + sanitize allow-listed raw HTML BEFORE KaTeX, so KaTeX's
+    // rendered output is never sanitized and matrx-variable / math element
+    // nodes are never touched.
+    rehype: [rehypeSafeRawHtml, ...SYNTAX_REHYPE, KATEX],
+    math: true
+  },
+  // One GFM table cell: the chat preset with every block construct off
+  // (verify-RC-B4 R6-1) — `> 90%` / `- n/a` / `# 3` read as the text they are.
+  "chat-cell": {
+    remark: [
+      remarkInlineOnly,
+      GFM,
+      remarkBreaks,
+      MATH,
+      ...SYNTAX_PARSE,
+      remarkMatrxVariable,
+      remarkMatrxCite,
+      PAGE_BREAK,
+      ...SYNTAX_TRANSFORM
+    ],
+    rehype: [rehypeSafeRawHtml, ...SYNTAX_REHYPE, KATEX],
+    math: true
+  },
+  message: {
+    remark: [GFM, MATH, remarkBreaks, ...SYNTAX_PARSE, PAGE_BREAK, ...SYNTAX_TRANSFORM],
+    rehype: [rehypeRaw, ...SYNTAX_REHYPE, KATEX],
+    math: true
+  }
+};
+function remarkWithNumbering(remark, numbering) {
+  if (!numbering || !remark) return remark;
+  return remark.map((plugin) => plugin === remarkMatrxSyntax ? [remarkMatrxSyntax, { numbering }] : plugin);
+}
+function rehypeWithNumbering(rehype, numbering) {
+  if (!numbering || !rehype) return rehype;
+  return rehype.map((plugin) => plugin === rehypeMatrxSyntax ? [rehypeMatrxSyntax, { numbering }] : plugin);
+}
+function prepareCoreSource(source, preset, numbering) {
+  if (preset === "plain") return source;
+  if (numbering?.linkDefinitions && source.includes("[")) {
+    const defs = collectLinkDefinitions(numbering.linkDefinitions);
+    const kinds = fenceLineKinds(source);
+    source = source.split("\n").map((line, i) => kinds[i] === "prose" ? resolveReferenceLinks(line, defs) : line).join("\n");
+  }
+  const isolated = isolatePageBreakLines(rewriteContainerSpellings(source));
+  return MARKDOWN_PRESETS[preset].math ? normalizeMathDelimiters(isolated) : isolated;
+}
+export {
+  MARKDOWN_PRESETS,
+  prepareCoreSource,
+  rehypeWithNumbering,
+  remarkWithNumbering
+};

package/dist/markdown-core/markdown-core-types.d.ts

@@ -0,0 +1,43 @@
+import type { Components } from "react-markdown";
+import type { DocumentNumbering } from "./syntax/document-numbering.js";
+/**
+ * Plugin presets for the ONE shared react-markdown edge (MarkdownCore).
+ * Every preset's plugin array lives in MarkdownCoreImpl — callers pick a
+ * preset by name so plugin imports never enter caller graphs. Adding a
+ * one-off plugin combination? Add a preset here + in the Impl; never
+ * import react-markdown or a remark/rehype plugin from a component again.
+ *
+ * - plain:      no plugins
+ * - gfm:        remark-gfm
+ * - gfm-breaks: remark-gfm + remark-breaks
+ * - math:       math only
+ * - gfm-math:   gfm + math
+ * - rich:       gfm + breaks + math
+ * - chat:       rich + matrx variables + matrx citations + safe raw HTML
+ * - chat-cell:  chat, INLINE constructs only — one GFM table cell (remark-inline-only)
+ * - message:    gfm + math + breaks + rehype-raw
+ *
+ * "math" everywhere means the ONE dialect in math-normalizer.ts: the source
+ * is normalized (`\(…\)` inline, `\[…\]` display, unambiguous `$…$`,
+ * code untouched) and remark-math/rehype-katex run with the shared options.
+ */
+export type MarkdownPreset = "plain" | "gfm" | "gfm-breaks" | "math" | "gfm-math" | "rich" | "chat" | "chat-cell" | "message";
+/** The element-override map a caller may pass to the core — import THIS, never react-markdown's own type. */
+export type MarkdownComponents = Components;
+export interface MarkdownCoreProps {
+    children: string;
+    preset?: MarkdownPreset;
+    components?: Components;
+    /**
+     * The text is still streaming in: heal half-arrived syntax before parse.
+     * Omit to inherit from the nearest MarkdownStreamingProvider (false outside
+     * a live stream); finished text is never healed.
+     */
+    streaming?: boolean;
+    /**
+     * Server renderer only: the document-wide numbering of the whole document
+     * this block belongs to (`computeDocumentNumbering`). Client leaves read it
+     * from the nearest DocumentNumberingProvider instead.
+     */
+    numbering?: DocumentNumbering | null;
+}

package/dist/markdown-core/math/vendor/micromark-math-math-flow.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @import {Construct, State, TokenizeContext, Tokenizer} from 'micromark-util-types'
+ */
+/** @type {Construct} */
+export declare const mathFlow: {
+    tokenize: typeof tokenizeMathFenced;
+    concrete: boolean;
+    name: string;
+};
+/**
+ * @this {TokenizeContext}
+ * @type {Tokenizer}
+ */
+declare function tokenizeMathFenced(effects: any, ok: any, nok: any): (code: any) => any;
+export {};

package/dist/markdown-core/math/vendor/micromark-math-math-flow.js

@@ -0,0 +1,143 @@
+import { factorySpace } from "micromark-factory-space";
+import { markdownLineEnding } from "micromark-util-character";
+const mathFlow = {
+  tokenize: tokenizeMathFenced,
+  concrete: true,
+  name: "mathFlow"
+};
+const nonLazyContinuation = {
+  tokenize: tokenizeNonLazyContinuation,
+  partial: true
+};
+function tokenizeMathFenced(effects, ok, nok) {
+  const self = this;
+  const tail = self.events[self.events.length - 1];
+  const initialSize = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
+  let sizeOpen = 0;
+  return start;
+  function start(code) {
+    effects.enter("mathFlow");
+    effects.enter("mathFlowFence");
+    effects.enter("mathFlowFenceSequence");
+    return sequenceOpen(code);
+  }
+  function sequenceOpen(code) {
+    if (code === 36) {
+      effects.consume(code);
+      sizeOpen++;
+      return sequenceOpen;
+    }
+    if (sizeOpen < 2) {
+      return nok(code);
+    }
+    effects.exit("mathFlowFenceSequence");
+    return factorySpace(effects, metaBefore, "whitespace")(code);
+  }
+  function metaBefore(code) {
+    if (code === null || markdownLineEnding(code)) {
+      return metaAfter(code);
+    }
+    effects.enter("mathFlowFenceMeta");
+    effects.enter("chunkString", {
+      contentType: "string"
+    });
+    return meta(code);
+  }
+  function meta(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("chunkString");
+      effects.exit("mathFlowFenceMeta");
+      return metaAfter(code);
+    }
+    if (code === 36) {
+      return nok(code);
+    }
+    effects.consume(code);
+    return meta;
+  }
+  function metaAfter(code) {
+    effects.exit("mathFlowFence");
+    if (self.interrupt) {
+      return ok(code);
+    }
+    return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+  }
+  function beforeNonLazyContinuation(code) {
+    return effects.attempt({
+      tokenize: tokenizeClosingFence,
+      partial: true
+    }, after, contentStart)(code);
+  }
+  function contentStart(code) {
+    return (initialSize ? factorySpace(effects, beforeContentChunk, "linePrefix", initialSize + 1) : beforeContentChunk)(code);
+  }
+  function beforeContentChunk(code) {
+    if (code === null) {
+      return after(code);
+    }
+    if (markdownLineEnding(code)) {
+      return effects.attempt(nonLazyContinuation, beforeNonLazyContinuation, after)(code);
+    }
+    effects.enter("mathFlowValue");
+    return contentChunk(code);
+  }
+  function contentChunk(code) {
+    if (code === null || markdownLineEnding(code)) {
+      effects.exit("mathFlowValue");
+      return beforeContentChunk(code);
+    }
+    effects.consume(code);
+    return contentChunk;
+  }
+  function after(code) {
+    effects.exit("mathFlow");
+    return ok(code);
+  }
+  function tokenizeClosingFence(effects2, ok2, nok2) {
+    let size = 0;
+    return factorySpace(effects2, beforeSequenceClose, "linePrefix", self.parser.constructs.disable.null.includes("codeIndented") ? void 0 : 4);
+    function beforeSequenceClose(code) {
+      effects2.enter("mathFlowFence");
+      effects2.enter("mathFlowFenceSequence");
+      return sequenceClose(code);
+    }
+    function sequenceClose(code) {
+      if (code === 36) {
+        size++;
+        effects2.consume(code);
+        return sequenceClose;
+      }
+      if (size < sizeOpen) {
+        return nok2(code);
+      }
+      effects2.exit("mathFlowFenceSequence");
+      return factorySpace(effects2, afterSequenceClose, "whitespace")(code);
+    }
+    function afterSequenceClose(code) {
+      if (code === null || markdownLineEnding(code)) {
+        effects2.exit("mathFlowFence");
+        return ok2(code);
+      }
+      return nok2(code);
+    }
+  }
+}
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+  const self = this;
+  return start;
+  function start(code) {
+    if (code === null) {
+      return ok(code);
+    }
+    effects.enter("lineEnding");
+    effects.consume(code);
+    effects.exit("lineEnding");
+    return lineStart;
+  }
+  function lineStart(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code);
+  }
+}
+export {
+  mathFlow
+};

package/dist/markdown-core/math/vendor/micromark-math-math-text.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @import {Options} from 'micromark-extension-math'
+ * @import {Construct, Previous, Resolver, State, Token, TokenizeContext, Tokenizer} from 'micromark-util-types'
+ */
+/**
+ * @param {Options | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {Construct}
+ *   Construct.
+ */
+export declare function mathText(options: any): {
+    tokenize: (effects: any, ok: any, nok: any) => (code: any) => any;
+    resolve: typeof resolveMathText;
+    previous: typeof previous;
+    name: string;
+};
+/** @type {Resolver} */
+declare function resolveMathText(events: any): any;
+/**
+ * @this {TokenizeContext}
+ * @type {Previous}
+ */
+declare function previous(code: any): boolean;
+export {};

package/dist/markdown-core/math/vendor/micromark-math-math-text.js

@@ -0,0 +1,127 @@
+import { markdownLineEnding } from "micromark-util-character";
+function mathText(options) {
+  const options_ = options || {};
+  let single = options_.singleDollarTextMath;
+  if (single === null || single === void 0) {
+    single = true;
+  }
+  return {
+    tokenize: tokenizeMathText,
+    resolve: resolveMathText,
+    previous,
+    name: "mathText"
+  };
+  function tokenizeMathText(effects, ok, nok) {
+    const self = this;
+    let sizeOpen = 0;
+    let size;
+    let token;
+    return start;
+    function start(code) {
+      effects.enter("mathText");
+      effects.enter("mathTextSequence");
+      return sequenceOpen(code);
+    }
+    function sequenceOpen(code) {
+      if (code === 36) {
+        effects.consume(code);
+        sizeOpen++;
+        return sequenceOpen;
+      }
+      if (sizeOpen < 2 && !single) {
+        return nok(code);
+      }
+      effects.exit("mathTextSequence");
+      return between(code);
+    }
+    function between(code) {
+      if (code === null) {
+        return nok(code);
+      }
+      if (code === 36) {
+        token = effects.enter("mathTextSequence");
+        size = 0;
+        return sequenceClose(code);
+      }
+      if (code === 32) {
+        effects.enter("space");
+        effects.consume(code);
+        effects.exit("space");
+        return between;
+      }
+      if (markdownLineEnding(code)) {
+        effects.enter("lineEnding");
+        effects.consume(code);
+        effects.exit("lineEnding");
+        return between;
+      }
+      effects.enter("mathTextData");
+      return data(code);
+    }
+    function data(code) {
+      if (code === null || code === 32 || code === 36 || markdownLineEnding(code)) {
+        effects.exit("mathTextData");
+        return between(code);
+      }
+      effects.consume(code);
+      return data;
+    }
+    function sequenceClose(code) {
+      if (code === 36) {
+        effects.consume(code);
+        size++;
+        return sequenceClose;
+      }
+      if (size === sizeOpen) {
+        effects.exit("mathTextSequence");
+        effects.exit("mathText");
+        return ok(code);
+      }
+      token.type = "mathTextData";
+      return data(code);
+    }
+  }
+}
+function resolveMathText(events) {
+  let tailExitIndex = events.length - 4;
+  let headEnterIndex = 3;
+  let index;
+  let enter;
+  if ((events[headEnterIndex][1].type === "lineEnding" || events[headEnterIndex][1].type === "space") && (events[tailExitIndex][1].type === "lineEnding" || events[tailExitIndex][1].type === "space")) {
+    index = headEnterIndex;
+    while (++index < tailExitIndex) {
+      if (events[index][1].type === "mathTextData") {
+        events[tailExitIndex][1].type = "mathTextPadding";
+        events[headEnterIndex][1].type = "mathTextPadding";
+        headEnterIndex += 2;
+        tailExitIndex -= 2;
+        break;
+      }
+    }
+  }
+  index = headEnterIndex - 1;
+  tailExitIndex++;
+  while (++index <= tailExitIndex) {
+    if (enter === void 0) {
+      if (index !== tailExitIndex && events[index][1].type !== "lineEnding") {
+        enter = index;
+      }
+    } else if (index === tailExitIndex || events[index][1].type === "lineEnding") {
+      events[enter][1].type = "mathTextData";
+      if (index !== enter + 2) {
+        events[enter][1].end = events[index - 1][1].end;
+        events.splice(enter + 2, index - enter - 2);
+        tailExitIndex -= index - enter - 2;
+        index = enter + 2;
+      }
+      enter = void 0;
+    }
+  }
+  return events;
+}
+function previous(code) {
+  return code !== 36 || this.events[this.events.length - 1][1].type === "characterEscape";
+}
+export {
+  mathText
+};

package/dist/markdown-core/math/vendor/micromark-math-syntax.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @import {Options} from 'micromark-extension-math'
+ * @import {Extension} from 'micromark-util-types'
+ */
+/**
+ * Create an extension for `micromark` to enable math syntax.
+ *
+ * @param {Options | null | undefined} [options={}]
+ *   Configuration (default: `{}`).
+ * @returns {Extension}
+ *   Extension for `micromark` that can be passed in `extensions`, to
+ *   enable math syntax.
+ */
+export declare function math(options: any): {
+    flow: {
+        [36]: {
+            tokenize: (effects: any, ok: any, nok: any) => (code: any) => any;
+            concrete: boolean;
+            name: string;
+        };
+    };
+    text: {
+        [36]: {
+            tokenize: (effects: any, ok: any, nok: any) => (code: any) => any;
+            resolve: (events: any) => any;
+            previous: (code: any) => boolean;
+            name: string;
+        };
+    };
+};

package/dist/markdown-core/math/vendor/micromark-math-syntax.js

@@ -0,0 +1,15 @@
+import { mathFlow } from "./micromark-math-math-flow.js";
+import { mathText } from "./micromark-math-math-text.js";
+function math(options) {
+  return {
+    flow: {
+      [36]: mathFlow
+    },
+    text: {
+      [36]: mathText(options)
+    }
+  };
+}
+export {
+  math
+};

package/dist/markdown-core/math/vendor/rehype-katex.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @import {ElementContent, Root} from 'hast'
+ * @import {KatexOptions} from 'katex'
+ * @import {VFile} from 'vfile'
+ */
+/**
+ * Render elements with a `language-math` (or `math-display`, `math-inline`)
+ * class with KaTeX.
+ *
+ * @param {Readonly<Options> | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns
+ *   Transform.
+ */
+export default function rehypeKatex(options: any): (tree: any, file: any) => void;