@ai-markdown/core 3.3.0 → 3.4.0

package/dist/components/index.d.ts

@@ -1,4 +1,93 @@
+import { CodeLanguage } from "@ai-markdown/code-language-detector";
 import { Element } from "hast";
+/** 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;
+type ImageLoadStatus = 'loading' | 'ready' | 'error';
+/** Lucide paths supplied for the Markdown image skin (ISC license). */
+export declare const imageIconPaths: Record<ImageIconName, readonly string[]>;
+interface ImageGalleryItem {
+  id: object;
+  src: string;
+  alt: string;
+  /** DOM adapters provide document ordering without leaking DOM types. */
+  precedes: (other: object) => boolean;
+}
+interface ImageGallery {
+  /** Document-ordered entries. The same array is returned until the membership changes. */
+  items: () => readonly ImageGalleryItem[];
+  /** Number of registered entries; O(1), so listeners can test it without sorting. */
+  size: () => number;
+  subscribe: (listener: () => void) => () => void;
+  set: (item: ImageGalleryItem) => void;
+  remove: (id: object) => void;
+}
+/** Scope is an adapter-owned object, never a global document id. */
+export declare function getImageGallery(scope: object): ImageGallery;
+/** The preview toolbar actions, in toolbar order. */
+export declare const imageActionNames: readonly ImageActionIconName[];
+/**
+ * The text of one component, as a partial override of its English defaults.
+ * A function is read on every render, so it can follow an application's own
+ * i18n state. This package ships no translations.
+ */
+type LabelsOption<T> = Partial<T> | (() => Partial<T>);
+/** The defaults with the supplied entries on top. An entry set to `undefined` keeps its default. */
+export declare function resolveLabels<T extends object>(defaults: T, option?: LabelsOption<T>): T;
+interface CodeBlockLabels {
+  /** Accessible name of the toolbar. */
+  actions: string;
+  /** Language shown for a block that has none. */
+  plainText: string;
+  copy: string;
+  copied: string;
+  copyFailed: string;
+  showSource: string;
+  showPreview: string;
+  expand: string;
+  collapse: string;
+  /** Shown above the source when a language renderer throws. */
+  previewFailed: string;
+}
+export declare const defaultCodeBlockLabels: Readonly<CodeBlockLabels>;
+interface DiagramLabels {
+  /** Nothing has rendered yet and the document is still streaming. */
+  waiting: string;
+  /** Nothing has rendered yet and the source is complete. */
+  rendering: string;
+  /** The engine module could not be downloaded. */
+  loadFailed: string;
+  retry: string;
+  /** The engine failed without a message of its own. */
+  renderFailed: string;
+  /** The source is longer than the engine's `maxTextSize`. */
+  tooLarge: (length: number, limit: number) => string;
+}
+export declare const defaultDiagramLabels: Readonly<DiagramLabels>;
+interface ImageLabels extends Record<ImageActionIconName, string> {
+  loading: string;
+  loadFailed: string;
+  /** Accessible name of the button that opens the preview. Receives the image's `alt`, which may be empty. */
+  open: (alt: string) => string;
+  /** Accessible name of a previewed image that has no `alt`. */
+  preview: string;
+  /** Accessible name of the preview toolbar. */
+  actions: string;
+}
+export declare const defaultImageLabels: Readonly<ImageLabels>;
+/** Why a table has no export. `projectTable` reports one of these; `TableLabels` has the text for each. */
+type TableExportReason = 'mergedCells' | 'notRectangular' | 'unsupportedStructure' | 'unsupportedContent' | 'unavailable';
+interface TableLabels extends Record<TableExportReason, string> {
+  /** Accessible name of the toolbar. */
+  actions: string;
+  copy: string;
+  download: string;
+  copied: string;
+  copyFailed: string;
+  /** Accessible name of the scrolling region. */
+  scrollRegion: string;
+}
+export declare const defaultTableLabels: Readonly<TableLabels>;
 interface CodeSource {
   code: string;
   language: string;
@@ -11,15 +100,106 @@ type TableProjection = {
   reason?: undefined;
 } | {
   rows?: undefined;
-  reason: string;
+  reason: TableExportReason;
 };
-/** Project sanitized HAST semantics, never custom cell UI or raw Markdown. */
+/** Project sanitized HAST semantics, never custom cell UI or raw Markdown. A
+ * table that cannot be exported reports why as a code; `TableLabels` has the text. */
 export declare function projectTable(node?: Element): TableProjection;
 export declare function serializeTable(rows: readonly (readonly string[])[], delimiter?: ',' | '\t'): string;
+/** Whether `next` is `previous` with nothing or more appended. */
+export declare function extendsCode(next: string, previous: string): boolean;
+/**
+ * Follows the language of one unlabelled code block.
+ *
+ * `read` answers during render, server rendering included, and changes
+ * nothing: a render that is thrown away cannot move the verdict. `observe` is
+ * called once the text is on screen, and only it feeds the detector that
+ * follows the block. That detector keeps one verdict for as long as the text
+ * only grows: it looks again only when the text has grown enough to change
+ * the evidence, never lowers its confidence, and charges a margin for a
+ * switch across language families. It is fed the text without hast's final
+ * newline, which makes every append a continuation.
+ *
+ * What `read` answers for a text:
+ * - the observed text, or one that extends it: the followed verdict as it
+ *   stands. `observe` then looks at the new text and returns true when the
+ *   verdict moved, so the host can read again;
+ * - anything else (a first or server render, a rewrite, an older text): the
+ *   verdict a fresh detector gives it, which is also what `observe` will
+ *   arrive at after starting over.
+ *
+ * While the document streams the detector does not look again before 80 more
+ * characters, and the streaming flag describes the document, not this fence.
+ * `observe` therefore starts a timer after each change: a block whose text
+ * has been still for `CODE_LANGUAGE_SETTLE_MS` is judged as complete, and
+ * `onSettle` asks the host to read again.
+ */
+export declare function createCodeLanguageTracker(onSettle: () => void): {
+  /** The verdict for `code`. Changes nothing, so a repeated or abandoned render is harmless. */
+  read(code: string, streaming: boolean): CodeLanguage | null;
+  /** Call once the text is on screen. Each call replaces the pending timer. True when the verdict `read` gave for `code` has moved. */
+  observe(code: string, streaming: boolean): boolean;
+  dispose: () => void;
+};
+/** The state of one code block at one update. Options arrive already resolved by the host. */
+interface CodeBlockInput {
+  /** Raw accumulated source, including its trailing newline. */
+  code: string;
+  /** Explicit fence language, normalized. Empty when the fence has none. */
+  language: string;
+  /** Which block this is. A different value starts a new generation even when the text continues. */
+  identity?: string;
+  /** Document streaming state. */
+  streaming: boolean;
+  /** Detect the language of a block that has none. */
+  autoDetect: boolean;
+  /** Pretty-print a JSON block once it is complete. */
+  formatJson: boolean;
+  expandNestedJson: boolean;
+  /** Minimum time between two displayed frames of a growing block. Zero shows every update. */
+  highlightIntervalMs: number;
+}
+interface CodeBlockSnapshot {
+  /** Text for the highlighter: throttled while the block grows, pretty-printed when it is complete JSON. */
+  text: string;
+  /** The fence language, else the detected one, else empty. */
+  language: string;
+  /** Grows by one when the block is rewritten or becomes another block. An append keeps it. */
+  generation: number;
+}
+/**
+ * Everything a code block derives from its source, for one block.
+ *
+ * `read` answers during render, server rendering included. Equal input gives
+ * an equal answer, and a render that is abandoned leaves the committed
+ * generation and the language verdict alone. `commit` is called once the answer
+ * is on screen: it records the lineage, lets the language detector look at the
+ * text, and starts the display throttle and the language settle timer. When a
+ * commit or a timer changes the answer, `onChange` asks the host to read again. A host that never commits, such as a server render, always reads the
+ * current text.
+ *
+ * - An append keeps the generation; a rewrite, another fence language or
+ *   another `identity` advances it.
+ * - While the document streams, appends inside `highlightIntervalMs` share one
+ *   displayed frame. A rewrite, a language change, a static update and the end
+ *   of the stream show the current text at once.
+ * - A block with no fence language is detected as it grows and judged as
+ *   complete once its text has been still (see `createCodeLanguageTracker`).
+ * - JSON is pretty-printed when the document is not streaming, or as soon as
+ *   the displayed text is a balanced value.
+ */
+export declare function createCodeBlockSession(onChange: () => void): {
+  read(input: CodeBlockInput): CodeBlockSnapshot;
+  commit(input: CodeBlockInput): void;
+  dispose(): void;
+};
 interface CodeFrame {
   code: string;
   language: string;
+  /** Shared only by append continuations (see `extendsCode`); never mutated. */
+  generation: object;
 }
+export declare function nextCodeFrame(previous: CodeFrame | undefined, code: string, language: string): CodeFrame;
 /** A trailing throttle: append bursts replace one pending frame without
  * moving its deadline. Replacements and completion bypass the timer. */
 export declare function createCodeFrame(initial: CodeFrame, publish: (frame: CodeFrame) => void): {
@@ -32,16 +212,11 @@ export declare function createCodeFrame(initial: CodeFrame, publish: (frame: Cod
 export declare function prettyPrintJson(text: string, expandNested?: boolean): string;
 /** Bracket-balance gate, not a JSON validator. Retain quote/escape state
  * across append seams so growing JSON does not rescan its whole body when
- * each nested object closes. Replacements start a fresh lineage. */
+ * each nested object closes. Replacements start a fresh lineage. The final
+ * newline of hast code text is left unscanned: it is whitespace, and it moves
+ * on every append. */
 export declare function createJsonCompletenessScanner(): (text: string) => boolean;
 export declare function jsonLooksComplete(text: string): boolean;
-/** Mermaid owns global configuration and a global renderer. Keep initialize,
- * parse and render in one serialized task. Each mounted diagram retains at
- * most one pending task; superseded frames never enter Mermaid. */
-export declare function createRenderQueue(): {
-  enqueue(owner: object, run: () => Promise<void>): Promise<void>;
-  cancel(owner: object): void;
-};
 export declare const mermaidRenderQueue: {
   enqueue(owner: object, run: () => Promise<void>): Promise<void>;
   cancel(owner: object): void;
@@ -65,10 +240,6 @@ type MermaidInitTarget = {
     getConfig?: () => MermaidConfig;
   };
 };
-/** Test hook: forget the theme cache so each test starts from a cold module. */
-export declare const resetMermaidInitializationForTests: () => void;
-/** mermaid's own default for `maxTextSize` (`MAX_TEXTLENGTH` in mermaidAPI). */
-export declare const MERMAID_DEFAULT_MAX_TEXT_SIZE = 50000;
 /**
  * The effective `maxTextSize`. `mermaid.render` does not reject oversized
  * input: it swaps in a placeholder diagram ("Maximum text size in diagram
@@ -110,64 +281,120 @@ export declare const getMermaidMaxTextSize: (mermaid: MermaidInitTarget) => numb
  */
 export declare const ensureMermaidInitialized: (mermaid: MermaidInitTarget, isDark: boolean) => void;
 interface DiagramEngine extends MermaidInitTarget {
-  parse(code: string, options: {
-    suppressErrors: true;
-  }): Promise<unknown>;
+  /** 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;
   }>;
 }
-type DiagramState = {
-  status: 'loading' | 'ready' | 'error';
+/**
+ * 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;
-  error?: 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;
-  resetKey: string;
+  /** Minimum time between attempts while streaming. Zero attempts every update. */
   interval: number;
 }
-/** Owns cancellation and retries across both UI adapters. In-flight Mermaid
- * cannot be aborted, but obsolete work never publishes or starts a render. */
+/**
+ * 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(request: DiagramRequest): void;
-  dispose: () => 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
+ * (`window.innerWidth - document.documentElement.clientWidth`); the same width
+ * is added as padding so the page does not shift sideways. Pass zero, or
+ * nothing, when the scrollbar takes no space.
+ */
 export declare function lockImagePreviewScroll(target: {
   style: {
     overflow: string;
+    paddingRight?: string;
   };
-}): () => 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;
-type ImageLoadStatus = 'loading' | 'ready' | 'error';
-/** Lucide paths supplied for the Markdown image skin (ISC license). */
-export declare const imageIconPaths: Record<ImageIconName, readonly string[]>;
-export declare const imageGroupSelector = "[data-aimd-image-scope], .aim-typography-root, .aimd-vue, .mantine-Typography-root";
-interface ImageGalleryItem {
-  id: object;
-  src: string;
-  alt: string;
-  /** DOM adapters provide document ordering without leaking DOM types. */
-  precedes: (other: object) => boolean;
-}
-interface ImageGallery {
-  items: () => readonly ImageGalleryItem[];
-  subscribe: (listener: () => void) => () => void;
-  set: (item: ImageGalleryItem) => void;
-  remove: (id: object) => void;
-}
-/** Scope is an adapter-owned object, never a global document id. */
-export declare function getImageGallery(scope: object): ImageGallery;
-export declare const imageActionLabels: Record<ImageActionIconName, string>;
-/** Transform rules adapted from @rc-component/image 1.10.0 (MIT).
- * Keep the Vue adapter's gestures aligned with the upstream React engine. */
+}, scrollbarWidth?: number): () => void;
+/** Transform rules adapted from @rc-component/image 1.10.0 (MIT, Copyright (c) 2019-present react-component; see LICENSE).
+ * Pure functions; `createImagePreviewController` applies them. */
 interface ImageTransform {
   x: number;
   y: number;
@@ -187,7 +414,15 @@ interface ImageGeometry {
 export declare const initialImageTransform: () => ImageTransform;
 export declare function imageTransformStyle(transform: ImageTransform): string;
 export declare function zoomImage(transform: ImageTransform, ratio: number, geometry: ImageGeometry, centerX?: number, centerY?: number, touch?: boolean): ImageTransform;
-export declare function imageWheelRatio(delta: number): number;
+/**
+ * The zoom factor for one wheel event. A full notch (100 pixels) is one 1.5x
+ * step, and a smaller delta a proportional part of it.
+ * - `mode` is `WheelEvent.deltaMode`. Some browsers and mice report lines or
+ *   pages, not pixels: three lines or one page count as a notch.
+ * - `pinch` is a trackpad pinch, which arrives as a wheel event with the
+ *   control key set and small deltas. It scales continuously with the delta.
+ */
+export declare function imageWheelRatio(delta: number, mode?: number, pinch?: boolean): number;
 /** Snap a moved image back inside the viewport, taking quarter turns into account. */
 export declare function reboundImage(transform: ImageTransform, geometry: ImageGeometry, bounds: {
   left: number;
@@ -210,6 +445,104 @@ export declare function imagePinchCenter(oldA: {
   x: number;
   y: number;
 };
+/**
+ * - `closed`: nothing to render.
+ * - `opening`: rendered in its starting style, for the frames a transition needs to start from.
+ * - `open`: the resting state.
+ * - `closing`: still rendered, in its leaving style, until the close duration has passed.
+ */
+type ImagePreviewPhase = 'closed' | 'opening' | 'open' | 'closing';
+interface ImagePreviewState {
+  phase: ImagePreviewPhase;
+  /** The gallery in document order. It follows the gallery while the preview is open. */
+  items: readonly ImageGalleryItem[];
+  /** Index of the image shown, or -1 while closed. */
+  current: number;
+  item: ImageGalleryItem | undefined;
+  transform: ImageTransform;
+  /** Load state of the image shown. */
+  status: ImageLoadStatus;
+  /** A drag or a pinch is in progress: the image follows the pointer without a transition. */
+  moving: boolean;
+  canPrevious: boolean;
+  canNext: boolean;
+  canZoomIn: boolean;
+  canZoomOut: boolean;
+}
+/** What the controller needs from the page. */
+interface ImagePreviewHost {
+  /** Layout box of the image shown, before its transform, and the viewport. Undefined while there is no image. */
+  geometry(): ImageGeometry | undefined;
+  /** Runs the callback before the next paint and returns a cancel function. `requestAnimationFrame` in a browser. */
+  frame(callback: () => void): () => void;
+}
+interface ImagePreviewOptions {
+  /** How long the leaving style stays up, in milliseconds. Zero closes at once. A function is read at each close,
+   * so a host can answer zero while the user prefers reduced motion. Default 300. */
+  closeDuration?: number | (() => number);
+}
+interface ImagePointer {
+  /** Pointer id: one drag, or one finger of a pinch. */
+  id: number;
+  x: number;
+  y: number;
+  /** `PointerEvent.button`. Only the main button starts a gesture. */
+  button?: number;
+}
+/**
+ * One image preview: which image of a gallery is shown, how it is transformed,
+ * and where it is in opening and closing. The host forwards its events as plain
+ * numbers and draws each state it is given.
+ *
+ * - `open(gallery, id)` shows the image registered under `id` and follows the
+ *   gallery from then on: images added or removed while the preview is open
+ *   update the list, and the preview closes when the image shown leaves it.
+ * - Pointer input is one model for mouse, pen and touch. One pointer drags.
+ *   Two pointers pinch, around a centre weighted by how far each one moved. A
+ *   pinch may shrink the image below its natural size; when the last pointer
+ *   lifts the image snaps back inside the viewport. The host should capture
+ *   the pointer when `pointerDown` returns true, so a drag that leaves the
+ *   window or its frame still ends.
+ * - Drag and wheel updates reach `publish` at most once per frame; everything
+ *   else is published at once. Each update is applied to the current state, so
+ *   several in one frame add up.
+ * - Switching images resets the transform. Zoom is limited to 1x to 50x in
+ *   1.5x steps, about the pointer for the wheel and a double click, about the
+ *   viewport centre for the toolbar.
+ */
+export declare function createImagePreviewController(host: ImagePreviewHost, publish: (state: ImagePreviewState) => void, options?: ImagePreviewOptions): {
+  state: () => ImagePreviewState;
+  /** Shows the image registered under `id`. False when the gallery has no such image. */
+  open(gallery: ImageGallery, id: object): boolean;
+  close: () => void;
+  /** Moves by `delta` images. Does nothing at either end of the gallery. */
+  go: (delta: number) => void;
+  /** A toolbar action. */
+  action(name: ImageActionIconName): void;
+  /** The image shown finished loading, or failed to. */
+  loaded(): void;
+  failed(): void;
+  /** True when the pointer now takes part in a gesture: capture it and prevent the default action. */
+  pointerDown(pointer: ImagePointer): boolean;
+  pointerMove(pointer: ImagePointer): void;
+  /** A pointer lifted or was cancelled. */
+  pointerUp(id: number): void;
+  /** True when the wheel zoomed: prevent the default action. `mode` is `WheelEvent.deltaMode`; `pinch` is a
+   * trackpad pinch, which browsers report as a wheel event with the control key set. */
+  wheel(input: {
+    deltaY: number;
+    x: number;
+    y: number;
+    mode?: number;
+    pinch?: boolean;
+  }): boolean;
+  /** Returns to the natural size, or zooms one step about the point when already there. */
+  doubleClick(x: number, y: number): void;
+  /** True when the key was used: prevent the default action. Left and right move through a gallery. */
+  key(key: string): boolean;
+  /** Stops every timer and subscription. The controller can be opened again afterwards. */
+  dispose(): void;
+};
 export interface CodeRendererInput {
   /** Raw accumulated source, including its trailing newline. */
   code: string;
@@ -229,5 +562,7 @@ export interface CodeBlockOptions {
   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 { CodeFrame, CodeSource, DiagramEngine, DiagramRequest, DiagramState, ImageActionIconName, ImageGallery, ImageGalleryItem, ImageGeometry, ImageIconName, ImageLoadStatus, ImageTransform, MermaidInitTarget, TableProjection };
+export type { CodeBlockInput, CodeBlockLabels, CodeBlockSnapshot, CodeFrame, CodeSource, DiagramEngine, DiagramError, DiagramLabels, DiagramRequest, DiagramState, DiagramView, ImageActionIconName, ImageGallery, ImageGalleryItem, ImageGeometry, ImageIconName, ImageLabels, ImageLoadStatus, ImagePointer, ImagePreviewHost, ImagePreviewOptions, ImagePreviewPhase, ImagePreviewState, ImageTransform, LabelsOption, MermaidInitTarget, TableExportReason, TableLabels, TableProjection };