vue-stream-markdown 0.0.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,762 @@
+import * as vue18 from "vue";
+import { Component, MaybeRef } from "vue";
+import "tippy.js/dist/tippy.css";
+import "tippy.js/themes/light.css";
+import "tippy.js/dist/border.css";
+import "tippy.js/dist/svg-arrow.css";
+import { Zoom } from "medium-zoom";
+import { MarkdownItAsync } from "markdown-it-async";
+import { KatexOptions as KatexOptions$1 } from "katex";
+import "medium-zoom/dist/style.css";
+import { BuiltinLanguage, BuiltinTheme, BundledLanguage, BundledTheme, CodeToTokensOptions, Highlighter, SpecialLanguage, TokensResult } from "shiki";
+import { Mermaid, MermaidConfig } from "mermaid";
+import { Extension, fromMarkdown } from "mdast-util-from-markdown";
+import { Options as Options$1 } from "mdast-util-to-markdown";
+import { Extension as Extension$1 } from "micromark-util-types";
+import { DefaultProps } from "tippy.js";
+
+//#region src/components/previewers/index.d.ts
+declare const CODE_PREVIEWERS: Record<string, Component>;
+//#endregion
+//#region src/types/core.d.ts
+type SyntaxTree = ReturnType<typeof fromMarkdown>;
+type ParsedNode = SyntaxTree['children'][number] & {
+  loading?: boolean;
+};
+type NodeType = ParsedNode['type'];
+type NodeRenderers = Partial<Record<NodeType, Component>>;
+type BlockquoteNode = Extract<ParsedNode, {
+  type: 'blockquote';
+}>;
+type BreakNode = Extract<ParsedNode, {
+  type: 'break';
+}>;
+type CodeNode = Extract<ParsedNode, {
+  type: 'code';
+}>;
+type DefinitionNode = Extract<ParsedNode, {
+  type: 'definition';
+}>;
+type DeleteNode = Extract<ParsedNode, {
+  type: 'delete';
+}>;
+type EmphasisNode = Extract<ParsedNode, {
+  type: 'emphasis';
+}>;
+type FootnoteDefinitionNode = Extract<ParsedNode, {
+  type: 'footnoteDefinition';
+}>;
+type FootnoteReferenceNode = Extract<ParsedNode, {
+  type: 'footnoteReference';
+}>;
+type HeadingNode = Extract<ParsedNode, {
+  type: 'heading';
+}>;
+type HtmlNode = Extract<ParsedNode, {
+  type: 'html';
+}>;
+type ImageNode = Extract<ParsedNode, {
+  type: 'image';
+}>;
+type ImageReferenceNode = Extract<ParsedNode, {
+  type: 'imageReference';
+}>;
+type InlineCodeNode = Extract<ParsedNode, {
+  type: 'inlineCode';
+}>;
+type LinkNode = Extract<ParsedNode, {
+  type: 'link';
+}>;
+type LinkReferenceNode = Extract<ParsedNode, {
+  type: 'linkReference';
+}>;
+type ListNode = Extract<ParsedNode, {
+  type: 'list';
+}>;
+type ListItemNode = Extract<ParsedNode, {
+  type: 'listItem';
+}>;
+type ParagraphNode = Extract<ParsedNode, {
+  type: 'paragraph';
+}>;
+type StrongNode = Extract<ParsedNode, {
+  type: 'strong';
+}>;
+type TableNode = Extract<ParsedNode, {
+  type: 'table';
+}>;
+type TableCellNode = Extract<ParsedNode, {
+  type: 'tableCell';
+}>;
+type TableRowNode = Extract<ParsedNode, {
+  type: 'tableRow';
+}>;
+type TextNode = Extract<ParsedNode, {
+  type: 'text';
+}>;
+type ThematicBreakNode = Extract<ParsedNode, {
+  type: 'thematicBreak';
+}>;
+type YamlNode = Extract<ParsedNode, {
+  type: 'yaml';
+}>;
+type MathNode = Extract<ParsedNode, {
+  type: 'math';
+}>;
+type InlineMathNode = Extract<ParsedNode, {
+  type: 'inlineMath';
+}>;
+//#endregion
+//#region src/types/locale.d.ts
+interface LocaleConfig {
+  button: {
+    zoomIn: string;
+    zoomOut: string;
+    resetZoom: string;
+    preview: string;
+    source: string;
+    collapse: string;
+    copy: string;
+    download: string;
+    minimize: string;
+    maximize: string;
+  };
+  error: {
+    vanilla: string;
+    image: string;
+    mermaid: string;
+    katex: string;
+    harden: string;
+  };
+}
+//#endregion
+//#region src/types/context.d.ts
+interface StreamMarkdownProps extends StreamMarkdownContext, MarkdownParserOptions {
+  mode?: 'static' | 'streaming';
+  content?: string;
+  nodeRenderers?: NodeRenderers;
+  locale?: string | LocaleConfig;
+}
+interface MarkdownParserOptions {
+  mdastOptions?: MdastOptions;
+  normalize?: (content: string) => string;
+  preprocess?: (content: string) => string;
+  postprocess?: (content: SyntaxTree) => SyntaxTree;
+  extendMarkdownIt?: (md: MarkdownItAsync) => void;
+}
+interface MdastOptions {
+  from?: Extension[];
+  to?: Options$1[];
+  micromark?: Extension$1[];
+}
+interface StreamMarkdownContext {
+  controls?: ControlsConfig;
+  previewers?: PreviewerConfig;
+  shikiOptions?: ShikiOptions;
+  mermaidOptions?: MermaidOptions;
+  katexOptions?: KatexOptions;
+  hardenOptions?: HardenOptions;
+  codeOptions?: CodeOptions;
+  imageOptions?: ImageOptions;
+  isDark?: boolean;
+}
+type TableControlsConfig = boolean | {
+  copy?: boolean | string;
+  download?: boolean | string;
+};
+type CodeControlsConfig = boolean | {
+  collapse?: boolean;
+  copy?: boolean;
+  download?: boolean;
+  fullscreen?: boolean;
+  lineNumbers?: boolean;
+};
+type ImageControlsConfig = boolean | {
+  download?: boolean;
+};
+type ZoomControlsConfig = boolean | {
+  position?: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+};
+type ControlsConfig = boolean | {
+  table?: boolean | TableControlsConfig;
+  code?: boolean | CodeControlsConfig;
+  image?: boolean | ImageControlsConfig;
+  mermaid?: boolean | ZoomControlsConfig;
+};
+type PreviewerConfig = boolean | {
+  html?: boolean | Component;
+  mermaid?: boolean | Component;
+};
+interface ShikiOptions {
+  theme?: [BuiltinTheme, BuiltinTheme];
+  langAlias?: Record<string, string>;
+  codeToTokenOptions?: CodeToTokensOptions<BundledLanguage, BundledTheme>;
+}
+interface MermaidOptions {
+  theme?: [string, string];
+  config?: MermaidConfig;
+  errorComponent?: Component;
+}
+interface KatexOptions {
+  config?: KatexOptions$1;
+  errorComponent?: Component;
+}
+interface ImageOptions {
+  fallback?: string;
+  caption?: boolean;
+  errorComponent?: Component;
+}
+interface CodeOptions {
+  languageIcon?: boolean;
+  languageName?: boolean;
+  lineNumbers?: boolean;
+}
+interface HardenOptions {
+  defaultOrigin?: string;
+  allowedLinkPrefixes?: string[];
+  allowedImagePrefixes?: string[];
+  allowedProtocols?: string[];
+  allowDataImages?: boolean;
+  errorComponent?: Component;
+}
+//#endregion
+//#region src/markdown-parser.d.ts
+interface Options extends MarkdownParserOptions {
+  mode: 'streaming' | 'static';
+}
+declare class MarkdownParser {
+  private mode;
+  private md;
+  private content;
+  private syntaxTree;
+  private options;
+  constructor(options: Options);
+  private update;
+  updateMode(mode: 'streaming' | 'static'): void;
+  parseMarkdown(content: string): ParsedNode[];
+  markdownToHtml(content: string): string;
+  markdownToAst(content: string, loading?: boolean): SyntaxTree;
+  astToMarkdown(data: SyntaxTree | ParsedNode): string;
+  hasLoadingNode(nodes?: ParsedNode[]): boolean;
+}
+//#endregion
+//#region src/types/renderer.d.ts
+interface NodeRendererListProps extends Omit<NodeRendererProps, 'node' | 'indexKey'> {
+  nodes?: ParsedNode[];
+  indexKey?: number | string;
+}
+interface NodeRendererProps extends StreamMarkdownContext {
+  markdownParser: MarkdownParser;
+  nodeRenderers: NodeRenderers;
+  node: ParsedNode;
+  mediumZoom: Zoom;
+  indexKey: number | string;
+  getContainer: () => HTMLElement | undefined;
+}
+interface BlockquoteNodeRendererProps extends NodeRendererProps {
+  node: BlockquoteNode;
+}
+interface BreakNodeRendererProps extends NodeRendererProps {
+  node: BreakNode;
+}
+interface CodeNodeRendererProps extends NodeRendererProps {
+  node: CodeNode;
+}
+interface DefinitionNodeRendererProps extends NodeRendererProps {
+  node: DefinitionNode;
+}
+interface DeleteNodeRendererProps extends NodeRendererProps {
+  node: DeleteNode;
+}
+interface EmphasisNodeRendererProps extends NodeRendererProps {
+  node: EmphasisNode;
+}
+interface FootnoteDefinitionNodeRendererProps extends NodeRendererProps {
+  node: FootnoteDefinitionNode;
+}
+interface FootnoteReferenceNodeRendererProps extends NodeRendererProps {
+  node: FootnoteReferenceNode;
+}
+interface HeadingNodeRendererProps extends NodeRendererProps {
+  node: HeadingNode;
+}
+interface HtmlNodeRendererProps extends NodeRendererProps {
+  node: HtmlNode;
+}
+interface ImageNodeRendererProps extends NodeRendererProps {
+  node: ImageNode;
+}
+interface ImageReferenceNodeRendererProps extends NodeRendererProps {
+  node: ImageReferenceNode;
+}
+interface InlineCodeNodeRendererProps extends NodeRendererProps {
+  node: InlineCodeNode;
+}
+interface LinkNodeRendererProps extends NodeRendererProps {
+  node: LinkNode;
+}
+interface LinkReferenceNodeRendererProps extends NodeRendererProps {
+  node: LinkReferenceNode;
+}
+interface ListNodeRendererProps extends NodeRendererProps {
+  node: ListNode;
+}
+interface ListItemNodeRendererProps extends NodeRendererProps {
+  node: ListItemNode;
+}
+interface ParagraphNodeRendererProps extends NodeRendererProps {
+  node: ParagraphNode;
+}
+interface StrongNodeRendererProps extends NodeRendererProps {
+  node: StrongNode;
+}
+interface TableNodeRendererProps extends NodeRendererProps {
+  node: TableNode;
+}
+interface TableRowNodeRendererProps extends NodeRendererProps {
+  node: TableRowNode;
+}
+interface TableCellNodeRendererProps extends NodeRendererProps {
+  node: TableCellNode;
+}
+interface TextNodeRendererProps extends NodeRendererProps {
+  node: TextNode;
+}
+interface ThematicBreakNodeRendererProps extends NodeRendererProps {
+  node: ThematicBreakNode;
+}
+interface YamlNodeRendererProps extends NodeRendererProps {
+  node: YamlNode;
+}
+interface MathNodeRendererProps extends NodeRendererProps {
+  node: MathNode;
+}
+interface InlineMathNodeRendererProps extends NodeRendererProps {
+  node: InlineMathNode;
+}
+//#endregion
+//#region src/types/shared.d.ts
+interface SelectItem {
+  label: string;
+  value: string;
+  icon?: Component;
+}
+//#endregion
+//#region src/components/renderers/index.d.ts
+declare const NODE_RENDERERS: NodeRenderers;
+//#endregion
+//#region src/components/index.d.ts
+declare const COMMON_COMPONENTS: Record<string, Component>;
+//#endregion
+//#region src/composables/use-context.d.ts
+interface Context {
+  isDark?: MaybeRef<boolean>;
+  getContainer?: () => HTMLElement | undefined;
+  onCopied?: (content: string) => void;
+}
+declare function useContext(): {
+  context: Context;
+  provideContext: (ctx: Partial<Context>) => void;
+  injectContext: () => Context;
+  isDark: vue18.ComputedRef<boolean>;
+  readonly getContainer: () => HTMLElement | undefined;
+  readonly onCopied: (content: string) => void;
+};
+//#endregion
+//#region src/composables/use-controls.d.ts
+interface UseControlsOptions {
+  controls: MaybeRef<ControlsConfig | undefined>;
+}
+declare function useControls(options: UseControlsOptions): {
+  isControlEnabled: (key: string) => boolean;
+};
+//#endregion
+//#region src/composables/use-harden-sanitizers.d.ts
+interface UseHardenSanitizersOptions {
+  url?: MaybeRef<string | undefined>;
+  hardenOptions?: MaybeRef<HardenOptions | undefined>;
+  loading?: MaybeRef<boolean | undefined>;
+  isImage?: MaybeRef<boolean | undefined>;
+}
+declare function useHardenSanitizers(options: UseHardenSanitizersOptions): {
+  hardenOptions: vue18.ComputedRef<HardenOptions>;
+  transformHardenUrl: (url: string) => string | null;
+  transformedUrl: vue18.ComputedRef<string | null>;
+  isHardenUrl: vue18.ComputedRef<boolean>;
+};
+//#endregion
+//#region src/composables/use-hsl-theme.d.ts
+declare function useHslTheme(): void;
+//#endregion
+//#region src/composables/use-i18n.d.ts
+declare function useI18n(): {
+  t: (key: string) => string;
+};
+//#endregion
+//#region src/composables/use-katex.d.ts
+declare function useKatex(): {
+  installed: vue18.Ref<boolean, boolean>;
+  render: (code: string, options?: KatexOptions$1) => Promise<{
+    html?: string;
+    error?: string;
+  }>;
+  preload: () => Promise<void>;
+  dispose: () => void;
+};
+//#endregion
+//#region src/composables/use-math-renderer.d.ts
+interface UseMathRendererOptions {
+  node: MaybeRef<InlineMathNode | MathNode>;
+  katexOptions?: MaybeRef<KatexOptions | undefined>;
+  throttle?: MaybeRef<number>;
+}
+declare function useMathRenderer(options: UseMathRendererOptions): {
+  html: vue18.Ref<string, string>;
+  error: vue18.ComputedRef<boolean>;
+  errorMessage: vue18.Ref<string, string>;
+};
+//#endregion
+//#region src/composables/use-mermaid.d.ts
+interface UseMermaidOptions {
+  mermaidOptions?: MaybeRef<MermaidOptions | undefined>;
+  isDark?: MaybeRef<boolean>;
+}
+declare function useMermaid(options?: UseMermaidOptions): {
+  installed: vue18.Ref<boolean, boolean>;
+  getMermaid: () => Promise<Mermaid>;
+  parseMermaid: (code: string) => Promise<boolean>;
+  renderMermaid: (code: string) => Promise<string | null>;
+  saveMermaid: (format: "svg" | "png", code?: string, onError?: (error: Error) => void) => Promise<void>;
+  preload: () => Promise<void>;
+  dispose: () => void;
+};
+//#endregion
+//#region src/composables/use-shiki.d.ts
+interface UseShikiOptions {
+  lang?: MaybeRef<string>;
+  shikiOptions?: MaybeRef<ShikiOptions | undefined>;
+  isDark?: MaybeRef<boolean>;
+}
+declare function useShiki(options?: UseShikiOptions): {
+  installed: vue18.Ref<boolean, boolean>;
+  getHighlighter: () => Promise<Highlighter>;
+  codeToTokens: (code: string) => Promise<TokensResult>;
+  preload: () => Promise<void>;
+  dispose: () => void;
+};
+//#endregion
+//#region src/composables/use-tippy.d.ts
+interface UseTippyOptions {
+  isDark?: MaybeRef<boolean>;
+  options?: MaybeRef<DefaultProps>;
+}
+declare function useTippy(options?: UseTippyOptions): {
+  initTippy: () => void;
+};
+//#endregion
+//#region src/composables/use-zoom.d.ts
+interface UseZoomOptions {
+  minZoom?: number;
+  maxZoom?: number;
+  zoomStep?: number;
+  wheelSensitivity?: number;
+  initialZoom?: number;
+  initialTranslateX?: number;
+  initialTranslateY?: number;
+}
+interface ZoomPanState {
+  zoom: number;
+  translateX: number;
+  translateY: number;
+}
+declare function useZoom(options?: UseZoomOptions): {
+  zoom: vue18.Ref<number, number>;
+  translateX: vue18.Ref<number, number>;
+  translateY: vue18.Ref<number, number>;
+  isDragging: vue18.Ref<boolean, boolean>;
+  transformStyle: vue18.ComputedRef<{
+    transform: string;
+  }>;
+  zoomIn: () => void;
+  zoomOut: () => void;
+  resetZoom: () => void;
+  setZoom: (value: number) => void;
+  startDrag: (e: MouseEvent | TouchEvent) => void;
+  onDrag: (e: MouseEvent | TouchEvent) => void;
+  stopDrag: () => void;
+  handleWheel: (event: WheelEvent, containerElement: HTMLElement) => void;
+  getState: () => ZoomPanState;
+  setState: (state: Partial<ZoomPanState>) => void;
+};
+//#endregion
+//#region src/constants/code.d.ts
+declare const DEFAULT_LIGHT_THEME = "github-light";
+declare const DEFAULT_DARK_THEME = "github-dark";
+declare const LANGUAGE_ALIAS: Record<string, BuiltinLanguage>;
+declare const LANGUAGE_EXTENSIONS: Partial<Record<BuiltinLanguage, string>>;
+declare const LANGUAGE_ICONS: Partial<Record<BuiltinLanguage | SpecialLanguage, Component>>;
+//#endregion
+//#region src/constants/harden.d.ts
+declare const DEFAULT_HARDEN_OPTIONS: HardenOptions;
+//#endregion
+//#region src/constants/icons.d.ts
+declare const ICONS: Record<string, Component>;
+//#endregion
+//#region src/index.vue.d.ts
+declare const __VLS_export: vue18.DefineComponent<StreamMarkdownProps, {
+  getMarkdownParser: () => MarkdownParser;
+  getParsedNodes: () => ParsedNode[];
+}, {}, {}, {}, vue18.ComponentOptionsMixin, vue18.ComponentOptionsMixin, {} & {
+  copied: (content: string) => any;
+}, string, vue18.PublicProps, Readonly<StreamMarkdownProps> & Readonly<{
+  onCopied?: ((content: string) => any) | undefined;
+}>, {
+  mode: "static" | "streaming";
+  content: string;
+  nodeRenderers: Partial<Record<"blockquote" | "break" | "code" | "definition" | "delete" | "emphasis" | "footnoteDefinition" | "footnoteReference" | "heading" | "html" | "image" | "imageReference" | "inlineCode" | "link" | "linkReference" | "list" | "listItem" | "paragraph" | "strong" | "table" | "tableCell" | "tableRow" | "text" | "thematicBreak" | "yaml" | "inlineMath" | "math", vue18.Component>>;
+  locale: string | LocaleConfig;
+  controls: ControlsConfig;
+  previewers: PreviewerConfig;
+  isDark: boolean;
+}, {}, {}, {}, string, vue18.ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+//#region src/locales/index.d.ts
+declare const SUPPORT_LANGUAGES: string[];
+declare const localesGlob: Record<string, () => Promise<unknown>>;
+declare const localeMessages: vue18.Ref<LocaleConfig | undefined, LocaleConfig | undefined>;
+declare const currentLocale: vue18.Ref<string, string>;
+declare function loadLocaleMessages(language: string | LocaleConfig): Promise<void>;
+//#endregion
+//#region src/postprocess/text.d.ts
+declare function postFixText(data: SyntaxTree): SyntaxTree;
+//#endregion
+//#region src/postprocess/index.d.ts
+declare function postprocess(data: SyntaxTree): SyntaxTree;
+//#endregion
+//#region src/preprocess/code.d.ts
+/**
+ * Fix unclosed code syntax in streaming markdown
+ *
+ * Handles two types of code syntax:
+ * 1. Inline code: `code` (single backticks)
+ * 2. Code blocks: ```language\ncode\n``` (triple backticks)
+ *
+ * Only processes the last paragraph (content after the last blank line) for inline code.
+ * Code blocks can span multiple paragraphs, so they are processed globally.
+ *
+ * @param content - Markdown content (potentially incomplete in stream mode)
+ * @returns Content with auto-completed code syntax if needed
+ *
+ * @example
+ * fixCode('Hello `world')
+ * // Returns: 'Hello `world`'
+ *
+ * @example
+ * fixCode('```javascript\nconst x = 1')
+ * // Returns: '```javascript\nconst x = 1\n```'
+ *
+ * @example
+ * fixCode('`')
+ * // Returns: '' (no completion, ` has no content)
+ *
+ * @example
+ * fixCode('```')
+ * // Returns: '```' (no completion, code block has no content)
+ */
+declare function fixCode(content: string): string;
+//#endregion
+//#region src/preprocess/delete.d.ts
+/**
+ * Fix unclosed strikethrough (~~) syntax in streaming markdown
+ *
+ * Only processes the last paragraph (content after the last blank line).
+ * This respects Markdown's rule that ~~ cannot span across paragraphs.
+ *
+ * @param content - Markdown content (potentially incomplete in stream mode)
+ * @returns Content with auto-completed ~~ if needed
+ *
+ * @example
+ * fixDelete('Hello ~~world')
+ * // Returns: 'Hello ~~world~~'
+ *
+ * @example
+ * fixDelete('Para1 ~~deleted~~\n\nPara2 ~~text')
+ * // Returns: 'Para1 ~~deleted~~\n\nPara2 ~~text~~'
+ *
+ * @example
+ * fixDelete('List item\n\n~~')
+ * // Returns: 'List item\n\n~~' (no completion, ~~ has no content)
+ */
+declare function fixDelete(content: string): string;
+//#endregion
+//#region src/preprocess/emphasis.d.ts
+/**
+ * Fix unclosed emphasis (* or _) syntax in streaming markdown
+ *
+ * Only processes the last paragraph (content after the last blank line).
+ * This respects Markdown's rule that emphasis cannot span across paragraphs.
+ */
+declare function fixEmphasis(content: string): string;
+//#endregion
+//#region src/preprocess/link.d.ts
+/**
+ * Fix unclosed link/image syntax in streaming markdown
+ *
+ * Link syntax: [text](url "title")
+ * Image syntax: ![alt](url "title")
+ *
+ * Only processes the last paragraph (content after the last blank line).
+ * This respects Markdown's rule that links cannot span across paragraphs.
+ *
+ * @param content - Markdown content (potentially incomplete in stream mode)
+ * @returns Content with auto-completed link/image syntax if needed
+ *
+ * @example
+ * fixLink('[Google](https://www.goo')
+ * // Returns: '[Google](https://www.goo)'
+ *
+ * @example
+ * fixLink('[text](')
+ * // Returns: '[text]()'
+ *
+ * @example
+ * fixLink('[text]')
+ * // Returns: '[text]()'
+ *
+ * @example
+ * fixLink('[text')
+ * // Returns: '[text]()'
+ *
+ * @example
+ * fixLink('![alt](https://image.png')
+ * // Returns: '![alt](https://image.png)'
+ */
+declare function fixLink(content: string): string;
+//#endregion
+//#region src/preprocess/strong.d.ts
+/**
+ * Fix unclosed strong (** or __) syntax in streaming markdown
+ *
+ * Only processes the last paragraph (content after the last blank line).
+ * This respects Markdown's rule that strong formatting cannot span across paragraphs.
+ *
+ * @param content - Markdown content (potentially incomplete in stream mode)
+ * @returns Content with auto-completed ** or __ if needed
+ *
+ * @example
+ * fixStrong('Hello **world')
+ * // Returns: 'Hello **world**'
+ *
+ * @example
+ * fixStrong('Hello __world')
+ * // Returns: 'Hello __world__'
+ *
+ * @example
+ * fixStrong('Para1 **bold**\n\nPara2 **text')
+ * // Returns: 'Para1 **bold**\n\nPara2 **text**'
+ *
+ * @example
+ * fixStrong('List item\n\n**')
+ * // Returns: 'List item\n\n**' (no completion, ** has no content)
+ */
+declare function fixStrong(content: string): string;
+//#endregion
+//#region src/preprocess/table.d.ts
+/**
+ * Fix incomplete table syntax in streaming markdown
+ *
+ * Handles markdown tables by detecting the header row and ensuring
+ * a separator row exists. Only processes the last paragraph for streaming.
+ *
+ * Table format:
+ * | Header 1 | Header 2 |
+ * | -------- | -------- |
+ * | Cell 1   | Cell 2   |
+ *
+ * @param content - Markdown content (potentially incomplete in stream mode)
+ * @returns Content with auto-completed table separator if needed
+ *
+ * @example
+ * fixTable('| a | b |\n')
+ * // Returns: '| a | b |\n| --- | --- |'
+ *
+ * @example
+ * fixTable('| a | b |\n| ---')
+ * // Returns: '| a | b |\n| --- | --- |'
+ *
+ * @example
+ * fixTable('| a | b |\n| --- | --- |')
+ * // Returns: '| a | b |\n| --- | --- |' (no change, already complete)
+ */
+declare function fixTable(content: string): string;
+//#endregion
+//#region src/preprocess/vendored/markdown-utils.d.ts
+declare function preprocessLaTeX(content: string): string;
+declare function preprocessThinkTag(content: string): string;
+//#endregion
+//#region src/preprocess/vendored/parse-incomplete-markdown.d.ts
+declare function parseIncompleteMarkdown(text: string): string;
+//#endregion
+//#region src/preprocess/pattern.d.ts
+declare const crlfPattern: RegExp;
+declare const trailingBackticksPattern: RegExp;
+declare const codeBlockPattern: RegExp;
+declare const singleBacktickPattern: RegExp;
+declare const tripleBacktickPattern: RegExp;
+declare const trailingWhitespacePattern: RegExp;
+declare const doubleAsteriskPattern: RegExp;
+declare const singleAsteriskPattern: RegExp;
+declare const doubleUnderscorePattern: RegExp;
+declare const singleUnderscorePattern: RegExp;
+declare const doubleTildePattern: RegExp;
+declare const doubleDollarPattern: RegExp;
+declare const incompleteBracketPattern: RegExp;
+declare const incompleteLinkTextPattern: RegExp;
+declare const incompleteUrlPattern: RegExp;
+declare const tableRowPattern: RegExp;
+declare const separatorPattern: RegExp;
+//#endregion
+//#region src/preprocess/index.d.ts
+declare function proprocessContent(content: string): string;
+declare function normalize(content: string): string;
+declare function preprocess(content: string): string;
+//#endregion
+//#region src/utils/harden.d.ts
+declare function transformUrl(url: unknown, allowedPrefixes: string[], defaultOrigin: string, allowDataImages?: boolean, isImage?: boolean, allowedProtocols?: string[]): string | null;
+//#endregion
+//#region src/utils/helper.d.ts
+declare function flow<T>(fns: Array<(arg: T) => T>): (arg: T) => T;
+declare function save(filename: string, content: string | Blob, mimeType: string): void;
+declare function svgToPngBlob(svgString: string, options?: {
+  scale?: number;
+}): Promise<Blob>;
+//#endregion
+//#region src/utils/module.d.ts
+declare function hasShiki(): Promise<boolean>;
+declare function hasMermaid(): Promise<boolean>;
+declare function hasKatex(): Promise<boolean>;
+//#endregion
+//#region src/utils/parser.d.ts
+declare function findLastLeafNode(nodes: ParsedNode[]): ParsedNode | null;
+declare function findNodeParent(targetNode: ParsedNode, nodes: ParsedNode[], parent?: {
+  children: ParsedNode[];
+}): {
+  parent: {
+    children: ParsedNode[];
+  };
+  index: number;
+} | null;
+//#endregion
+//#region src/utils/table.d.ts
+interface TableData {
+  headers: string[];
+  rows: string[][];
+}
+declare function extractTableDataFromElement(tableElement: HTMLElement): TableData;
+declare function tableDataToCSV(data: TableData): string;
+declare function tableDataToTSV(data: TableData): string;
+declare function escapeMarkdownTableCell(cell: string): string;
+declare function tableDataToMarkdown(data: TableData): string;
+//#endregion
+export { BlockquoteNode, BlockquoteNodeRendererProps, BreakNode, BreakNodeRendererProps, CODE_PREVIEWERS, COMMON_COMPONENTS, CodeControlsConfig, CodeNode, CodeNodeRendererProps, CodeOptions, ControlsConfig, DEFAULT_DARK_THEME, DEFAULT_HARDEN_OPTIONS, DEFAULT_LIGHT_THEME, DefinitionNode, DefinitionNodeRendererProps, DeleteNode, DeleteNodeRendererProps, EmphasisNode, EmphasisNodeRendererProps, FootnoteDefinitionNode, FootnoteDefinitionNodeRendererProps, FootnoteReferenceNode, FootnoteReferenceNodeRendererProps, HardenOptions, HeadingNode, HeadingNodeRendererProps, HtmlNode, HtmlNodeRendererProps, ICONS, ImageControlsConfig, ImageNode, ImageNodeRendererProps, ImageOptions, ImageReferenceNode, ImageReferenceNodeRendererProps, InlineCodeNode, InlineCodeNodeRendererProps, InlineMathNode, InlineMathNodeRendererProps, KatexOptions, LANGUAGE_ALIAS, LANGUAGE_EXTENSIONS, LANGUAGE_ICONS, LinkNode, LinkNodeRendererProps, LinkReferenceNode, LinkReferenceNodeRendererProps, ListItemNode, ListItemNodeRendererProps, ListNode, ListNodeRendererProps, LocaleConfig, _default as Markdown, MarkdownParser, MarkdownParserOptions, MathNode, MathNodeRendererProps, MdastOptions, MermaidOptions, NODE_RENDERERS, NodeRendererListProps, NodeRendererProps, NodeRenderers, NodeType, Options, ParagraphNode, ParagraphNodeRendererProps, ParsedNode, PreviewerConfig, SUPPORT_LANGUAGES, SelectItem, ShikiOptions, StreamMarkdownContext, StreamMarkdownProps, StrongNode, StrongNodeRendererProps, SyntaxTree, TableCellNode, TableCellNodeRendererProps, TableControlsConfig, TableData, TableNode, TableNodeRendererProps, TableRowNode, TableRowNodeRendererProps, TextNode, TextNodeRendererProps, ThematicBreakNode, ThematicBreakNodeRendererProps, UseMathRendererOptions, UseZoomOptions, YamlNode, YamlNodeRendererProps, ZoomControlsConfig, ZoomPanState, codeBlockPattern, crlfPattern, currentLocale, doubleAsteriskPattern, doubleDollarPattern, doubleTildePattern, doubleUnderscorePattern, escapeMarkdownTableCell, extractTableDataFromElement, findLastLeafNode, findNodeParent, fixCode, fixDelete, fixEmphasis, fixLink, fixStrong, fixTable, flow, hasKatex, hasMermaid, hasShiki, incompleteBracketPattern, incompleteLinkTextPattern, incompleteUrlPattern, loadLocaleMessages, localeMessages, localesGlob, normalize, parseIncompleteMarkdown, postFixText, postprocess, preprocess, preprocessLaTeX, preprocessThinkTag, proprocessContent, save, separatorPattern, singleAsteriskPattern, singleBacktickPattern, singleUnderscorePattern, svgToPngBlob, tableDataToCSV, tableDataToMarkdown, tableDataToTSV, tableRowPattern, trailingBackticksPattern, trailingWhitespacePattern, transformUrl, tripleBacktickPattern, useContext, useControls, useHardenSanitizers, useHslTheme, useI18n, useKatex, useMathRenderer, useMermaid, useShiki, useTippy, useZoom };