markstream-angular 0.0.5 → 0.0.7

package/dist/index.d.ts

@@ -0,0 +1,1490 @@
+import { SmoothMarkdownStreamOptions } from 'markstream-core';
+export { SmoothMarkdownStreamOptions } from 'markstream-core';
+import { ParsedNode, BaseNode, HtmlPolicy, ParseOptions, MarkdownIt } from 'stream-markdown-parser';
+import * as i0 from '@angular/core';
+import { Type, AfterViewInit, OnChanges, OnDestroy, OnInit, EventEmitter, SimpleChanges, InjectionToken, ElementRef } from '@angular/core';
+import * as markstream_angular from 'markstream-angular';
+
+type CustomComponentMap = Record<string, Type<unknown>>;
+declare function subscribeCustomComponents(listener: () => void): () => void;
+declare function getCustomComponentsRevision(): number;
+declare function setCustomComponents(id: string, mapping: CustomComponentMap): void;
+declare function setCustomComponents(mapping: CustomComponentMap): void;
+declare function getCustomNodeComponents(customId?: string): CustomComponentMap;
+declare function removeCustomComponents(id: string): void;
+declare function clearGlobalCustomComponents(): void;
+
+interface CodeBlockMonacoThemeObject {
+    name: string;
+    base?: string;
+    inherit?: boolean;
+    colors?: Record<string, string>;
+    rules?: Array<Record<string, unknown>>;
+    [key: string]: unknown;
+}
+type CodeBlockMonacoTheme = string | CodeBlockMonacoThemeObject;
+type CodeBlockMonacoLanguage = string | ((...args: unknown[]) => unknown);
+interface CodeBlockDiffHideUnchangedRegionsOptions {
+    enabled?: boolean;
+    contextLineCount?: number;
+    minimumLineCount?: number;
+    revealLineCount?: number;
+}
+type CodeBlockDiffHideUnchangedRegions = boolean | CodeBlockDiffHideUnchangedRegionsOptions;
+type CodeBlockDiffLineStyle = 'background' | 'bar';
+type CodeBlockDiffAppearance = 'auto' | 'light' | 'dark';
+type CodeBlockDiffUnchangedRegionStyle = 'line-info' | 'line-info-basic' | 'metadata' | 'simple';
+type CodeBlockDiffHunkActionKind = 'revert' | 'stage';
+type CodeBlockDiffHunkSide = 'upper' | 'lower';
+interface CodeBlockDiffHunkActionContext {
+    action: CodeBlockDiffHunkActionKind;
+    side: CodeBlockDiffHunkSide;
+    lineChange: unknown;
+    originalModel: unknown;
+    modifiedModel: unknown;
+}
+interface CodeBlockMonacoOptions {
+    MAX_HEIGHT?: number | string;
+    fontSize?: number;
+    lineHeight?: number;
+    fontFamily?: string;
+    tabSize?: number;
+    readOnly?: boolean;
+    wordWrap?: 'off' | 'on' | 'wordWrapColumn' | 'bounded' | string;
+    wrappingIndent?: 'none' | 'same' | 'indent' | 'deepIndent' | string;
+    theme?: string;
+    themes?: CodeBlockMonacoTheme[];
+    languages?: CodeBlockMonacoLanguage[];
+    renderSideBySide?: boolean;
+    useInlineViewWhenSpaceIsLimited?: boolean;
+    enableSplitViewResizing?: boolean;
+    ignoreTrimWhitespace?: boolean;
+    maxComputationTime?: number;
+    diffAlgorithm?: string;
+    renderIndicators?: boolean;
+    originalEditable?: boolean;
+    revealDebounceMs?: number;
+    revealStrategy?: 'bottom' | 'centerIfOutside' | 'center';
+    revealBatchOnIdleMs?: number;
+    updateThrottleMs?: number;
+    diffUpdateThrottleMs?: number;
+    diffAutoScroll?: boolean;
+    diffHideUnchangedRegions?: CodeBlockDiffHideUnchangedRegions;
+    diffLineStyle?: CodeBlockDiffLineStyle;
+    diffAppearance?: CodeBlockDiffAppearance;
+    diffUnchangedRegionStyle?: CodeBlockDiffUnchangedRegionStyle;
+    diffHunkActionsOnHover?: boolean;
+    diffHunkHoverHideDelayMs?: number;
+    onDiffHunkAction?: (context: CodeBlockDiffHunkActionContext) => void | boolean | Promise<void | boolean>;
+    scrollbar?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+
+type AngularRenderableNode = (ParsedNode | BaseNode) & Record<string, unknown>;
+interface CodeBlockPreviewPayload {
+    node: AngularRenderableNode;
+    artifactType: 'text/html' | 'image/svg+xml';
+    artifactTitle: string;
+    id: string;
+}
+type NodeRendererCodeBlockProps = Partial<{
+    stream: boolean;
+    darkTheme: CodeBlockMonacoTheme;
+    lightTheme: CodeBlockMonacoTheme;
+    themes: CodeBlockMonacoTheme[];
+    monacoOptions: CodeBlockMonacoOptions;
+    minWidth: string | number;
+    maxWidth: string | number;
+    isShowPreview: boolean;
+    enableFontSizeControl: boolean;
+    showHeader: boolean;
+    showCopyButton: boolean;
+    showExpandButton: boolean;
+    showPreviewButton: boolean;
+    showCollapseButton: boolean;
+    showFontSizeButtons: boolean;
+    htmlPreviewAllowScripts: boolean;
+    htmlPreviewSandbox: string;
+}> & Record<string, unknown>;
+type NodeRendererMermaidProps = Partial<{
+    maxHeight: string | null;
+    estimatedPreviewHeightPx: number;
+    workerTimeoutMs: number;
+    parseTimeoutMs: number;
+    renderTimeoutMs: number;
+    fullRenderTimeoutMs: number;
+    renderDebounceMs: number;
+    showHeader: boolean;
+    showModeToggle: boolean;
+    showCopyButton: boolean;
+    showExportButton: boolean;
+    showFullscreenButton: boolean;
+    showCollapseButton: boolean;
+    showZoomControls: boolean;
+    isStrict: boolean;
+    enableMermaidInteractions: boolean;
+}> & Record<string, unknown>;
+type NodeRendererD2Props = Partial<{
+    maxHeight: string | null;
+    themeId: number | null;
+    darkThemeId: number | null;
+    showHeader: boolean;
+    showModeToggle: boolean;
+    showCopyButton: boolean;
+    showExportButton: boolean;
+    showCollapseButton: boolean;
+}> & Record<string, unknown>;
+type NodeRendererInfographicProps = Partial<{
+    maxHeight: string | null;
+    estimatedPreviewHeightPx: number;
+    showHeader: boolean;
+    showModeToggle: boolean;
+    showCopyButton: boolean;
+    showCollapseButton: boolean;
+    showExportButton: boolean;
+    showFullscreenButton: boolean;
+    showZoomControls: boolean;
+}> & Record<string, unknown>;
+interface NodeRendererEvents {
+    onCopy?: (code: string) => void;
+    onHandleArtifactClick?: (payload: CodeBlockPreviewPayload) => void;
+}
+interface NodeRendererProps {
+    content?: string;
+    nodes?: readonly BaseNode[] | null;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
+    debugPerformance?: boolean;
+    customHtmlTags?: readonly string[];
+    htmlPolicy?: HtmlPolicy;
+    viewportPriority?: boolean;
+    codeBlockStream?: boolean;
+    codeBlockDarkTheme?: CodeBlockMonacoTheme;
+    codeBlockLightTheme?: CodeBlockMonacoTheme;
+    codeBlockMonacoOptions?: CodeBlockMonacoOptions;
+    renderCodeBlocksAsPre?: boolean;
+    codeBlockMinWidth?: string | number;
+    codeBlockMaxWidth?: string | number;
+    codeBlockProps?: NodeRendererCodeBlockProps;
+    mermaidProps?: NodeRendererMermaidProps;
+    d2Props?: NodeRendererD2Props;
+    infographicProps?: NodeRendererInfographicProps;
+    customComponents?: CustomComponentMap;
+    showTooltips?: boolean;
+    themes?: CodeBlockMonacoTheme[];
+    isDark?: boolean;
+    customId?: string;
+    indexKey?: number | string;
+    typewriter?: boolean;
+    /** Enable/disable non-code-node enter and streamed-text fade animations. Default: true */
+    fade?: boolean;
+    batchRendering?: boolean;
+    initialRenderBatchSize?: number;
+    renderBatchSize?: number;
+    renderBatchDelay?: number;
+    renderBatchBudgetMs?: number;
+    renderBatchIdleTimeoutMs?: number;
+    deferNodesUntilVisible?: boolean;
+    maxLiveNodes?: number;
+    liveNodeBuffer?: number;
+    allowHtml?: boolean;
+    smoothStreaming?: boolean | 'auto';
+    smoothStreamingOptions?: SmoothMarkdownStreamOptions;
+}
+interface AngularRenderContext {
+    customId?: string;
+    isDark?: boolean;
+    indexKey?: string;
+    final?: boolean;
+    typewriter?: boolean;
+    fade?: boolean;
+    textStreamState?: Map<string, string>;
+    streamRenderVersion?: number;
+    showTooltips?: boolean;
+    codeBlockStream?: boolean;
+    renderCodeBlocksAsPre?: boolean;
+    allowHtml?: boolean;
+    htmlPolicy?: HtmlPolicy;
+    customHtmlTags?: readonly string[];
+    parseOptions?: ParseOptions;
+    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
+    codeBlockProps?: NodeRendererCodeBlockProps;
+    mermaidProps?: NodeRendererMermaidProps;
+    d2Props?: NodeRendererD2Props;
+    infographicProps?: NodeRendererInfographicProps;
+    customComponents?: CustomComponentMap;
+    codeBlockThemes?: {
+        themes?: CodeBlockMonacoTheme[];
+        darkTheme?: CodeBlockMonacoTheme;
+        lightTheme?: CodeBlockMonacoTheme;
+        monacoOptions?: CodeBlockMonacoOptions;
+        minWidth?: string | number;
+        maxWidth?: string | number;
+    };
+    events: NodeRendererEvents;
+}
+declare function buildRenderContext(props: NodeRendererProps, events?: NodeRendererEvents, textStreamState?: Map<string, string>, streamRenderVersion?: number): AngularRenderContext;
+declare function resolveParsedNodes(props: NodeRendererProps): AngularRenderableNode[];
+
+declare class AdmonitionNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get kind(): string;
+    get kindClass(): string;
+    get resolvedTitle(): string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdmonitionNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AdmonitionNodeComponent, "markstream-angular-admonition-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class BlockquoteNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get cite(): string;
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BlockquoteNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<BlockquoteNodeComponent, "markstream-angular-blockquote-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class CheckboxNodeComponent {
+    node: AngularRenderableNode;
+    get checked(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CheckboxNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CheckboxNodeComponent, "markstream-angular-checkbox-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class CodeBlockNodeComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly cdr;
+    private readonly i18n;
+    private editorHost?;
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    props?: Record<string, any>;
+    useFallback: boolean;
+    copied: boolean;
+    collapsed: boolean;
+    expanded: boolean;
+    inlinePreviewOpen: boolean;
+    editorReady: boolean;
+    defaultFontSize: number;
+    fontSize: number;
+    private helpers;
+    private createPromise;
+    private syncPromise;
+    private editorKind;
+    private viewReady;
+    private destroyed;
+    private copyTimer;
+    private deferredHeightSyncRaf;
+    get t(): (key: string) => string;
+    get mergedProps(): {
+        [x: string]: any;
+        stream?: boolean;
+        darkTheme?: CodeBlockMonacoTheme;
+        lightTheme?: CodeBlockMonacoTheme;
+        themes?: CodeBlockMonacoTheme[];
+        monacoOptions?: markstream_angular.CodeBlockMonacoOptions;
+        minWidth?: string | number;
+        maxWidth?: string | number;
+        isShowPreview?: boolean;
+        enableFontSizeControl?: boolean;
+        showHeader?: boolean;
+        showCopyButton?: boolean;
+        showExpandButton?: boolean;
+        showPreviewButton?: boolean;
+        showCollapseButton?: boolean;
+        showFontSizeButtons?: boolean;
+        htmlPreviewAllowScripts?: boolean;
+        htmlPreviewSandbox?: string;
+    };
+    get resolvedLoading(): boolean;
+    get resolvedStream(): boolean;
+    get resolvedIsDark(): boolean;
+    get resolvedDarkTheme(): CodeBlockMonacoTheme;
+    get resolvedLightTheme(): CodeBlockMonacoTheme;
+    get resolvedThemes(): CodeBlockMonacoTheme[];
+    get resolvedMonacoOptions(): {
+        [x: string]: unknown;
+        MAX_HEIGHT?: number | string;
+        fontSize?: number;
+        lineHeight?: number;
+        fontFamily?: string;
+        tabSize?: number;
+        readOnly?: boolean;
+        wordWrap?: "off" | "on" | "wordWrapColumn" | "bounded" | string;
+        wrappingIndent?: "none" | "same" | "indent" | "deepIndent" | string;
+        theme?: string;
+        themes?: CodeBlockMonacoTheme[];
+        languages?: markstream_angular.CodeBlockMonacoLanguage[];
+        renderSideBySide?: boolean;
+        useInlineViewWhenSpaceIsLimited?: boolean;
+        enableSplitViewResizing?: boolean;
+        ignoreTrimWhitespace?: boolean;
+        maxComputationTime?: number;
+        diffAlgorithm?: string;
+        renderIndicators?: boolean;
+        originalEditable?: boolean;
+        revealDebounceMs?: number;
+        revealStrategy?: "bottom" | "centerIfOutside" | "center";
+        revealBatchOnIdleMs?: number;
+        updateThrottleMs?: number;
+        diffUpdateThrottleMs?: number;
+        diffAutoScroll?: boolean;
+        diffHideUnchangedRegions?: markstream_angular.CodeBlockDiffHideUnchangedRegions;
+        diffLineStyle?: markstream_angular.CodeBlockDiffLineStyle;
+        diffAppearance?: markstream_angular.CodeBlockDiffAppearance;
+        diffUnchangedRegionStyle?: markstream_angular.CodeBlockDiffUnchangedRegionStyle;
+        diffHunkActionsOnHover?: boolean;
+        diffHunkHoverHideDelayMs?: number;
+        onDiffHunkAction?: (context: markstream_angular.CodeBlockDiffHunkActionContext) => void | boolean | Promise<void | boolean>;
+        scrollbar?: Record<string, unknown>;
+    };
+    get resolvedEnableFontSizeControl(): boolean;
+    get resolvedShowHeader(): boolean;
+    get resolvedShowCopyButton(): boolean;
+    get resolvedShowExpandButton(): boolean;
+    get resolvedShowPreviewButton(): boolean;
+    get resolvedShowCollapseButton(): boolean;
+    get resolvedShowFontSizeButtons(): boolean;
+    get resolvedShowTooltips(): boolean;
+    get resolvedIsShowPreview(): boolean;
+    get rawLanguage(): string;
+    get canonicalLanguage(): string;
+    get monacoLanguage(): string;
+    get isPlainTextLanguage(): boolean;
+    get displayLanguage(): string;
+    get languageIconDataUrl(): string;
+    get resolvedCode(): string;
+    get originalCode(): string;
+    get isDiff(): boolean;
+    get isPreviewable(): boolean;
+    get previewTitle(): string;
+    get headerForeground(): string;
+    get headerBackground(): string;
+    get ariaLabel(): string;
+    get showLoadingPlaceholder(): boolean;
+    get shouldDelayEditor(): boolean;
+    get containerStyle(): Record<string, string>;
+    readonly closeInlinePreview: () => void;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    tooltipFor(text: string): string;
+    toggleCollapsed(): void;
+    toggleExpanded(): void;
+    changeFontSize(delta: number): void;
+    resetFontSize(): void;
+    copyCode(): Promise<void>;
+    previewCode(): void;
+    private applyInitialFontSize;
+    private syncEditorState;
+    private ensureHelpers;
+    private recreateEditor;
+    private updateEditor;
+    private applyEditorFontSize;
+    private applyEditorHeight;
+    private resolveEditorHeight;
+    private resolveEditorLineCount;
+    private resolveEditorLineHeight;
+    private resolveMaxHeight;
+    private cancelDeferredHeightSync;
+    private scheduleDeferredHeightSync;
+    private cleanupEditor;
+    private resolveCssSize;
+    private copyUsingTextarea;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CodeBlockNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CodeBlockNodeComponent, "markstream-angular-code-block-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "props": { "alias": "props"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class HtmlPreviewFrameComponent {
+    code: string;
+    isDark: boolean;
+    htmlPreviewAllowScripts: boolean;
+    htmlPreviewSandbox?: string;
+    title?: string;
+    onClose?: () => void;
+    private readonly i18n;
+    get resolvedTitle(): string;
+    get sandboxValue(): string;
+    get srcdoc(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlPreviewFrameComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlPreviewFrameComponent, "markstream-angular-html-preview-frame", never, { "code": { "alias": "code"; "required": false; }; "isDark": { "alias": "isDark"; "required": false; }; "htmlPreviewAllowScripts": { "alias": "htmlPreviewAllowScripts"; "required": false; }; "htmlPreviewSandbox": { "alias": "htmlPreviewSandbox"; "required": false; }; "title": { "alias": "title"; "required": false; }; "onClose": { "alias": "onClose"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class D2BlockNodeComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly cdr;
+    private previewHost?;
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    props?: Record<string, any>;
+    rendering: boolean;
+    copied: boolean;
+    collapsed: boolean;
+    showSource: boolean;
+    svgMarkup: string;
+    error: string;
+    private viewReady;
+    private destroyed;
+    private renderToken;
+    private copyTimer;
+    get mergedProps(): {
+        [x: string]: any;
+        maxHeight?: string | null;
+        themeId?: number | null;
+        darkThemeId?: number | null;
+        showHeader?: boolean;
+        showModeToggle?: boolean;
+        showCopyButton?: boolean;
+        showExportButton?: boolean;
+        showCollapseButton?: boolean;
+    };
+    get code(): string;
+    get resolvedIsDark(): boolean;
+    get resolvedShowHeader(): boolean;
+    get resolvedShowModeToggle(): boolean;
+    get resolvedShowCopyButton(): boolean;
+    get resolvedShowExportButton(): boolean;
+    get resolvedShowCollapseButton(): boolean;
+    get resolvedShowTooltips(): boolean;
+    get resolvedMaxHeight(): string;
+    get resolvedLoading(): boolean;
+    get resolvedProgressiveRender(): boolean;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    tooltipFor(text: string): string;
+    setMode(nextSource: boolean): void;
+    copySource(): Promise<void>;
+    exportSvg(): void;
+    toggleCollapsed(): void;
+    private renderDiagram;
+    private syncSvgHost;
+    private scheduleHostSync;
+    static ɵfac: i0.ɵɵFactoryDeclaration<D2BlockNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<D2BlockNodeComponent, "markstream-angular-d2-block-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "props": { "alias": "props"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class DefinitionListNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get items(): AngularRenderableNode[];
+    termFor(item: AngularRenderableNode): AngularRenderableNode[];
+    definitionFor(item: AngularRenderableNode): AngularRenderableNode[];
+    trackByIndex: (index: number) => string;
+    itemPrefix(index: number, part: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DefinitionListNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DefinitionListNodeComponent, "markstream-angular-definition-list-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class EmojiNodeComponent {
+    node: AngularRenderableNode;
+    get text(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmojiNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmojiNodeComponent, "markstream-angular-emoji-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class EmphasisNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EmphasisNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<EmphasisNodeComponent, "markstream-angular-emphasis-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FallbackComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get hasChildren(): boolean;
+    get hasNestedContent(): boolean;
+    get customTag(): string;
+    get customClassName(): string;
+    get rawBodyHtml(): string;
+    get nestedPrefix(): string;
+    get resolvedFinal(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FallbackComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FallbackComponent, "markstream-angular-fallback-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FootnoteAnchorNodeComponent {
+    node: AngularRenderableNode;
+    get id(): string;
+    get href(): string;
+    get title(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FootnoteAnchorNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FootnoteAnchorNodeComponent, "markstream-angular-footnote-anchor-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FootnoteNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get footnoteId(): string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FootnoteNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FootnoteNodeComponent, "markstream-angular-footnote-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class FootnoteReferenceNodeComponent {
+    node: AngularRenderableNode;
+    get id(): string;
+    get href(): string;
+    get referenceId(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FootnoteReferenceNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FootnoteReferenceNodeComponent, "markstream-angular-footnote-reference-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class HardBreakNodeComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HardBreakNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HardBreakNodeComponent, "markstream-angular-hardbreak-node", never, {}, {}, never, never, true, never>;
+}
+
+declare class HeadingNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get level(): number;
+    get attrs(): any;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeadingNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeadingNodeComponent, "markstream-angular-heading-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class HighlightNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HighlightNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HighlightNodeComponent, "markstream-angular-highlight-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class HtmlBlockNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    private readonly containerRef?;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    private commitContent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlBlockNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlBlockNodeComponent, "markstream-angular-html-block-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class HtmlInlineNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    private readonly containerRef?;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    private commitContent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlInlineNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlInlineNodeComponent, "markstream-angular-html-inline-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ImageNodeComponent {
+    node: AngularRenderableNode;
+    get src(): string;
+    get alt(): string;
+    get title(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ImageNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ImageNodeComponent, "markstream-angular-image-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InfographicBlockNodeComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly cdr;
+    private previewHost?;
+    private modalHost?;
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    props?: Record<string, any>;
+    rendering: boolean;
+    copied: boolean;
+    collapsed: boolean;
+    showSource: boolean;
+    modalOpen: boolean;
+    zoom: number;
+    error: string;
+    containerMinHeight: string;
+    svgMarkup: string;
+    private viewReady;
+    private destroyed;
+    private renderToken;
+    private copyTimer;
+    private infographicInstance;
+    get mergedProps(): {
+        [x: string]: any;
+        maxHeight?: string | null;
+        estimatedPreviewHeightPx?: number;
+        showHeader?: boolean;
+        showModeToggle?: boolean;
+        showCopyButton?: boolean;
+        showCollapseButton?: boolean;
+        showExportButton?: boolean;
+        showFullscreenButton?: boolean;
+        showZoomControls?: boolean;
+    };
+    get code(): string;
+    get resolvedIsDark(): boolean;
+    get resolvedShowHeader(): boolean;
+    get resolvedShowCopyButton(): boolean;
+    get resolvedShowCollapseButton(): boolean;
+    get resolvedShowModeToggle(): boolean;
+    get resolvedShowExportButton(): boolean;
+    get resolvedShowFullscreenButton(): boolean;
+    get resolvedShowZoomControls(): boolean;
+    get resolvedShowTooltips(): boolean;
+    get resolvedMaxHeight(): string;
+    get estimatedPreviewHeightPx(): number;
+    get resolvedContainerMinHeight(): string;
+    private get maxPreviewHeight();
+    private resolveContainerMinHeight;
+    get resolvedLoading(): boolean;
+    get resolvedProgressiveRender(): boolean;
+    get modalTransform(): string;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    handleWindowKeydown(event: KeyboardEvent): void;
+    tooltipFor(text: string): string;
+    setMode(nextSource: boolean): void;
+    copySource(): Promise<void>;
+    exportSvg(): void;
+    openModal(): void;
+    closeModal(): void;
+    toggleCollapsed(): void;
+    adjustZoom(delta: number): void;
+    resetZoom(): void;
+    private renderInfographic;
+    private destroyInfographic;
+    private syncModalPreview;
+    private schedulePreviewSync;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InfographicBlockNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InfographicBlockNodeComponent, "markstream-angular-infographic-block-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "props": { "alias": "props"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InlineCodeNodeComponent implements OnChanges {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    typewriter?: boolean;
+    fade?: boolean;
+    settledCode: string;
+    streamedDelta: string;
+    private streamFadeVersion;
+    ngOnChanges(): void;
+    get streamedDeltaClass(): "markstream-angular-text__stream-delta--a" | "markstream-angular-text__stream-delta--b";
+    get fadeEnabled(): boolean;
+    get typewriterEnabled(): boolean;
+    settleStreamedDelta(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InlineCodeNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InlineCodeNodeComponent, "markstream-angular-inline-code-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; "typewriter": { "alias": "typewriter"; "required": false; }; "fade": { "alias": "fade"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsertNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsertNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsertNodeComponent, "markstream-angular-insert-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class LinkNodeComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private anchorRef?;
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    private hovering;
+    get href(): string;
+    get title(): string;
+    get openInNewTab(): boolean;
+    get loading(): boolean;
+    get resolvedShowTooltip(): boolean;
+    get children(): AngularRenderableNode[];
+    get hasChildren(): boolean;
+    get fallbackLabel(): string;
+    get nestedPrefix(): string;
+    get cssVars(): Record<string, string>;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    onAnchorEnter(): void;
+    onAnchorLeave(): void;
+    private syncTooltip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LinkNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LinkNodeComponent, "markstream-angular-link-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ListItemNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    value?: number;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListItemNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListItemNodeComponent, "markstream-angular-list-item-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ListNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get ordered(): boolean;
+    get startValue(): number;
+    get items(): AngularRenderableNode[];
+    trackByIndex: (index: number) => string;
+    itemPrefix(index: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ListNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ListNodeComponent, "markstream-angular-list-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class MathBlockNodeComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly cdr;
+    private mathRef?;
+    node: AngularRenderableNode;
+    rendering: boolean;
+    private destroyed;
+    private renderVersion;
+    private hasRenderedOnce;
+    get content(): string;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    private renderMath;
+    private resolveKatexMarkup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MathBlockNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MathBlockNodeComponent, "markstream-angular-math-block-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MathInlineNodeComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly cdr;
+    private mathRef?;
+    node: AngularRenderableNode;
+    loading: boolean;
+    private destroyed;
+    private renderVersion;
+    private hasRenderedOnce;
+    get content(): string;
+    get displayMode(): boolean;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    private renderMath;
+    private resolveKatexMarkup;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MathInlineNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MathInlineNodeComponent, "markstream-angular-math-inline-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MermaidBlockNodeComponent implements AfterViewInit, OnChanges, OnDestroy {
+    private readonly cdr;
+    private previewHost?;
+    private modalHost?;
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    props?: Record<string, any>;
+    rendering: boolean;
+    copied: boolean;
+    collapsed: boolean;
+    showSource: boolean;
+    modalOpen: boolean;
+    zoom: number;
+    svgMarkup: string;
+    error: string;
+    private viewReady;
+    private destroyed;
+    private renderToken;
+    private copyTimer;
+    private lastMermaidBindFunctions;
+    get mergedProps(): {
+        [x: string]: any;
+        maxHeight?: string | null;
+        estimatedPreviewHeightPx?: number;
+        workerTimeoutMs?: number;
+        parseTimeoutMs?: number;
+        renderTimeoutMs?: number;
+        fullRenderTimeoutMs?: number;
+        renderDebounceMs?: number;
+        showHeader?: boolean;
+        showModeToggle?: boolean;
+        showCopyButton?: boolean;
+        showExportButton?: boolean;
+        showFullscreenButton?: boolean;
+        showCollapseButton?: boolean;
+        showZoomControls?: boolean;
+        isStrict?: boolean;
+        enableMermaidInteractions?: boolean;
+    };
+    get code(): string;
+    get resolvedIsDark(): boolean;
+    get resolvedShowHeader(): boolean;
+    get resolvedShowModeToggle(): boolean;
+    get resolvedShowCopyButton(): boolean;
+    get resolvedShowExportButton(): boolean;
+    get resolvedShowFullscreenButton(): boolean;
+    get resolvedShowCollapseButton(): boolean;
+    get resolvedShowZoomControls(): boolean;
+    get resolvedShowTooltips(): boolean;
+    get resolvedMaxHeight(): string;
+    get estimatedPreviewHeightPx(): number;
+    private get maxPreviewHeight();
+    get resolvedWorkerTimeout(): number;
+    get resolvedParseTimeout(): number;
+    get resolvedRenderTimeout(): number;
+    get resolvedFullRenderTimeout(): number;
+    get strictMode(): boolean;
+    get resolvedLoading(): boolean;
+    get resolvedProgressiveRender(): boolean;
+    get previewTransform(): string;
+    get modalTransform(): string;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    handleWindowKeydown(event: KeyboardEvent): void;
+    tooltipFor(text: string): string;
+    setMode(nextSource: boolean): void;
+    copySource(): Promise<void>;
+    exportSvg(): void;
+    openModal(): void;
+    closeModal(): void;
+    toggleCollapsed(): void;
+    adjustZoom(delta: number): void;
+    resetZoom(): void;
+    handleModalWheel(event: WheelEvent): void;
+    private renderDiagram;
+    private syncSvgHosts;
+    private bindMermaidInteractions;
+    private scheduleHostSync;
+    private canParseWithFallback;
+    private canParseOrPrefix;
+    private findPrefixCandidate;
+    private applyThemeTo;
+    private getMermaidDiagramKind;
+    private isGanttTaskLine;
+    private getSafeGanttPreviewCandidate;
+    private getSafePrefixCandidate;
+    private withTimeout;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MermaidBlockNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<MermaidBlockNodeComponent, "markstream-angular-mermaid-block-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "props": { "alias": "props"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type NestedRenderItem = {
+    kind: 'label';
+    attrs: Record<string, string | true> | null;
+    children: AngularRenderableNode[];
+} | {
+    kind: 'node';
+    node: AngularRenderableNode;
+};
+declare class NestedRendererComponent implements OnChanges {
+    node?: AngularRenderableNode | null;
+    nodes: readonly AngularRenderableNode[] | null | undefined;
+    content?: string | null;
+    loading?: boolean;
+    final?: boolean;
+    cacheKey?: string;
+    parseOptions?: ParseOptions;
+    customHtmlTags?: readonly string[];
+    customMarkdownIt?: (markdown: MarkdownIt) => MarkdownIt;
+    context?: AngularRenderContext;
+    indexPrefix: string;
+    items: NestedRenderItem[];
+    ngOnChanges(): void;
+    trackByIndex: (index: number) => string;
+    childPrefix(index: number): string;
+    private get resolvedNodes();
+    private buildItems;
+    private resolveFinal;
+    private resolveCustomHtmlTags;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NestedRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NestedRendererComponent, "markstream-angular-nested-renderer", never, { "node": { "alias": "node"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; "content": { "alias": "content"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "final": { "alias": "final"; "required": false; }; "cacheKey": { "alias": "cacheKey"; "required": false; }; "parseOptions": { "alias": "parseOptions"; "required": false; }; "customHtmlTags": { "alias": "customHtmlTags"; "required": false; }; "customMarkdownIt": { "alias": "customMarkdownIt"; "required": false; }; "context": { "alias": "context"; "required": false; }; "indexPrefix": { "alias": "indexPrefix"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface VisibleNodeEntry {
+    node: AngularRenderableNode;
+    index: number;
+    render: boolean;
+    animate: boolean;
+    placeholderHeight: number;
+}
+declare class NodeRendererComponent implements NodeRendererProps, OnChanges, OnInit, AfterViewInit, OnDestroy {
+    private readonly cdr;
+    private readonly hostRef;
+    private readonly smoothStream;
+    private readonly parentSmoothStreamingScope;
+    private rootRef?;
+    private typewriterCursorRef?;
+    content: string;
+    nodes?: readonly AngularRenderableNode[] | null;
+    final?: boolean;
+    parseOptions?: NodeRendererProps['parseOptions'];
+    customMarkdownIt?: NodeRendererProps['customMarkdownIt'];
+    debugPerformance?: boolean;
+    customHtmlTags?: readonly string[];
+    htmlPolicy: NodeRendererProps['htmlPolicy'];
+    viewportPriority?: boolean;
+    codeBlockStream: boolean;
+    codeBlockDarkTheme?: NodeRendererProps['codeBlockDarkTheme'];
+    codeBlockLightTheme?: NodeRendererProps['codeBlockLightTheme'];
+    codeBlockMonacoOptions?: NodeRendererProps['codeBlockMonacoOptions'];
+    renderCodeBlocksAsPre: boolean;
+    codeBlockMinWidth?: string | number;
+    codeBlockMaxWidth?: string | number;
+    codeBlockProps?: NodeRendererProps['codeBlockProps'];
+    mermaidProps?: NodeRendererProps['mermaidProps'];
+    d2Props?: NodeRendererProps['d2Props'];
+    infographicProps?: NodeRendererProps['infographicProps'];
+    customComponents?: NodeRendererProps['customComponents'];
+    showTooltips: boolean;
+    themes?: string[];
+    isDark: boolean;
+    customId?: string;
+    indexKey?: number | string;
+    /** Show a blinking typewriter cursor while streamed content grows. Default: false */
+    typewriter: boolean;
+    /** Enable/disable non-code-node enter and streamed-text fade animations. Default: true */
+    fade: boolean;
+    batchRendering: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+    allowHtml: boolean;
+    smoothStreaming: boolean | 'auto';
+    smoothStreamingOptions?: SmoothMarkdownStreamOptions;
+    copy: EventEmitter<string>;
+    handleArtifactClick: EventEmitter<CodeBlockPreviewPayload>;
+    click: EventEmitter<MouseEvent>;
+    mouseover: EventEmitter<MouseEvent>;
+    mouseout: EventEmitter<MouseEvent>;
+    parsedNodes: AngularRenderableNode[];
+    visibleEntries: VisibleNodeEntry[];
+    renderContext: AngularRenderContext;
+    topSpacerHeight: number;
+    bottomSpacerHeight: number;
+    private renderedCount;
+    private focusIndex;
+    private liveRange;
+    private readonly nodeHeights;
+    private readonly nodeVisibility;
+    private readonly nodeSeen;
+    private readonly textStreamState;
+    private streamRenderVersion;
+    private readonly slotElements;
+    private readonly observedElements;
+    private observer;
+    private observerConfig;
+    private readonly observerIndexByElement;
+    private batchTimer;
+    private batchRaf;
+    private batchIdle;
+    private batchPending;
+    private enhancementToken;
+    private enhancementTimer;
+    private enhancementHandle;
+    private postRenderTimer;
+    private unsubscribeCustomComponents?;
+    private isSyncingSmoothStream;
+    private hasMountedForSmoothStreaming;
+    private unsubscribeSmoothStream?;
+    private previousRenderContent;
+    private previousEffectiveFinal;
+    private previousRenderVersionSource;
+    showTypewriterCursor: boolean;
+    private typewriterCursorTimeout;
+    private lastTypewriterContentLength;
+    private static readonly TYPEWRITER_CURSOR_EXCLUDED_NODE_TYPES;
+    get hasNodes(): boolean;
+    get smoothStreamingEligible(): boolean;
+    get smoothStreamingEnabled(): boolean;
+    get renderContent(): string;
+    get rawContent(): string;
+    get smoothSourceSynced(): boolean;
+    get requestedFinal(): boolean | undefined;
+    get effectiveFinal(): boolean | undefined;
+    get resolvedIndexPrefix(): string;
+    isSmoothStreamingEnabled(): boolean;
+    get resolvedInitialBatchSize(): number;
+    get resolvedRenderBatchSize(): number;
+    get resolvedMaxLiveNodes(): number;
+    get resolvedLiveNodeBuffer(): number;
+    get liveWindowEnabled(): boolean;
+    get viewportPriorityEnabled(): boolean;
+    get virtualizationEnabled(): boolean;
+    get incrementalRenderingActive(): boolean;
+    get deferNodesActive(): boolean;
+    get shouldObserveSlots(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    trackByEntry: (_index: number, entry: VisibleNodeEntry) => string;
+    entryIndexKey(index: number): string;
+    handleMouseOver(event: MouseEvent): void;
+    handleMouseOut(event: MouseEvent): void;
+    private ensureSmoothStreamInitialized;
+    private syncSmoothStream;
+    private rebuild;
+    private cleanupTransientState;
+    private trimMeasuredState;
+    private refreshVisibleEntries;
+    private shouldRenderNode;
+    private scheduleBatchStep;
+    private stopBatching;
+    private schedulePostRenderWork;
+    private clearPostRenderWork;
+    private syncSlotObservers;
+    private observeSlot;
+    private ensureObserver;
+    private resolveViewportRoot;
+    private markNodeVisible;
+    private unobserveIndex;
+    private disconnectObserver;
+    private measureNodeHeights;
+    private scheduleEnhancements;
+    private applyEnhancements;
+    private disposeEnhancements;
+    private shouldSkipTypewriterCursorForNode;
+    private shouldShowTypewriterCursorForCurrentNodes;
+    private getNodeTextLength;
+    private getTypewriterContentLength;
+    private clearTypewriterCursorTimeout;
+    private getLastTextNode;
+    private updateTypewriterCursorPosition;
+    private updateTypewriterCursorState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NodeRendererComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NodeRendererComponent, "markstream-angular", never, { "content": { "alias": "content"; "required": false; }; "nodes": { "alias": "nodes"; "required": false; }; "final": { "alias": "final"; "required": false; }; "parseOptions": { "alias": "parseOptions"; "required": false; }; "customMarkdownIt": { "alias": "customMarkdownIt"; "required": false; }; "debugPerformance": { "alias": "debugPerformance"; "required": false; }; "customHtmlTags": { "alias": "customHtmlTags"; "required": false; }; "htmlPolicy": { "alias": "htmlPolicy"; "required": false; }; "viewportPriority": { "alias": "viewportPriority"; "required": false; }; "codeBlockStream": { "alias": "codeBlockStream"; "required": false; }; "codeBlockDarkTheme": { "alias": "codeBlockDarkTheme"; "required": false; }; "codeBlockLightTheme": { "alias": "codeBlockLightTheme"; "required": false; }; "codeBlockMonacoOptions": { "alias": "codeBlockMonacoOptions"; "required": false; }; "renderCodeBlocksAsPre": { "alias": "renderCodeBlocksAsPre"; "required": false; }; "codeBlockMinWidth": { "alias": "codeBlockMinWidth"; "required": false; }; "codeBlockMaxWidth": { "alias": "codeBlockMaxWidth"; "required": false; }; "codeBlockProps": { "alias": "codeBlockProps"; "required": false; }; "mermaidProps": { "alias": "mermaidProps"; "required": false; }; "d2Props": { "alias": "d2Props"; "required": false; }; "infographicProps": { "alias": "infographicProps"; "required": false; }; "customComponents": { "alias": "customComponents"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "themes": { "alias": "themes"; "required": false; }; "isDark": { "alias": "isDark"; "required": false; }; "customId": { "alias": "customId"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; "typewriter": { "alias": "typewriter"; "required": false; }; "fade": { "alias": "fade"; "required": false; }; "batchRendering": { "alias": "batchRendering"; "required": false; }; "initialRenderBatchSize": { "alias": "initialRenderBatchSize"; "required": false; }; "renderBatchSize": { "alias": "renderBatchSize"; "required": false; }; "renderBatchDelay": { "alias": "renderBatchDelay"; "required": false; }; "renderBatchBudgetMs": { "alias": "renderBatchBudgetMs"; "required": false; }; "renderBatchIdleTimeoutMs": { "alias": "renderBatchIdleTimeoutMs"; "required": false; }; "deferNodesUntilVisible": { "alias": "deferNodesUntilVisible"; "required": false; }; "maxLiveNodes": { "alias": "maxLiveNodes"; "required": false; }; "liveNodeBuffer": { "alias": "liveNodeBuffer"; "required": false; }; "allowHtml": { "alias": "allowHtml"; "required": false; }; "smoothStreaming": { "alias": "smoothStreaming"; "required": false; }; "smoothStreamingOptions": { "alias": "smoothStreamingOptions"; "required": false; }; }, { "copy": "copy"; "handleArtifactClick": "handleArtifactClick"; "click": "click"; "mouseover": "mouseover"; "mouseout": "mouseout"; }, never, never, true, never>;
+}
+
+type ParagraphSegment = {
+    kind: 'inline';
+    nodes: AngularRenderableNode[];
+    mediaOnly: boolean;
+} | {
+    kind: 'block';
+    node: AngularRenderableNode;
+};
+declare class ParagraphNodeComponent implements OnChanges {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    segments: ParagraphSegment[];
+    get children(): AngularRenderableNode[];
+    ngOnChanges(): void;
+    trackByIndex: (index: number) => string;
+    trackByChildIndex: (index: number) => number;
+    segmentPrefix(index: number): string;
+    childPrefix(segmentIndex: number, childIndex: number): string;
+    isWhitespaceText(node: AngularRenderableNode): boolean;
+    getTextContent(node: AngularRenderableNode): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ParagraphNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ParagraphNodeComponent, "markstream-angular-paragraph-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class PreCodeNodeComponent {
+    node: AngularRenderableNode;
+    get language(): string;
+    get languageClass(): string;
+    get ariaLabel(): string;
+    get code(): string;
+    get loading(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreCodeNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PreCodeNodeComponent, "markstream-angular-pre-code-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class ReferenceNodeComponent {
+    node: AngularRenderableNode;
+    get id(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReferenceNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ReferenceNodeComponent, "markstream-angular-reference-node", never, { "node": { "alias": "node"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class SafeAttrsDirective implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly appliedAttrs;
+    private readonly appliedClasses;
+    private readonly appliedStyles;
+    markstreamSafeAttrs?: Record<string, unknown> | null;
+    ngOnChanges(): void;
+    private clearAppliedState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SafeAttrsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SafeAttrsDirective, "[markstreamSafeAttrs]", never, { "markstreamSafeAttrs": { "alias": "markstreamSafeAttrs"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface SmoothStreamingScope {
+    isSmoothStreamingEnabled: () => boolean;
+}
+declare const MARKSTREAM_SMOOTH_STREAMING_SCOPE: InjectionToken<SmoothStreamingScope>;
+
+declare class StrikethroughNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StrikethroughNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StrikethroughNodeComponent, "markstream-angular-strikethrough-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class StrongNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StrongNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StrongNodeComponent, "markstream-angular-strong-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SubscriptNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubscriptNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SubscriptNodeComponent, "markstream-angular-subscript-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class SuperscriptNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SuperscriptNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SuperscriptNodeComponent, "markstream-angular-superscript-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TableNodeComponent implements OnDestroy {
+    tableElement?: ElementRef<HTMLTableElement>;
+    private readonly cdr;
+    private currentHeaderCellCount;
+    private readonly minColumnWidth;
+    private resizeState;
+    columnWidths: number[];
+    private _node;
+    set node(value: AngularRenderableNode);
+    get node(): AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get headerRow(): AngularRenderableNode;
+    get headerCells(): AngularRenderableNode[];
+    get rows(): AngularRenderableNode[];
+    cellsFor(row: AngularRenderableNode): AngularRenderableNode[];
+    childrenFor(cell: AngularRenderableNode): AngularRenderableNode[];
+    alignment(cell: AngularRenderableNode): string;
+    trackRow: (index: number) => string;
+    trackCell: (index: number) => number;
+    cellPrefix(rowIndex: string | number, cellIndex: number): string;
+    startColumnResize(index: number, event: PointerEvent): void;
+    ngOnDestroy(): void;
+    private measureHeaderWidths;
+    private onColumnResizeMove;
+    private stopColumnResize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableNodeComponent, "markstream-angular-table-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class TextNodeComponent implements OnChanges {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    typewriter?: boolean;
+    fade?: boolean;
+    settledText: string;
+    streamedDelta: string;
+    private streamFadeVersion;
+    private lastStreamRenderVersion?;
+    ngOnChanges(): void;
+    get centered(): boolean;
+    get streamedDeltaClass(): "markstream-angular-text__stream-delta--a" | "markstream-angular-text__stream-delta--b";
+    get fadeEnabled(): boolean;
+    get typewriterEnabled(): boolean;
+    settleStreamedDelta(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextNodeComponent, "markstream-angular-text-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; "typewriter": { "alias": "typewriter"; "required": false; }; "fade": { "alias": "fade"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class ThematicBreakNodeComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThematicBreakNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ThematicBreakNodeComponent, "markstream-angular-thematic-break-node", never, {}, {}, never, never, true, never>;
+}
+
+declare class VmrContainerNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VmrContainerNodeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<VmrContainerNodeComponent, "markstream-angular-vmr-container-node", never, { "node": { "alias": "node"; "required": true; }; "context": { "alias": "context"; "required": false; }; "indexKey": { "alias": "indexKey"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface EnhanceRenderedHtmlOptions {
+    final?: boolean;
+    isDark?: boolean;
+    renderCodeBlocksAsPre?: boolean;
+    monacoOptions?: CodeBlockMonacoOptions;
+    d2ThemeId?: number | null;
+    d2DarkThemeId?: number | null;
+    showTooltips?: boolean;
+    codeBlockProps?: NodeRendererCodeBlockProps;
+    mermaidProps?: NodeRendererMermaidProps;
+    d2Props?: NodeRendererD2Props;
+    infographicProps?: NodeRendererInfographicProps;
+    onCopy?: (code: string) => void;
+    isCancelled?: () => boolean;
+}
+interface RenderedHtmlEnhancementHandle {
+    dispose: () => void;
+}
+declare function enhanceRenderedHtml(root: HTMLElement, options?: EnhanceRenderedHtmlOptions): Promise<RenderedHtmlEnhancementHandle>;
+declare function disposeRenderedHtmlEnhancements(root: HTMLElement | null | undefined): void;
+
+declare function setDefaultI18nMap(map: Record<string, string>): void;
+declare function useSafeI18n(): {
+    t(key: string): string;
+};
+
+type D2Loader = () => Promise<unknown> | unknown;
+declare function setD2Loader(loader: D2Loader | null): void;
+declare function enableD2(loader?: D2Loader): void;
+declare function disableD2(): void;
+declare function isD2Enabled(): boolean;
+
+interface KatexModule {
+    renderToString: (content: string, options?: Record<string, unknown>) => string;
+}
+type KatexLoader = () => Promise<unknown> | unknown;
+declare function setKatexLoader(loader: KatexLoader | null): void;
+declare function enableKatex(loader?: KatexLoader): void;
+declare function disableKatex(): void;
+declare function isKatexEnabled(): boolean;
+declare function getKatex(): Promise<KatexModule | null>;
+
+type MermaidLoader = () => Promise<unknown> | unknown;
+interface MermaidModule {
+    render: (id: string, source: string) => Promise<MermaidRenderResult> | MermaidRenderResult;
+    parse?: (source: string) => Promise<unknown> | unknown;
+    initialize?: (config?: Record<string, unknown>) => unknown;
+    mermaidAPI?: {
+        render?: MermaidModule['render'];
+        parse?: MermaidModule['parse'];
+        initialize?: MermaidModule['initialize'];
+    };
+}
+type MermaidRenderResult = string | {
+    svg?: string;
+    bindFunctions?: (element: Element) => unknown;
+};
+interface MermaidInitConfig extends Record<string, unknown> {
+    securityLevel?: unknown;
+    flowchart?: {
+        htmlLabels?: unknown;
+    };
+}
+declare function setMermaidLoader(loader: MermaidLoader | null): void;
+declare function enableMermaid(loader?: MermaidLoader): void;
+declare function disableMermaid(): void;
+declare function isMermaidEnabled(): boolean;
+declare function getMermaid(initConfig?: MermaidInitConfig): Promise<MermaidModule | null>;
+
+type NestedMarkdownSourceNode = BaseNode & {
+    children?: BaseNode[];
+    content?: string;
+};
+interface NestedMarkdownNodesInput {
+    node?: NestedMarkdownSourceNode | null;
+    nodes?: readonly BaseNode[] | null;
+    content?: string | null;
+}
+interface NestedMarkdownNodesOptions {
+    cacheKey?: string;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customHtmlTags?: readonly string[];
+    customMarkdownIt?: (markdown: MarkdownIt) => MarkdownIt;
+}
+declare function parseNestedMarkdownToNodes(input: NestedMarkdownNodesInput, options?: NestedMarkdownNodesOptions): BaseNode[];
+
+type RenderableMarkdownNode = (ParsedNode | BaseNode) & Record<string, unknown>;
+type NestedClassValue = string | readonly string[] | null | undefined;
+interface MarkstreamAngularRenderOptions {
+    content?: string | null;
+    nodes?: readonly RenderableMarkdownNode[] | null;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customHtmlTags?: readonly string[];
+    allowHtml?: boolean;
+    htmlPolicy?: HtmlPolicy;
+}
+interface NestedMarkdownHtmlOptions {
+    cacheKey?: string;
+    customHtmlTags?: readonly string[];
+    allowHtml?: boolean;
+    htmlPolicy?: HtmlPolicy;
+    customNodeTag?: string;
+    customNodeClass?: NestedClassValue | ((node: RenderableMarkdownNode) => NestedClassValue);
+}
+interface NestedMarkdownHtmlInput {
+    node?: RenderableMarkdownNode | null;
+    nodes?: readonly RenderableMarkdownNode[] | null;
+    content?: string | null;
+}
+declare function renderMarkdownToHtml(input: MarkstreamAngularRenderOptions): string;
+declare function renderNestedMarkdownToHtml(input: NestedMarkdownHtmlInput, options?: NestedMarkdownHtmlOptions): string;
+declare function renderMarkdownNodesToHtml(nodes: readonly RenderableMarkdownNode[] | null | undefined, options?: NestedMarkdownHtmlOptions): string;
+declare function renderMarkdownNodeToHtml(node: RenderableMarkdownNode | null | undefined, options?: NestedMarkdownHtmlOptions): string;
+
+declare function sanitizeHtmlContent(content: string, policy?: HtmlPolicy): string;
+
+declare class SmoothMarkdownStreamService implements OnDestroy {
+    private controller;
+    private snapshot;
+    private readonly listeners;
+    private unsubscribeFromController?;
+    init(options?: SmoothMarkdownStreamOptions): void;
+    ngOnDestroy(): void;
+    /**
+     * Subscribe to snapshot updates. Called when the controller's visible
+     * content advances during smooth streaming. The listener is invoked
+     * after each snapshot sync so that Angular components can trigger
+     * rebuild / markForCheck.
+     */
+    subscribe(listener: () => void): () => void;
+    get source(): string;
+    get visible(): string;
+    get done(): boolean;
+    get caughtUp(): boolean;
+    get final(): boolean;
+    get pendingChars(): number;
+    enqueue(chunk: string): void;
+    finish(options?: {
+        flush?: boolean;
+    }): void;
+    flush(): void;
+    reset(initialMarkdown?: string): void;
+    pause(): void;
+    resume(): void;
+    private syncSnapshot;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SmoothMarkdownStreamService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SmoothMarkdownStreamService>;
+}
+
+type LanguageIconResolver = (lang: string) => string | undefined | null;
+declare function normalizeLanguageIdentifier(lang?: string | null): string;
+declare function resolveMonacoLanguageId(lang?: string | null): string;
+declare function setLanguageIconResolver(resolver?: LanguageIconResolver | null): void;
+declare function getLanguageIcon(lang: string): string;
+declare const languageMap: Record<string, string>;
+
+type KaTeXCDNWorkerMode = 'classic' | 'module';
+interface KaTeXCDNWorkerOptions {
+    katexUrl: string;
+    mhchemUrl?: string;
+    mode?: KaTeXCDNWorkerMode;
+    debug?: boolean;
+    workerOptions?: WorkerOptions;
+    renderOptions?: {
+        throwOnError?: boolean;
+        output?: string;
+        strict?: string;
+    };
+}
+interface KaTeXCDNWorkerHandle {
+    worker: Worker | null;
+    dispose: () => void;
+    source: string;
+}
+declare function buildKaTeXCDNWorkerSource(options: KaTeXCDNWorkerOptions): string;
+declare function createKaTeXWorkerFromCDN(options: KaTeXCDNWorkerOptions): KaTeXCDNWorkerHandle;
+
+declare const WORKER_BUSY_CODE = "WORKER_BUSY";
+declare function setKaTeXWorker(nextWorker: Worker): void;
+declare function clearKaTeXWorker(): void;
+declare function setKaTeXWorkerDebug(enabled: boolean): void;
+declare function renderKaTeXInWorker(content: string, displayMode?: boolean, timeout?: number, signal?: AbortSignal): Promise<string>;
+declare function setKaTeXCache(content: string, displayMode: boolean, html: string): void;
+declare function getKaTeXWorkerLoad(): {
+    inFlight: number;
+    max: number;
+};
+declare function setKaTeXWorkerMaxConcurrency(value: number): void;
+declare function isKaTeXWorkerBusy(): boolean;
+declare function waitForKaTeXWorkerSlot(timeout?: number, signal?: AbortSignal): Promise<void>;
+interface BackpressureOptions {
+    timeout?: number;
+    waitTimeout?: number;
+    backoffMs?: number;
+    maxRetries?: number;
+    signal?: AbortSignal;
+}
+declare const defaultBackpressure: {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+declare function setKaTeXBackpressureDefaults(options: Partial<typeof defaultBackpressure>): void;
+declare function getKaTeXBackpressureDefaults(): {
+    timeout: number;
+    waitTimeout: number;
+    backoffMs: number;
+    maxRetries: number;
+};
+declare function renderKaTeXWithBackpressure(content: string, displayMode?: boolean, options?: BackpressureOptions): Promise<string>;
+
+type MermaidCDNWorkerMode = 'classic' | 'module';
+interface MermaidCDNWorkerOptions {
+    mermaidUrl: string;
+    mode?: MermaidCDNWorkerMode;
+    debug?: boolean;
+    workerOptions?: WorkerOptions;
+    initializeOptions?: Record<string, any>;
+}
+interface MermaidCDNWorkerHandle {
+    worker: Worker | null;
+    dispose: () => void;
+    source: string;
+}
+declare function buildMermaidCDNWorkerSource(options: MermaidCDNWorkerOptions): string;
+declare function createMermaidWorkerFromCDN(options: MermaidCDNWorkerOptions): MermaidCDNWorkerHandle;
+
+type Theme = 'light' | 'dark';
+declare function setMermaidWorkerClientDebug(enabled: boolean): void;
+declare function setMermaidWorkerMaxConcurrency(value: number): void;
+declare function getMermaidWorkerLoad(): {
+    inFlight: number;
+    max: number;
+};
+declare const MERMAID_WORKER_BUSY_CODE = "WORKER_BUSY";
+declare const MERMAID_DISABLED_CODE = "MERMAID_DISABLED";
+declare function setMermaidWorker(nextWorker: Worker): void;
+declare function clearMermaidWorker(): void;
+declare function canParseOffthread(code: string, theme: Theme, timeout?: number): Promise<boolean>;
+declare function findPrefixOffthread(code: string, theme: Theme, timeout?: number): Promise<string>;
+declare function terminateWorker(): void;
+
+export { AdmonitionNodeComponent as AdmonitionNode, CodeBlockNodeComponent as AngularCodeBlockNode, BlockquoteNodeComponent as BlockquoteNode, CheckboxNodeComponent as CheckboxNode, CodeBlockNodeComponent as CodeBlockNode, D2BlockNodeComponent as D2BlockNode, DefinitionListNodeComponent as DefinitionListNode, EmojiNodeComponent as EmojiNode, EmphasisNodeComponent as EmphasisNode, FallbackComponent, FootnoteAnchorNodeComponent as FootnoteAnchorNode, FootnoteNodeComponent as FootnoteNode, FootnoteReferenceNodeComponent as FootnoteReferenceNode, HardBreakNodeComponent as HardBreakNode, HeadingNodeComponent as HeadingNode, HighlightNodeComponent as HighlightNode, HtmlBlockNodeComponent as HtmlBlockNode, HtmlInlineNodeComponent as HtmlInlineNode, HtmlPreviewFrameComponent as HtmlPreviewFrame, ImageNodeComponent as ImageNode, InfographicBlockNodeComponent as InfographicBlockNode, InlineCodeNodeComponent as InlineCodeNode, InsertNodeComponent as InsertNode, LinkNodeComponent as LinkNode, ListItemNodeComponent as ListItemNode, ListNodeComponent as ListNode, MARKSTREAM_SMOOTH_STREAMING_SCOPE, MERMAID_DISABLED_CODE, MERMAID_WORKER_BUSY_CODE, CodeBlockNodeComponent as MarkdownCodeBlockNode, NodeRendererComponent as MarkdownRenderComponent, NodeRendererComponent as MarkstreamAngularComponent, MathBlockNodeComponent as MathBlockNode, MathInlineNodeComponent as MathInlineNode, MermaidBlockNodeComponent as MermaidBlockNode, NestedRendererComponent as NestedRenderer, NodeRendererComponent as NodeRenderer, ParagraphNodeComponent as ParagraphNode, PreCodeNodeComponent as PreCodeNode, ReferenceNodeComponent as ReferenceNode, SafeAttrsDirective, SmoothMarkdownStreamService, StrikethroughNodeComponent as StrikethroughNode, StrongNodeComponent as StrongNode, SubscriptNodeComponent as SubscriptNode, SuperscriptNodeComponent as SuperscriptNode, TableNodeComponent as TableNode, TextNodeComponent as TextNode, ThematicBreakNodeComponent as ThematicBreakNode, VmrContainerNodeComponent as VmrContainerNode, WORKER_BUSY_CODE, buildKaTeXCDNWorkerSource, buildMermaidCDNWorkerSource, buildRenderContext, canParseOffthread, clearGlobalCustomComponents, clearKaTeXWorker, clearMermaidWorker, createKaTeXWorkerFromCDN, createMermaidWorkerFromCDN, disableD2, disableKatex, disableMermaid, disposeRenderedHtmlEnhancements, enableD2, enableKatex, enableMermaid, enhanceRenderedHtml, findPrefixOffthread, getCustomComponentsRevision, getCustomNodeComponents, getKaTeXBackpressureDefaults, getKaTeXWorkerLoad, getKatex, getLanguageIcon, getMermaid, getMermaidWorkerLoad, isD2Enabled, isKaTeXWorkerBusy, isKatexEnabled, isMermaidEnabled, languageMap, normalizeLanguageIdentifier, parseNestedMarkdownToNodes, removeCustomComponents, renderKaTeXInWorker, renderKaTeXWithBackpressure, renderMarkdownNodeToHtml, renderMarkdownNodesToHtml, renderMarkdownToHtml, renderNestedMarkdownToHtml, resolveMonacoLanguageId, resolveParsedNodes, sanitizeHtmlContent, setCustomComponents, setD2Loader, setDefaultI18nMap, setKaTeXBackpressureDefaults, setKaTeXCache, setKaTeXWorker, setKaTeXWorkerDebug, setKaTeXWorkerMaxConcurrency, setKatexLoader, setLanguageIconResolver, setMermaidLoader, setMermaidWorker, setMermaidWorkerClientDebug, setMermaidWorkerMaxConcurrency, subscribeCustomComponents, terminateWorker, useSafeI18n, waitForKaTeXWorkerSlot };
+export type { AngularRenderContext, AngularRenderableNode, BackpressureOptions, CodeBlockDiffAppearance, CodeBlockDiffHideUnchangedRegions, CodeBlockDiffHideUnchangedRegionsOptions, CodeBlockDiffHunkActionContext, CodeBlockDiffHunkActionKind, CodeBlockDiffHunkSide, CodeBlockDiffLineStyle, CodeBlockDiffUnchangedRegionStyle, CodeBlockMonacoLanguage, CodeBlockMonacoOptions, CodeBlockMonacoTheme, CodeBlockMonacoThemeObject, CodeBlockPreviewPayload, CustomComponentMap, D2Loader, EnhanceRenderedHtmlOptions, KaTeXCDNWorkerHandle, KaTeXCDNWorkerMode, KaTeXCDNWorkerOptions, KatexLoader, LanguageIconResolver, NodeRendererProps as MarkstreamAngularComponentProps, MarkstreamAngularRenderOptions, MermaidCDNWorkerHandle, MermaidCDNWorkerMode, MermaidCDNWorkerOptions, MermaidLoader, NestedMarkdownHtmlInput, NestedMarkdownHtmlOptions, NestedMarkdownNodesInput, NestedMarkdownNodesOptions, NodeRendererCodeBlockProps, NodeRendererD2Props, NodeRendererEvents, NodeRendererInfographicProps, NodeRendererMermaidProps, NodeRendererProps, RenderableMarkdownNode, RenderedHtmlEnhancementHandle, SmoothStreamingScope };