@ai-markdown/core 3.4.2 → 3.5.0

package/dist/components/index.d.ts

@@ -1,5 +1,134 @@
 import { CodeLanguage } from "@ai-markdown/code-language-detector";
 import { Element } from "hast";
+/** Engine spellings, independent of the UI package. */
+export declare enum CodeLanguageFormat {
+  HighlightJs = "highlight-js",
+  Shiki = "shiki",
+  Pierre = "pierre"
+}
+type CodeLanguageResolver = CodeLanguageFormat | ((language: string) => string);
+export declare function resolveCodeHighlightLanguage(language: string, format?: CodeLanguageResolver): string;
+export declare function resolveCodeHighlightInterval(value: number | undefined, fallback?: number): number;
+interface CodeHighlightToken {
+  text: string;
+  color?: string;
+  backgroundColor?: string;
+  /** Shiki-compatible bit flags: italic=1, bold=2, underline=4. */
+  fontStyle?: number;
+}
+/** HTML must come from a trusted highlighter which escapes source text. Never return raw source as HTML. */
+type CodeHighlightResult = {
+  html: string;
+} | {
+  tokens: readonly CodeHighlightToken[];
+};
+interface CodeHighlightRequest {
+  code: string;
+  language: string;
+  colorScheme: 'light' | 'dark';
+  /** Enable incremental work while the document is streaming. */
+  streaming?: boolean;
+}
+/** Mutable engine state owned by one mounted code block, updated only on commit. */
+interface CodeHighlightBackend {
+  highlight(request: CodeHighlightRequest): CodeHighlightResult | undefined;
+  dispose(): void;
+}
+/** Inject engines from the application; core imports no highlighting runtime. */
+interface CodeHighlightAdapter {
+  languageFormat: CodeLanguageResolver;
+  /** Optional incremental backend. Never created during rendering or SSR. */
+  createSession?(): CodeHighlightBackend;
+  supports?(language: string): boolean;
+  isReady?(request: CodeHighlightRequest): boolean;
+  /** Called only after the framework commits. May load an engine, theme or language. */
+  prepare?(request: CodeHighlightRequest): void | Promise<void>;
+  /** Synchronous after preparation. Return undefined to display plain source. */
+  highlight(request: CodeHighlightRequest): CodeHighlightResult | undefined;
+}
+interface CodeHighlightInput {
+  adapter?: CodeHighlightAdapter;
+  code: string;
+  /** Unconverted fence language or detector result. */
+  language: string;
+  colorScheme: 'light' | 'dark';
+  /** Enable incremental work while the document is streaming. */
+  streaming?: boolean;
+  generation: number;
+  active?: boolean;
+}
+interface CodeHighlightSnapshot {
+  language: string;
+  status: 'plain' | 'loading' | 'ready' | 'error';
+  result?: CodeHighlightResult;
+  error?: unknown;
+}
+/** Per-block cache and async preparation. A late preparation never publishes an old code result. */
+export declare function createCodeHighlightSession(onChange: () => void): {
+  read(input: CodeHighlightInput): CodeHighlightSnapshot;
+  commit(input: CodeHighlightInput): void;
+  retry(): void;
+  dispose(): void;
+};
+type MermaidConfig = {
+  theme?: string;
+  securityLevel?: string;
+  darkMode?: boolean;
+  suppressErrorRendering?: boolean;
+  maxTextSize?: number;
+  themeVariables?: unknown;
+};
+/** The part of the mermaid module this file touches. Structural so tests can
+ *  pass a stub; `mermaidAPI` is deprecated in mermaid's types but present at
+ *  runtime in mermaid 11, and it is the only place `getSiteConfig` /
+ *  `getConfig` live (the default export has neither). */
+type MermaidInitTarget = {
+  initialize(config: MermaidConfig): void;
+  mermaidAPI?: {
+    getSiteConfig?: () => MermaidConfig;
+    getConfig?: () => MermaidConfig;
+  };
+};
+/**
+ * The effective `maxTextSize`. `mermaid.render` does not reject oversized
+ * input: it swaps in a placeholder diagram ("Maximum text size in diagram
+ * exceeded") and resolves normally, and `mermaid.parse` has no size gate at
+ * all, so the whole text is parsed first. The renderer checks this before
+ * parsing and reports the size as an error instead. The key is in mermaid's
+ * `secure` list, so a `%%{init}%%` directive cannot raise it and the site
+ * config is the value that applies.
+ */
+export declare const getMermaidMaxTextSize: (mermaid: MermaidInitTarget) => number;
+/**
+ * mermaid's config is a module-level singleton shared with the host
+ * application when the bundler dedupes the package, and a host that enables
+ * `click` interactions calls `mermaid.initialize({ securityLevel: 'loose' })`
+ * — the officially documented way. Under `loose` mermaid skips DOMPurify
+ * and its output goes into this component's `innerHTML` verbatim: an
+ * LLM-authored diagram string could then run script in the page origin.
+ * So a theme cache alone is not enough of a guard: before every render the
+ * current `securityLevel` is read back (a config copy, still far cheaper
+ * than `initialize`'s merge + theme variables + diagram registration) and an
+ * unsafe value forces a re-initialize
+ * (2026-08-19 review r2 P2-11; the v2.4.2 "documented premise" made this
+ * the host's problem — it is ours, the innerHTML is ours).
+ *
+ * In mermaid 11 `initialize` goes through `setSiteConfig`, which REPLACES
+ * the site config with defaults + the keys passed in. Calling it with only
+ * our keys wiped the host's `theme`, `fontFamily`, `flowchart` options and
+ * so on, and turned a host `sandbox` into `strict` (3.0.2 review). So:
+ * - the current site config is read back and passed through with our
+ *   overrides on top, so host keys survive;
+ * - `sandbox` is accepted as is; only `loose` / `antiscript` / unset become
+ *   `strict`;
+ * - a theme the host chose is kept (with its `themeVariables`); the color
+ *   scheme switch only applies to the theme when the host has not chosen
+ *   one, or when the current theme is one we wrote;
+ * - when nothing needs to change, `initialize` is not called at all, so a
+ *   host on `strict`/`sandbox` and this component stop overwriting each
+ *   other on every render.
+ */
+export declare const ensureMermaidInitialized: (mermaid: MermaidInitTarget, isDark: boolean) => void;
 /** Shared image semantics; no DOM or framework dependency. */
 type ImageActionIconName = 'rotateLeft' | 'rotateRight' | 'zoomIn' | 'zoomOut' | 'close' | 'prev' | 'next' | 'flipX' | 'flipY';
 type ImageIconName = 'placeholder' | 'error' | 'preview' | 'gallery' | ImageActionIconName;
@@ -88,6 +217,145 @@ interface TableLabels extends Record<TableExportReason, string> {
   scrollRegion: string;
 }
 export declare const defaultTableLabels: Readonly<TableLabels>;
+interface DiagramEngine extends MermaidInitTarget {
+  kind?: 'mermaid';
+  /** Resolves truthy for a source that parses; rejects, or resolves falsy, for one that does not. */
+  parse(code: string): Promise<unknown>;
+  render(id: string, code: string): Promise<{
+    svg: string;
+    diagramType?: string;
+    bindFunctions?(element: object): void;
+  }>;
+}
+/** A stateless SVG renderer. Output must be safe to insert into the document. */
+interface SvgDiagramEngine {
+  /** Identifies the built-in CSS palette, not a capability registry. */
+  palette?: 'pele' | 'ondine';
+  kind: 'svg';
+  maxTextSize?: number;
+  render(id: string, code: string, dark: boolean): Promise<{
+    svg: string;
+    diagramType?: string;
+    bindFunctions?(element: object): void | (() => void);
+  }>;
+}
+type DiagramEngineLoader = () => Promise<DiagramEngine | SvgDiagramEngine>;
+/**
+ * What the host shows. One value instead of separate flags whose combinations
+ * had to be kept coherent by hand:
+ * - `source`: nothing has rendered in this generation (warm-up, server render).
+ * - `diagram`: the last successful render.
+ * - `error`: only a failed corrective pass after a stream, or a static failure
+ *   with no diagram up, enters this state.
+ */
+type DiagramView = {
+  kind: 'source';
+} | {
+  kind: 'diagram';
+  svg: string;
+  chartType: string;
+  palette?: 'pele' | 'ondine';
+  dark?: boolean;
+  onBindError?: (error: unknown) => void;
+  bind?: (element: object) => void | (() => void);
+} | DiagramError;
+/**
+ * Why a diagram did not render, as data: the host owns the words.
+ * - `tooLarge`: the source is longer than the engine's `maxTextSize`.
+ * - `parse` and `render`: the engine refused the source or failed to draw it.
+ *   `message` is the engine's own text, which is diagnostic and not
+ *   translated, or empty when it gave none.
+ */
+type DiagramError = {
+  kind: 'error';
+  reason: 'tooLarge';
+  length: number;
+  limit: number;
+} | {
+  kind: 'error';
+  reason: 'parse' | 'render';
+  message: string;
+};
+/** The text for an error view: the engine's own message when there is one, else the label for the reason. */
+export declare function diagramErrorText(error: DiagramError, labels: Pick<DiagramLabels, 'tooLarge' | 'renderFailed'>): string;
+interface DiagramState {
+  view: DiagramView;
+  /** The engine module could not be loaded and the automatic retries are spent. `retry()` starts over. */
+  loadFailed: boolean;
+}
+interface DiagramRequest {
+  code: string;
+  dark: boolean;
+  /** Document streaming state. Its edges mark the start and the end of a generation. */
+  streaming: boolean;
+  /** False while the host shows something else, such as the source. No attempt runs. */
+  active: boolean;
+  /** Minimum time between attempts while streaming. Zero attempts every update. */
+  interval: number;
+}
+/**
+ * The render state machine for one diagram. The host passes every change of
+ * its inputs to `update` and draws what `publish` receives.
+ *
+ * ## While `streaming` is true
+ *
+ * The source is usually a truncated prefix, so a parse failure is expected:
+ * - Before the first success the view stays `source`, never `error`.
+ * - After a success the last diagram stays up; each attempt replaces it only
+ *   when it succeeds.
+ * - Attempts are throttled by `interval` with the same trailing throttle as
+ *   code display: appends inside an interval replace one pending frame without
+ *   moving its deadline. A rewrite, a non-streaming update and the end of the
+ *   stream pass through at once.
+ * - When streaming ends, one corrective pass runs on the final source. Its
+ *   failure is published even over a diagram, because that diagram no longer
+ *   matches the source. Only that one pass may do so.
+ * - When streaming starts, a new generation begins on the same instance (a
+ *   regenerated answer keeps its block position). Everything from the previous
+ *   generation is dropped and the view returns to `source`.
+ *
+ * ## While `streaming` stays false
+ *
+ * A failure is published only while no diagram is up. Once one is, a later
+ * failure (a theme change, an incomplete source from a host that does not pass
+ * `streaming`) keeps it.
+ *
+ * ## Always
+ *
+ * - An attempt whose source and theme match the diagram on screen is skipped.
+ * - A source above the engine's `maxTextSize` is an error, not a render.
+ * - A failed engine download is not a diagram error. It keeps the view, keeps a
+ *   pending corrective pass, and is retried a bounded number of times.
+ * - An attempt that has been superseded publishes nothing.
+ */
+export declare function createDiagramController(load: DiagramEngineLoader, publish: (state: DiagramState) => void, fallback?: DiagramEngineLoader): {
+  update(next: DiagramRequest): void;
+  /** Attempts again on unchanged inputs, with a fresh download budget. */
+  retry(): void;
+  dispose(): void;
+};
+interface CodeBlockOptions {
+  /** Legacy callbacks default to highlight.js names. Adapters own their language format. */
+  languageFormat?: CodeLanguageResolver;
+  /** Takes precedence over the legacy framework highlight callback. Keep adapter identity stable. */
+  highlighter?: CodeHighlightAdapter;
+  defaultExpanded?: boolean;
+  autoDetectUnknownLanguage?: boolean;
+  formatJson?: boolean;
+  expandNestedJson?: boolean;
+  highlightIntervalMs?: number;
+  mermaidIntervalMs?: number;
+  /** Optional renderer loader. Omit to use Mermaid. Keep its identity stable. */
+  mermaidEngine?: DiagramEngineLoader | false;
+  /** Standard entry only: fall back to Mermaid for a known unavailable type. Default true. */
+  mermaidFallback?: boolean;
+  /** Text of the code block, as overrides of the English defaults. A function is called on every render. */
+  labels?: LabelsOption<CodeBlockLabels>;
+}
+/** Common behavior defaults. UI integrations may override these defaults, not their resolution rules. */
+type CodeBlockPolicy = Required<Pick<CodeBlockOptions, 'defaultExpanded' | 'autoDetectUnknownLanguage' | 'formatJson' | 'expandNestedJson' | 'highlightIntervalMs'>>;
+export declare const defaultCodeBlockPolicy: Readonly<CodeBlockPolicy>;
+export declare function resolveCodeBlockPolicy(overrides?: Partial<CodeBlockPolicy>, inherited?: Partial<CodeBlockPolicy>, defaults?: Partial<CodeBlockPolicy>): CodeBlockPolicy;
 interface CodeSource {
   code: string;
   language: string;
@@ -221,165 +489,6 @@ export declare const mermaidRenderQueue: {
   enqueue(owner: object, run: () => Promise<void>): Promise<void>;
   cancel(owner: object): void;
 };
-type MermaidConfig = {
-  theme?: string;
-  securityLevel?: string;
-  darkMode?: boolean;
-  suppressErrorRendering?: boolean;
-  maxTextSize?: number;
-  themeVariables?: unknown;
-};
-/** The part of the mermaid module this file touches. Structural so tests can
- *  pass a stub; `mermaidAPI` is deprecated in mermaid's types but present at
- *  runtime in mermaid 11, and it is the only place `getSiteConfig` /
- *  `getConfig` live (the default export has neither). */
-type MermaidInitTarget = {
-  initialize(config: MermaidConfig): void;
-  mermaidAPI?: {
-    getSiteConfig?: () => MermaidConfig;
-    getConfig?: () => MermaidConfig;
-  };
-};
-/**
- * The effective `maxTextSize`. `mermaid.render` does not reject oversized
- * input: it swaps in a placeholder diagram ("Maximum text size in diagram
- * exceeded") and resolves normally, and `mermaid.parse` has no size gate at
- * all, so the whole text is parsed first. The renderer checks this before
- * parsing and reports the size as an error instead. The key is in mermaid's
- * `secure` list, so a `%%{init}%%` directive cannot raise it and the site
- * config is the value that applies.
- */
-export declare const getMermaidMaxTextSize: (mermaid: MermaidInitTarget) => number;
-/**
- * mermaid's config is a module-level singleton shared with the host
- * application when the bundler dedupes the package, and a host that enables
- * `click` interactions calls `mermaid.initialize({ securityLevel: 'loose' })`
- * — the officially documented way. Under `loose` mermaid skips DOMPurify
- * and its output goes into this component's `innerHTML` verbatim: an
- * LLM-authored diagram string could then run script in the page origin.
- * So a theme cache alone is not enough of a guard: before every render the
- * current `securityLevel` is read back (a config copy, still far cheaper
- * than `initialize`'s merge + theme variables + diagram registration) and an
- * unsafe value forces a re-initialize
- * (2026-08-19 review r2 P2-11; the v2.4.2 "documented premise" made this
- * the host's problem — it is ours, the innerHTML is ours).
- *
- * In mermaid 11 `initialize` goes through `setSiteConfig`, which REPLACES
- * the site config with defaults + the keys passed in. Calling it with only
- * our keys wiped the host's `theme`, `fontFamily`, `flowchart` options and
- * so on, and turned a host `sandbox` into `strict` (3.0.2 review). So:
- * - the current site config is read back and passed through with our
- *   overrides on top, so host keys survive;
- * - `sandbox` is accepted as is; only `loose` / `antiscript` / unset become
- *   `strict`;
- * - a theme the host chose is kept (with its `themeVariables`); the color
- *   scheme switch only applies to the theme when the host has not chosen
- *   one, or when the current theme is one we wrote;
- * - when nothing needs to change, `initialize` is not called at all, so a
- *   host on `strict`/`sandbox` and this component stop overwriting each
- *   other on every render.
- */
-export declare const ensureMermaidInitialized: (mermaid: MermaidInitTarget, isDark: boolean) => void;
-interface DiagramEngine extends MermaidInitTarget {
-  /** Resolves truthy for a source that parses; rejects, or resolves falsy, for one that does not. */
-  parse(code: string): Promise<unknown>;
-  render(id: string, code: string): Promise<{
-    svg: string;
-    diagramType?: string;
-    bindFunctions?(element: object): void;
-  }>;
-}
-/**
- * What the host shows. One value instead of separate flags whose combinations
- * had to be kept coherent by hand:
- * - `source`: nothing has rendered in this generation (warm-up, server render).
- * - `diagram`: the last successful render.
- * - `error`: only a failed corrective pass after a stream, or a static failure
- *   with no diagram up, enters this state.
- */
-type DiagramView = {
-  kind: 'source';
-} | {
-  kind: 'diagram';
-  svg: string;
-  chartType: string;
-  bind?: (element: object) => void;
-} | DiagramError;
-/**
- * Why a diagram did not render, as data: the host owns the words.
- * - `tooLarge`: the source is longer than the engine's `maxTextSize`.
- * - `parse` and `render`: the engine refused the source or failed to draw it.
- *   `message` is the engine's own text, which is diagnostic and not
- *   translated, or empty when it gave none.
- */
-type DiagramError = {
-  kind: 'error';
-  reason: 'tooLarge';
-  length: number;
-  limit: number;
-} | {
-  kind: 'error';
-  reason: 'parse' | 'render';
-  message: string;
-};
-/** The text for an error view: the engine's own message when there is one, else the label for the reason. */
-export declare function diagramErrorText(error: DiagramError, labels: Pick<DiagramLabels, 'tooLarge' | 'renderFailed'>): string;
-interface DiagramState {
-  view: DiagramView;
-  /** The engine module could not be loaded and the automatic retries are spent. `retry()` starts over. */
-  loadFailed: boolean;
-}
-interface DiagramRequest {
-  code: string;
-  dark: boolean;
-  /** Document streaming state. Its edges mark the start and the end of a generation. */
-  streaming: boolean;
-  /** False while the host shows something else, such as the source. No attempt runs. */
-  active: boolean;
-  /** Minimum time between attempts while streaming. Zero attempts every update. */
-  interval: number;
-}
-/**
- * The render state machine for one diagram. The host passes every change of
- * its inputs to `update` and draws what `publish` receives.
- *
- * ## While `streaming` is true
- *
- * The source is usually a truncated prefix, so a parse failure is expected:
- * - Before the first success the view stays `source`, never `error`.
- * - After a success the last diagram stays up; each attempt replaces it only
- *   when it succeeds.
- * - Attempts are throttled by `interval` with the same trailing throttle as
- *   code display: appends inside an interval replace one pending frame without
- *   moving its deadline. A rewrite, a non-streaming update and the end of the
- *   stream pass through at once.
- * - When streaming ends, one corrective pass runs on the final source. Its
- *   failure is published even over a diagram, because that diagram no longer
- *   matches the source. Only that one pass may do so.
- * - When streaming starts, a new generation begins on the same instance (a
- *   regenerated answer keeps its block position). Everything from the previous
- *   generation is dropped and the view returns to `source`.
- *
- * ## While `streaming` stays false
- *
- * A failure is published only while no diagram is up. Once one is, a later
- * failure (a theme change, an incomplete source from a host that does not pass
- * `streaming`) keeps it.
- *
- * ## Always
- *
- * - An attempt whose source and theme match the diagram on screen is skipped.
- * - A source above the engine's `maxTextSize` is an error, not a render.
- * - A failed engine download is not a diagram error. It keeps the view, keeps a
- *   pending corrective pass, and is retried a bounded number of times.
- * - An attempt that has been superseded publishes nothing.
- */
-export declare function createDiagramController(load: () => Promise<DiagramEngine>, publish: (state: DiagramState) => void): {
-  update(next: DiagramRequest): void;
-  /** Attempts again on unchanged inputs, with a fresh download budget. */
-  retry(): void;
-  dispose(): void;
-};
 /**
  * Stops the page behind a preview from scrolling. `scrollbarWidth` is the
  * width of the scrollbar that hiding the overflow removes
@@ -592,6 +701,106 @@ export declare function createImagePreviewController(host: ImagePreviewHost, pub
   /** Stops every timer and subscription. The controller can be opened again afterwards. */
   dispose(): void;
 };
+/** Structural subset; generic options preserve the installed engine's own parameter types. */
+interface SvgRendererModule<Options extends object = {
+  idPrefix?: string;
+  limit?: number;
+}> {
+  render(source: string, options?: Options): {
+    svg: string;
+    type?: string;
+  } | Promise<{
+    svg: string;
+    type?: string;
+  }>;
+}
+interface DiagramAdapterOptions<Options extends object> {
+  renderOptions?: Omit<Options, 'idPrefix'>;
+}
+export declare function createPeleLoader<Options extends object>(load: () => Promise<SvgRendererModule<Options>>, options?: DiagramAdapterOptions<Options>): DiagramEngineLoader;
+export declare function createOndineLoader<Options extends object>(load: () => Promise<SvgRendererModule<Options>>, options?: DiagramAdapterOptions<Options>): DiagramEngineLoader;
+interface PierreHighlightToken {
+  content: string;
+  offset: number;
+  color?: string;
+  bgColor?: string;
+  fontStyle?: number;
+}
+/** Only the synchronous, editable-document API is needed; core imports no WASM runtime. */
+interface PierreLiveTokenizer {
+  readonly lineCount: number;
+  getLineLength(line: number): number;
+  getLineTokens(line: number): {
+    tokens: readonly PierreHighlightToken[];
+  };
+  applyEdits(edits: readonly {
+    range: {
+      start: {
+        line: number;
+        character: number;
+      };
+      end: {
+        line: number;
+        character: number;
+      };
+    };
+    newText: string;
+  }[]): {
+    lineChanges: readonly {
+      oldStartLine: number;
+      oldEndLine: number;
+      newStartLine: number;
+      newEndLine: number;
+    }[];
+  };
+  dispose(): void;
+}
+/** Structural interface: applications own the optional WASM engine and theme imports. */
+interface PierreHighlightRuntime<Language extends string, Theme> {
+  isSupportedLanguage(language: string): boolean;
+  codeToTokens(code: string, options: {
+    lang: Language;
+    theme: NoInfer<Theme>;
+  }): {
+    tokens: readonly (readonly PierreHighlightToken[])[];
+    fg?: string;
+  };
+  LiveTokenizer?: new (options: {
+    code: string;
+    lang: Language;
+    theme: NoInfer<Theme>;
+  }) => PierreLiveTokenizer;
+  themes: {
+    light: Theme;
+    dark: Theme;
+  };
+}
+/** Lazy initialization is shared; mutable tokenizers belong to individual mounted blocks. */
+export declare function createPierreHighlightAdapter<Language extends string, Theme>(options: {
+  load: () => Promise<PierreHighlightRuntime<Language, Theme>>;
+  /** Defaults to true. Disable to compare with full-frame tokenization. */
+  incremental?: boolean;
+}): CodeHighlightAdapter;
+/** Raised only for an identified diagram type unavailable in the selected engine. */
+export declare class UnsupportedDiagramError extends Error {
+  readonly diagramType: string;
+  constructor(diagramType: string);
+}
+export declare const resolveDiagramInterval: (value: number | undefined) => number;
+/** Shared per loader, not per component. Rejected imports are never retained. */
+export declare function createCachedDiagramLoader(load: DiagramEngineLoader): DiagramEngineLoader;
+export declare function preloadDiagramEngine(load: DiagramEngineLoader): Promise<void>;
+interface DiagramInput {
+  code: string;
+  colorScheme: 'light' | 'dark';
+  streaming: boolean;
+  active: boolean;
+  resetKey: string;
+  intervalMs?: number;
+  load: DiagramEngineLoader;
+  /** Absent in engine-independent entry points. Only a classified unsupported type can use this. */
+  fallback?: DiagramEngineLoader;
+}
 export interface CodeRendererInput {
   /** Raw accumulated source, including its trailing newline. */
   code: string;
@@ -604,14 +813,4 @@ export interface CodeRendererInput {
   /** Changes on source replacement or identity change; append preserves it. */
   resetKey: string;
 }
-export interface CodeBlockOptions {
-  defaultExpanded?: boolean;
-  autoDetectUnknownLanguage?: boolean;
-  formatJson?: boolean;
-  expandNestedJson?: boolean;
-  highlightIntervalMs?: number;
-  mermaidIntervalMs?: number;
-  /** Text of the code block, as overrides of the English defaults. A function is called on every render. */
-  labels?: LabelsOption<CodeBlockLabels>;
-}
-export type { CodeBlockInput, CodeBlockLabels, CodeBlockSnapshot, CodeFrame, CodeSource, DiagramEngine, DiagramError, DiagramLabels, DiagramRequest, DiagramState, DiagramView, ImageActionIconName, ImageGallery, ImageGalleryItem, ImageGeometry, ImageIconName, ImageLabels, ImageLoadStatus, ImagePointer, ImagePreviewAction, ImagePreviewHost, ImagePreviewOptions, ImagePreviewPhase, ImagePreviewState, ImageTransform, LabelsOption, MermaidInitTarget, TableExportReason, TableLabels, TableProjection };
+export type { CodeBlockInput, CodeBlockLabels, CodeBlockOptions, CodeBlockPolicy, CodeBlockSnapshot, CodeFrame, CodeHighlightAdapter, CodeHighlightBackend, CodeHighlightInput, CodeHighlightRequest, CodeHighlightResult, CodeHighlightSnapshot, CodeHighlightToken, CodeLanguageResolver, CodeSource, DiagramAdapterOptions, DiagramEngine, DiagramEngineLoader, DiagramError, DiagramInput, DiagramLabels, DiagramRequest, DiagramState, DiagramView, ImageActionIconName, ImageGallery, ImageGalleryItem, ImageGeometry, ImageIconName, ImageLabels, ImageLoadStatus, ImagePointer, ImagePreviewAction, ImagePreviewHost, ImagePreviewOptions, ImagePreviewPhase, ImagePreviewState, ImageTransform, LabelsOption, MermaidInitTarget, PierreHighlightRuntime, PierreHighlightToken, PierreLiveTokenizer, SvgDiagramEngine, SvgRendererModule, TableExportReason, TableLabels, TableProjection };