streamdown-angular 0.4.0

package/types/streamdown-angular.d.ts

@@ -0,0 +1,625 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnDestroy, ComponentRef, ViewContainerRef, OnInit, Type, EnvironmentProviders } from '@angular/core';
+import * as hast from 'hast';
+import { Root, RootContent, ElementContent, Element } from 'hast';
+import { PluggableList } from 'unified';
+import { ClassValue } from 'clsx';
+import * as streamdown_angular from 'streamdown-angular';
+import { SafeHtml } from '@angular/platform-browser';
+
+/**
+ * Main public component (Streamdown `index.tsx`).
+ *
+ * Usage:
+ *   <ngx-streamdown [content]="markdown()" />
+ *
+ * Data flow (React useMemo chain → Angular computed):
+ *   content → parseMarkdownIntoBlocks → @for(block) → ngx-block → hast-renderer
+ */
+declare class StreamdownComponent {
+    /** Markdown text to render (grows during streaming) */
+    readonly content: _angular_core.InputSignal<string>;
+    /** Fix incomplete markdown (such as `**bold` during streaming). Default: true */
+    readonly parseIncompleteMarkdown: _angular_core.InputSignal<boolean>;
+    /** Show a streaming caret (typing cursor) at the end of the last block. Default: false */
+    readonly caret: _angular_core.InputSignal<boolean>;
+    readonly blocks: _angular_core.Signal<string[]>;
+    readonly dir: _angular_core.Signal<"rtl" | "ltr">;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StreamdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StreamdownComponent, "ngx-streamdown", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "parseIncompleteMarkdown": { "alias": "parseIncompleteMarkdown"; "required": false; "isSignal": true; }; "caret": { "alias": "caret"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Renders a single markdown block (Streamdown `Block`, memoized).
+ *
+ * Thanks to `OnPush` + the parent's `@for track $index`, only the changed block
+ * re-renders — the streaming equivalent of React's `memo()`.
+ */
+declare class BlockComponent {
+    /** Markdown text of a single block */
+    readonly content: _angular_core.InputSignal<string>;
+    /** Fix incomplete markdown (remend) */
+    readonly parseIncompleteMarkdown: _angular_core.InputSignal<boolean>;
+    /** Whether to append a streaming caret at the end of this block (last block only) */
+    readonly caret: _angular_core.InputSignal<boolean>;
+    private readonly md;
+    readonly hast: _angular_core.Signal<hast.Root>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlockComponent, "ngx-block", never, { "content": { "alias": "content"; "required": true; "isSignal": true; }; "parseIncompleteMarkdown": { "alias": "parseIncompleteMarkdown"; "required": false; "isSignal": true; }; "caret": { "alias": "caret"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Configuration that plugins add to the pipeline (math, cjk, ...).
+ * `provideStreamdown*()` providers populate this token with `multi: true`.
+ */
+interface StreamdownPipelineConfig {
+    /** remark plugins added BEFORE remark-rehype (e.g. remark-math) */
+    remarkPlugins?: PluggableList;
+    /** rehype plugins added BEFORE rehype-sanitize (e.g. rehype-katex) */
+    rehypePlugins?: PluggableList;
+    /** Override the rehype-sanitize schema (e.g. to allow katex output) */
+    sanitizeSchema?: unknown;
+}
+declare const STREAMDOWN_PIPELINE: InjectionToken<StreamdownPipelineConfig[]>;
+/**
+ * Converts a markdown string into a HAST (HTML AST) tree.
+ * Matches the Streamdown `lib/markdown.ts` pipeline, but extensible via plugins:
+ *   remark-parse → remark-gfm → [remarkPlugins] → remark-rehype → rehype-raw
+ *     → [rehypePlugins] → rehype-sanitize
+ */
+declare class MarkdownService {
+    private readonly configs;
+    private readonly processor;
+    /**
+     * Markdown → HAST tree (sync). Uses `runSync` so each render is fast during streaming.
+     * @param options.remend "close" incomplete markdown (default: true)
+     */
+    toHast(markdown: string, options?: {
+        remend?: boolean;
+    }): Root;
+    /** Builds the pipeline with plugins (once). */
+    private build;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MarkdownService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MarkdownService>;
+}
+
+/**
+ * The entry point of the HAST renderer.
+ *
+ * When the `hast` input (Root) changes, it does not rebuild the whole tree — it
+ * **diffs (reconciles)** against the previous render: only changed text/attributes/elements
+ * are updated. During streaming this eliminates flicker, preserves scroll/selection, and updates
+ * the `node` input of special components (code-block, table) without recreating them.
+ */
+declare class HastRendererComponent implements OnDestroy {
+    /** The HAST Root tree to render */
+    readonly hast: _angular_core.InputSignal<Root>;
+    /** Append a streaming caret (text cursor) at the end */
+    readonly caret: _angular_core.InputSignal<boolean>;
+    private readonly hostRef;
+    private readonly vcr;
+    private readonly renderer;
+    private rendered;
+    private caretEl;
+    constructor();
+    ngOnDestroy(): void;
+    /** Appends the caret inside the last block element (inline) or to the host. */
+    private addCaret;
+    /** Removes the existing caret from the DOM. */
+    private removeCaret;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HastRendererComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HastRendererComponent, "ngx-hast-renderer", never, { "hast": { "alias": "hast"; "required": true; "isSignal": true; }; "caret": { "alias": "caret"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Element node + extra data (similar to React's `ExtraProps`).
+ * Passed to dynamic components via `setInput('node', ...)`.
+ */
+interface HastElementInput {
+    node: Element;
+}
+/**
+ * Child nodes the renderer iterates over.
+ * Both `Root.children` (RootContent[]) and `Element.children` (ElementContent[])
+ * fit into this union.
+ */
+type HastChild = RootContent | ElementContent;
+
+/** Add a fade-in animation to new elements (optional). */
+declare const STREAMDOWN_ANIMATE: InjectionToken<boolean>;
+/**
+ * Internal bookkeeping record for a single rendered HAST node.
+ * Diffing (reconciliation) keeps this tree of records and only updates what changed.
+ */
+interface RenderedNode {
+    /** Corresponding HAST node (previous state) */
+    hast: HastChild;
+    /** Created DOM node (text / element / component host) */
+    dom: Node;
+    /** For a special tag — the component ref (for cleanup and input updates) */
+    componentRef?: ComponentRef<unknown>;
+    /** For a generic element — its children's records */
+    children?: RenderedNode[];
+}
+/**
+ * The core of the HAST renderer. Turns a HAST tree into DOM and — most importantly —
+ * on subsequent renders **diffs (reconciles)** against the existing DOM instead of
+ * rebuilding the whole tree: only changed text/attributes/elements are updated. During streaming this:
+ *   - eliminates "flicker" (unchanged DOM is preserved),
+ *   - does not break scroll/selection/focus,
+ *   - updates the `node` input of special components (code-block, table) without recreating them,
+ *   - applies a fade-in animation naturally to new elements (only for new DOM).
+ */
+declare class HastRendererService {
+    private readonly renderer;
+    private readonly linkModal;
+    private readonly linkSafety;
+    private readonly animate;
+    /**
+     * Renders the `next` HAST nodes into `parent`, diffing against the `previous` records.
+     * On the first render `previous` is an empty array. Returns: the new tree of records
+     * (passed to the next reconcile).
+     */
+    reconcile(parent: HTMLElement, previous: RenderedNode[], next: readonly HastChild[], vcr: ViewContainerRef): RenderedNode[];
+    /** Fully cleans up records rendered via reconcile (destroys component refs). */
+    destroyAll(rendered: RenderedNode[]): void;
+    /**
+     * Creates the `nodes` list into `parent` (without diffing). Returns: the ComponentRefs.
+     * Kept for special cases (recursive render inside a table).
+     */
+    renderNodes(nodes: readonly HastChild[], parent: HTMLElement, vcr: ViewContainerRef): ComponentRef<unknown>[];
+    /** Removes the DOM children under `parent` and destroys the ComponentRefs. */
+    clear(parent: HTMLElement, refs: ComponentRef<unknown>[]): void;
+    /** Creates a new DOM/component for a single HAST node (returns detached dom). */
+    private createRendered;
+    /** Updates existing DOM in place with the new HAST node (without recreating). */
+    private patch;
+    /** Cleans up the record (and its children): destroy the component + remove from DOM. */
+    private destroyRendered;
+    /**
+     * For `a` tags: external links get `target=_blank` + `rel=noopener noreferrer`;
+     * when link safety is enabled, intercept the click and open through a modal.
+     */
+    private enhanceAnchor;
+    /** Merges the ELEMENT_CLASSES base with the element's own className. */
+    private applyClasses;
+    /** HAST properties → DOM attributes (initial, full application). */
+    private applyProperties;
+    /** Applies the attribute diff: removes the deleted ones, sets the new ones. */
+    private updateAttributes;
+    /** Writes a single HAST property to a DOM attribute (with safe allowlist logic). */
+    private setProp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HastRendererService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<HastRendererService>;
+}
+
+/**
+ * A standalone component that renders a single generic HAST element node.
+ *
+ * The main render path goes through `HastRendererService` directly with Renderer2
+ * (wrapper-free, for correct HTML semantics). This component serves as a reusable
+ * unit: for when special components want to render their HAST children, or to use it
+ * from a template as `<ngx-hast-element [node]="...">`.
+ *
+ * `:host { display: contents }` — the `<ngx-hast-element>` wrapper does not affect layout.
+ */
+declare class HastElementComponent implements OnInit, OnDestroy {
+    /** The HAST element node to render */
+    readonly node: _angular_core.InputSignal<Element>;
+    private readonly hostRef;
+    private readonly vcr;
+    private readonly renderer;
+    private refs;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HastElementComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HastElementComponent, "ngx-hast-element", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Merges class values into a single string (Streamdown `cn`).
+ * Accepts array/object/conditional values: `cn('a', cond && 'b', ['c'])`.
+ * (No Tailwind needed — styles now live as plain CSS in `streamdown.css`.)
+ */
+declare function cn(...inputs: ClassValue[]): string;
+/**
+ * HTML tagName → extra class. Empty (default) — because all typography is
+ * provided via element selectors in `streamdown.css` (`.ngx-streamdown h1` ...) and
+ * inlined automatically into `HastRendererComponent` (no Tailwind needed).
+ *
+ * Users can add their own extra classes for tags here, for example:
+ *   ELEMENT_CLASSES['h1'] = 'my-heading';
+ * This value is merged with the element's own `className` via `cn()`.
+ */
+declare const ELEMENT_CLASSES: Record<string, string>;
+/**
+ * Tags that require a dedicated Angular component (tagName → component class).
+ * Currently empty; in later stages `pre` → CodeBlock, `table` → Table will be added.
+ * Tags not in this map are rendered as generic DOM elements.
+ */
+declare const COMPONENT_MAP: Map<string, Type<unknown>>;
+
+/**
+ * Enables the fade-in animation for elements that newly appear during streaming.
+ * Thanks to diffing (reconcile), only NEW DOM is animated — existing elements don't replay.
+ * `prefers-reduced-motion` is respected.
+ */
+declare function provideStreamdownAnimation(): EnvironmentProviders;
+
+/**
+ * Splits markdown into top-level blocks (Streamdown `lib/parse-blocks.tsx`).
+ *
+ * The `marked` lexer breaks markdown into tokens; each token's `raw` text is one block.
+ * This matters for streaming: only the changed (last) block re-renders, while the
+ * rest stay unchanged thanks to `@for track $index` + OnPush.
+ */
+declare function parseMarkdownIntoBlocks(markdown: string): string[];
+
+declare function detectDirection(text: string): 'rtl' | 'ltr';
+
+/**
+ * MAIN component that renders a Markdown code block (`<pre>`).
+ *
+ * In COMPONENT_MAP this component is bound to the `pre` tag; the renderer
+ * calls `setInput('node', preElement)`.
+ *
+ * Logic:
+ *  1) First look up a component by language in `CODE_LANGUAGE_COMPONENTS`
+ *     (e.g. `mermaid`). If found, create it, pass the `code` input,
+ *     place it into the body and do NOT run Shiki.
+ *  2) Otherwise, show the code card: header (language + copy/download) and
+ *     body (Shiki output). Until highlighting is ready, plain escaped
+ *     code is shown (so it appears immediately during streaming).
+ */
+declare class CodeBlockComponent implements OnDestroy {
+    /** The `<pre>` HAST element to render. */
+    readonly node: _angular_core.InputSignal<Element>;
+    private readonly vcr;
+    private readonly highlighter;
+    private readonly sanitizer;
+    /** Host where the plugin component is placed (for registered languages). */
+    private readonly pluginHost;
+    /** Created plugin ComponentRefs (for cleanup). */
+    private pluginRefs;
+    /** Code block info: {code, language}. */
+    protected readonly info: _angular_core.Signal<streamdown_angular.CodeInfo>;
+    protected readonly code: _angular_core.Signal<string>;
+    protected readonly language: _angular_core.Signal<string>;
+    /** Name of the downloadable file (e.g. `code.ts`). */
+    protected readonly downloadName: _angular_core.Signal<string>;
+    /** Is a dedicated component registered for this language? */
+    protected readonly hasRegisteredComponent: _angular_core.Signal<boolean>;
+    /** Shiki-highlighted, sanitized HTML (null until loaded). */
+    protected readonly highlighted: _angular_core.WritableSignal<SafeHtml | null>;
+    constructor();
+    ngOnDestroy(): void;
+    private disposePlugins;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodeBlockComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodeBlockComponent, "ngx-code-block", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Service that syntax-highlights code via Shiki.
+ *
+ * `shiki` is an OPTIONAL peer dependency — so the dynamic `import()` is run
+ * once (cached) inside a try/catch. If shiki is not installed, the import
+ * fails, or the language is unknown, we fall back to a plain escaped
+ * `<pre><code>`. This service NEVER throws.
+ */
+declare class ShikiHighlighterService {
+    /** Cached promise for loading the Shiki module once. */
+    private shikiPromise;
+    /**
+     * Highlights `code` for the `lang` language and returns HTML.
+     * On error, falls back to an escaped `<pre><code>`.
+     */
+    highlight(code: string, lang: string): Promise<string>;
+    /** Lazily loads the Shiki module (once); returns `null` on failure. */
+    private loadShiki;
+    /** Plain escaped `<pre><code>` (XSS-safe fallback). */
+    private fallback;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShikiHighlighterService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ShikiHighlighterService>;
+}
+
+/**
+ * Language (lowercase) → component registry.
+ *
+ * Optional plugins (e.g. `mermaid`) can "claim" a specific code language:
+ * if a component is registered for that language, `CodeBlockComponent` creates
+ * that component instead of highlighting with Shiki.
+ *
+ * A registered component MUST accept a `code: string` (raw code) input.
+ */
+declare const CODE_LANGUAGE_COMPONENTS: Map<string, Type<unknown>>;
+
+/** Information extracted about a code block. */
+interface CodeInfo {
+    /** Raw code text (all text nodes concatenated). */
+    code: string;
+    /** Language identifier (lowercase), e.g. `'ts'`. Defaults to `'text'` if not found. */
+    language: string;
+}
+/**
+ * Finds the inner `<code>` in a `<pre>` HAST element and extracts the language and raw code.
+ *
+ * The language is taken from the value starting with `language-...` in the `<code>`'s
+ * `className` (e.g. `language-ts` → `ts`). Returns `'text'` if not found.
+ * The code is built by concatenating all descendant text nodes of the `<code>`.
+ */
+declare function extractCodeInfo(pre: Element): CodeInfo;
+/** Converts a language name to a file extension (for the download button). Defaults to `'txt'`. */
+declare function languageToExtension(lang: string): string;
+
+/**
+ * Custom component bound to `table` HAST tags (`table` → this in COMPONENT_MAP).
+ *
+ * Operating principle (AVOIDING RECURSION):
+ *   If we re-render the `table` node ITSELF, we get infinite recursion
+ *   (because `table` is in COMPONENT_MAP). So we create the `<table>` DOM
+ *   element ourselves with Renderer2 and render only the node's CHILDREN
+ *   (thead/tbody/tr ...) into that element.
+ *
+ * Additionally, a small toolbar is added for copying the table as Markdown/CSV
+ * and downloading it as CSV.
+ */
+declare class TableComponent implements OnDestroy {
+    /** HAST `table` element node to render */
+    readonly node: _angular_core.InputSignal<Element>;
+    protected readonly t: streamdown_angular.StreamdownTranslations;
+    /** Temporary "copied" message for a toolbar action (`null` when none) */
+    readonly copied: _angular_core.WritableSignal<string | null>;
+    private readonly hostElRef;
+    private readonly vcr;
+    private readonly renderer;
+    private readonly renderer2;
+    private refs;
+    private builtTable;
+    private feedbackTimer;
+    constructor();
+    ngOnDestroy(): void;
+    /** Copies the Markdown representation of the table to the clipboard. */
+    copyMarkdown(): Promise<void>;
+    /** Copies the CSV representation of the table to the clipboard. */
+    copyCsv(): Promise<void>;
+    /** Downloads the table as a `table.csv` file (via Blob). */
+    downloadCsv(): void;
+    /** Writes text to the clipboard and shows a temporary message (when the Clipboard API is available). */
+    private copyToClipboard;
+    /** Sets a temporary feedback message visible for ~2s. */
+    private flashFeedback;
+    /** Clears the built table and its ComponentRefs. */
+    private cleanup;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent, "ngx-table", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Walks a HAST `table` element and collects the text of each cell.
+ * Structure: table → (thead | tbody) → tr → (th | td). A `tr` placed directly
+ * under the table is also supported.
+ * Each cell's text is `trim()`-ed.
+ */
+declare function extractTableData(table: Element): string[][];
+/** Converts rows to RFC 4180 CSV text (CRLF row separator). */
+declare function toCsv(rows: string[][]): string;
+/**
+ * Converts rows to TSV (tab-separated) text.
+ * Tabs and newlines inside a cell are replaced with spaces (TSV has no escaping).
+ */
+declare function toTsv(rows: string[][]): string;
+/**
+ * Converts rows to a GFM Markdown table.
+ * The first row is taken as the header and a `---` separator row is added after it.
+ * Returns an empty string for empty input.
+ */
+declare function toMarkdown(rows: string[][]): string;
+
+/**
+ * Component that converts a `mermaid` language block into an SVG diagram.
+ *
+ * It is registered in the code-language registry via `provideStreamdownMermaid()`;
+ * after that, ```mermaid code blocks are rendered with this component instead of Shiki highlighting.
+ *
+ * Data flow:
+ *   code() changes → effect → renderDiagram() → dynamic import('mermaid') → m.render() → innerHTML
+ */
+declare class MermaidComponent {
+    /** Raw mermaid source to render (provided by the registry via the `code` input) */
+    readonly code: _angular_core.InputSignal<string>;
+    /** Container where the SVG is placed */
+    private readonly host;
+    private readonly renderer;
+    protected readonly t: streamdown_angular.StreamdownTranslations;
+    /** Indicates a render is in progress (loading state) */
+    protected readonly rendering: _angular_core.WritableSignal<boolean>;
+    /** Error message (when non-empty, the error box is shown) */
+    protected readonly errorMessage: _angular_core.WritableSignal<string | null>;
+    /** Whether at least one successful render has occurred (for streaming UX) */
+    protected readonly hasRendered: _angular_core.WritableSignal<boolean>;
+    /**
+     * Sequence number of the most recent render request. Async renders may finish out of order —
+     * we only write the result of the latest request to the DOM (to avoid a race condition).
+     */
+    private renderSeq;
+    constructor();
+    /**
+     * Dynamically loads mermaid and renders the current `code()` to SVG.
+     *
+     * IMPORTANT: first we validate the syntax with `mermaid.parse(..., { suppressErrors: true })`.
+     * During streaming, when the code is not yet complete, parse returns `false` — in that case
+     * we do NOT call `m.render()` AT ALL (so mermaid's "Syntax error" bomb graphic does not
+     * appear) and we keep the previous diagram.
+     */
+    private renderDiagram;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MermaidComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MermaidComponent, "ngx-mermaid", never, { "code": { "alias": "code"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Enables mermaid diagrams. Add `provideStreamdownMermaid()` in `app.config.ts`:
+ *
+ *   export const appConfig: ApplicationConfig = {
+ *     providers: [provideStreamdownMermaid()],
+ *   };
+ *
+ * This binds the `mermaid` language to the code-language registry, so ```mermaid code blocks
+ * are rendered as SVG diagrams via `MermaidComponent`.
+ */
+declare function provideStreamdownMermaid(): EnvironmentProviders;
+
+/**
+ * Enables KaTeX math formulas ($inline$ and $$block$$).
+ * IMPORTANT: the consuming app MUST import `katex/dist/katex.min.css`.
+ */
+declare function provideStreamdownMath(): EnvironmentProviders;
+
+/**
+ * Sanitize schema that preserves KaTeX output.
+ * A deeply extended copy of `defaultSchema`:
+ *  - allows `className`/`style`/`aria-hidden` on all elements,
+ *  - adds MathML + SVG (katex) tags to `tagNames`.
+ * Loosely typed because the token expects `unknown`.
+ */
+declare const katexSanitizeSchema: unknown;
+
+/**
+ * UI strings (i18n). Angular equivalent of Streamdown `translations-context.tsx`.
+ * Can be partially or fully overridden via `provideStreamdownTranslations({...})`.
+ */
+interface StreamdownTranslations {
+    copy: string;
+    copied: string;
+    download: string;
+    copyMarkdown: string;
+    copyCsv: string;
+    downloadCsv: string;
+    openLink: string;
+    cancel: string;
+    open: string;
+    linkWarningTitle: string;
+    linkWarningBody: string;
+    mermaidError: string;
+    renderingDiagram: string;
+    imageError: string;
+}
+/** Default (English) strings. */
+declare const DEFAULT_TRANSLATIONS: StreamdownTranslations;
+declare const STREAMDOWN_TRANSLATIONS: InjectionToken<Partial<StreamdownTranslations>>;
+/** Components get UI strings through this service. */
+declare class TranslationsService {
+    private readonly overrides;
+    /** Merged strings (default + override). */
+    readonly t: StreamdownTranslations;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslationsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TranslationsService>;
+}
+/**
+ * Overrides the UI strings (i18n). For example, in Uzbek:
+ *   provideStreamdownTranslations({ copy: 'Nusxa', copied: 'Nusxalandi', download: 'Yuklab olish' })
+ */
+declare function provideStreamdownTranslations(translations: Partial<StreamdownTranslations>): EnvironmentProviders;
+
+/**
+ * Icons (inline SVG strings). Equivalent of Streamdown `icon-context.tsx`.
+ * Each value is a full `<svg>...</svg>` string. Override with your own icons
+ * via `provideStreamdownIcons({...})` (e.g. lucide/heroicons).
+ */
+interface StreamdownIcons {
+    copy: string;
+    check: string;
+    download: string;
+    externalLink: string;
+    close: string;
+    chevronDown: string;
+}
+/** Default icons (minimal SVG in lucide style). */
+declare const DEFAULT_ICONS: StreamdownIcons;
+declare const STREAMDOWN_ICONS: InjectionToken<Partial<StreamdownIcons>>;
+/** Components get icons through this service. */
+declare class IconService {
+    private readonly overrides;
+    /** Merged icons (default + override). */
+    readonly icons: StreamdownIcons;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<IconService>;
+}
+/** Overrides the icons. */
+declare function provideStreamdownIcons(icons: Partial<StreamdownIcons>): EnvironmentProviders;
+
+/**
+ * CSS class/data-attribute prefix. Equivalent of Streamdown `prefix-context.tsx`.
+ * Provides a stable "hook" for styling (e.g. `data-streamdown="code-block"`).
+ */
+declare const STREAMDOWN_PREFIX: InjectionToken<string>;
+declare class PrefixService {
+    /** Default prefix 'streamdown'. */
+    readonly prefix: string;
+    /** `prefixed('code-block')` → `'streamdown-code-block'`. */
+    prefixed(name: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PrefixService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<PrefixService>;
+}
+/** Overrides the class/data-attribute prefix. */
+declare function provideStreamdownPrefix(prefix: string): EnvironmentProviders;
+
+/**
+ * Component for markdown images (`img`). Equivalent of Streamdown `lib/image.tsx`.
+ *
+ * Bound to the `img` tag in COMPONENT_MAP. Comes with a loading skeleton, error state and
+ * lazy-loading. The `node` input is the hast `img` element node.
+ */
+declare class ImageComponent {
+    /** hast `img` element node */
+    readonly node: _angular_core.InputSignal<Element>;
+    protected readonly t: streamdown_angular.StreamdownTranslations;
+    protected readonly loaded: _angular_core.WritableSignal<boolean>;
+    protected readonly errored: _angular_core.WritableSignal<boolean>;
+    protected readonly src: _angular_core.Signal<string>;
+    protected readonly alt: _angular_core.Signal<string>;
+    protected readonly title: _angular_core.Signal<string | null>;
+    private prop;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageComponent, "ngx-image", never, { "node": { "alias": "node"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * External link confirmation modal. Added to the `StreamdownComponent` template and
+ * shown when `LinkModalService.pendingUrl` is set. Otherwise renders nothing.
+ */
+declare class LinkModalComponent {
+    private readonly svc;
+    protected readonly t: streamdown_angular.StreamdownTranslations;
+    protected readonly url: _angular_core.WritableSignal<string | null>;
+    confirm(): void;
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LinkModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LinkModalComponent, "ngx-link-modal", never, {}, {}, never, never, true, never>;
+}
+
+/** Whether link safety is enabled (default: no). */
+declare const STREAMDOWN_LINK_SAFETY: InjectionToken<boolean>;
+/**
+ * Manages the confirmation modal shown when an external link is clicked.
+ * Angular equivalent of the Streamdown `lib/link-modal.tsx` logic.
+ */
+declare class LinkModalService {
+    /** URL awaiting confirmation (modal is closed when null). */
+    readonly pendingUrl: _angular_core.WritableSignal<string | null>;
+    /** Opens the modal with the given URL. */
+    request(url: string): void;
+    /** Confirms: opens the link in a new window and closes the modal. */
+    confirm(): void;
+    /** Cancels: closes the modal, the link is not opened. */
+    cancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LinkModalService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<LinkModalService>;
+}
+/**
+ * Enables the confirmation modal for external links (safety UX).
+ * When enabled, clicking http(s) links first shows the modal.
+ */
+declare function provideStreamdownLinkSafety(): EnvironmentProviders;
+
+export { BlockComponent, CODE_LANGUAGE_COMPONENTS, COMPONENT_MAP, CodeBlockComponent, DEFAULT_ICONS, DEFAULT_TRANSLATIONS, ELEMENT_CLASSES, HastElementComponent, HastRendererComponent, HastRendererService, IconService, ImageComponent, LinkModalComponent, LinkModalService, MarkdownService, MermaidComponent, PrefixService, STREAMDOWN_ANIMATE, STREAMDOWN_ICONS, STREAMDOWN_LINK_SAFETY, STREAMDOWN_PIPELINE, STREAMDOWN_PREFIX, STREAMDOWN_TRANSLATIONS, ShikiHighlighterService, StreamdownComponent, TableComponent, TranslationsService, cn, detectDirection, extractCodeInfo, extractTableData, katexSanitizeSchema, languageToExtension, parseMarkdownIntoBlocks, provideStreamdownAnimation, provideStreamdownIcons, provideStreamdownLinkSafety, provideStreamdownMath, provideStreamdownMermaid, provideStreamdownPrefix, provideStreamdownTranslations, toCsv, toMarkdown, toTsv };
+export type { CodeInfo, HastChild, HastElementInput, RenderedNode, StreamdownIcons, StreamdownPipelineConfig, StreamdownTranslations };