markstream-angular 0.0.1-alpha.0

package/dist/types/components/NodeRenderer/NodeRenderer.component.d.ts

@@ -0,0 +1,120 @@
+import { AfterViewInit, OnChanges, OnDestroy, OnInit, EventEmitter } from '@angular/core';
+import { AngularRenderContext, AngularRenderableNode, NodeRendererProps } from '../shared/node-helpers';
+interface VisibleNodeEntry {
+    node: AngularRenderableNode;
+    index: number;
+    render: boolean;
+    animate: boolean;
+    placeholderHeight: number;
+}
+export declare class NodeRendererComponent implements NodeRendererProps, OnChanges, OnInit, AfterViewInit, OnDestroy {
+    private readonly cdr;
+    private readonly hostRef;
+    private rootRef?;
+    content: string;
+    nodes?: readonly AngularRenderableNode[] | null;
+    final?: boolean;
+    parseOptions?: NodeRendererProps['parseOptions'];
+    customMarkdownIt?: NodeRendererProps['customMarkdownIt'];
+    debugPerformance?: boolean;
+    customHtmlTags?: readonly string[];
+    viewportPriority?: boolean;
+    codeBlockStream: boolean;
+    codeBlockDarkTheme?: any;
+    codeBlockLightTheme?: any;
+    codeBlockMonacoOptions?: Record<string, any>;
+    renderCodeBlocksAsPre: boolean;
+    codeBlockMinWidth?: string | number;
+    codeBlockMaxWidth?: string | number;
+    codeBlockProps?: Record<string, any>;
+    mermaidProps?: Record<string, any>;
+    d2Props?: Record<string, any>;
+    infographicProps?: Record<string, any>;
+    customComponents?: NodeRendererProps['customComponents'];
+    showTooltips: boolean;
+    themes?: string[];
+    isDark: boolean;
+    customId?: string;
+    indexKey?: number | string;
+    typewriter: boolean;
+    batchRendering: boolean;
+    initialRenderBatchSize: number;
+    renderBatchSize: number;
+    renderBatchDelay: number;
+    renderBatchBudgetMs: number;
+    renderBatchIdleTimeoutMs: number;
+    deferNodesUntilVisible: boolean;
+    maxLiveNodes: number;
+    liveNodeBuffer: number;
+    allowHtml: boolean;
+    copy: EventEmitter<string>;
+    handleArtifactClick: EventEmitter<any>;
+    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 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?;
+    get resolvedIndexPrefix(): string;
+    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(): 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 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;
+}
+export {};

package/dist/types/components/ParagraphNode/ParagraphNode.component.d.ts

@@ -0,0 +1,20 @@
+import { OnChanges } from '@angular/core';
+import { AngularRenderContext, AngularRenderableNode } from '../shared/node-helpers';
+type ParagraphSegment = {
+    kind: 'inline';
+    nodes: AngularRenderableNode[];
+} | {
+    kind: 'block';
+    node: AngularRenderableNode;
+};
+export declare class ParagraphNodeComponent implements OnChanges {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    segments: ParagraphSegment[];
+    get children(): AngularRenderableNode[];
+    ngOnChanges(): void;
+    trackByIndex: (index: number) => string;
+    segmentPrefix(index: number): string;
+}
+export {};

package/dist/types/components/PreCodeNode/PreCodeNode.component.d.ts

@@ -0,0 +1,9 @@
+import { AngularRenderableNode } from '../shared/node-helpers';
+export declare class PreCodeNodeComponent {
+    node: AngularRenderableNode;
+    get language(): string;
+    get languageClass(): string;
+    get ariaLabel(): string;
+    get code(): string;
+    get loading(): boolean;
+}

package/dist/types/components/ReferenceNode/ReferenceNode.component.d.ts

@@ -0,0 +1,5 @@
+import { AngularRenderableNode } from '../shared/node-helpers';
+export declare class ReferenceNodeComponent {
+    node: AngularRenderableNode;
+    get id(): string;
+}

package/dist/types/components/StrikethroughNode/StrikethroughNode.component.d.ts

@@ -0,0 +1,8 @@
+import { AngularRenderContext, AngularRenderableNode } from '../shared/node-helpers';
+export declare class StrikethroughNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+}

package/dist/types/components/StrongNode/StrongNode.component.d.ts

@@ -0,0 +1,8 @@
+import { AngularRenderContext, AngularRenderableNode } from '../shared/node-helpers';
+export declare class StrongNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+}

package/dist/types/components/SubscriptNode/SubscriptNode.component.d.ts

@@ -0,0 +1,8 @@
+import { AngularRenderContext, AngularRenderableNode } from '../shared/node-helpers';
+export declare class SubscriptNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+}

package/dist/types/components/SuperscriptNode/SuperscriptNode.component.d.ts

@@ -0,0 +1,8 @@
+import { AngularRenderContext, AngularRenderableNode } from '../shared/node-helpers';
+export declare class SuperscriptNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+}

package/dist/types/components/TableNode/TableNode.component.d.ts

@@ -0,0 +1,14 @@
+import { AngularRenderContext, AngularRenderableNode } from '../shared/node-helpers';
+export declare class TableNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get headerRow(): 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;
+}

package/dist/types/components/TextNode/TextNode.component.d.ts

@@ -0,0 +1,6 @@
+import { AngularRenderableNode } from '../shared/node-helpers';
+export declare class TextNodeComponent {
+    node: AngularRenderableNode;
+    get text(): string;
+    get centered(): boolean;
+}

package/dist/types/components/ThematicBreakNode/ThematicBreakNode.component.d.ts

@@ -0,0 +1,2 @@
+export declare class ThematicBreakNodeComponent {
+}

package/dist/types/components/VmrContainerNode/VmrContainerNode.component.d.ts

@@ -0,0 +1,8 @@
+import { AngularRenderContext, AngularRenderableNode } from '../shared/node-helpers';
+export declare class VmrContainerNodeComponent {
+    node: AngularRenderableNode;
+    context?: AngularRenderContext;
+    indexKey?: string;
+    get children(): AngularRenderableNode[];
+    get nestedPrefix(): string;
+}

package/dist/types/components/shared/node-helpers.d.ts

@@ -0,0 +1,99 @@
+import { Type } from '@angular/core';
+import { BaseNode, MarkdownIt, ParseOptions, ParsedNode } from 'stream-markdown-parser';
+export type AngularRenderableNode = (ParsedNode | BaseNode) & Record<string, unknown>;
+export interface NodeRendererEvents {
+    onCopy?: (code: string) => void;
+    onHandleArtifactClick?: (payload: any) => void;
+}
+export interface NodeRendererProps {
+    content?: string;
+    nodes?: readonly BaseNode[] | null;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
+    debugPerformance?: boolean;
+    customHtmlTags?: readonly string[];
+    viewportPriority?: boolean;
+    codeBlockStream?: boolean;
+    codeBlockDarkTheme?: any;
+    codeBlockLightTheme?: any;
+    codeBlockMonacoOptions?: Record<string, any>;
+    renderCodeBlocksAsPre?: boolean;
+    codeBlockMinWidth?: string | number;
+    codeBlockMaxWidth?: string | number;
+    codeBlockProps?: Record<string, any>;
+    mermaidProps?: Record<string, any>;
+    d2Props?: Record<string, any>;
+    infographicProps?: Record<string, any>;
+    customComponents?: Record<string, Type<any>>;
+    showTooltips?: boolean;
+    themes?: string[];
+    isDark?: boolean;
+    customId?: string;
+    indexKey?: number | string;
+    typewriter?: boolean;
+    batchRendering?: boolean;
+    initialRenderBatchSize?: number;
+    renderBatchSize?: number;
+    renderBatchDelay?: number;
+    renderBatchBudgetMs?: number;
+    renderBatchIdleTimeoutMs?: number;
+    deferNodesUntilVisible?: boolean;
+    maxLiveNodes?: number;
+    liveNodeBuffer?: number;
+    allowHtml?: boolean;
+}
+export interface AngularRenderContext {
+    customId?: string;
+    isDark?: boolean;
+    indexKey?: string;
+    final?: boolean;
+    typewriter?: boolean;
+    showTooltips?: boolean;
+    codeBlockStream?: boolean;
+    renderCodeBlocksAsPre?: boolean;
+    allowHtml?: boolean;
+    customHtmlTags?: readonly string[];
+    parseOptions?: ParseOptions;
+    customMarkdownIt?: (md: MarkdownIt) => MarkdownIt;
+    codeBlockProps?: Record<string, any>;
+    mermaidProps?: Record<string, any>;
+    d2Props?: Record<string, any>;
+    infographicProps?: Record<string, any>;
+    customComponents?: Record<string, Type<any>>;
+    codeBlockThemes?: {
+        themes?: string[];
+        darkTheme?: any;
+        lightTheme?: any;
+        monacoOptions?: Record<string, any>;
+        minWidth?: string | number;
+        maxWidth?: string | number;
+    };
+    events: NodeRendererEvents;
+}
+export declare const BLOCK_LEVEL_TYPES: Set<string>;
+export declare function buildRenderContext(props: NodeRendererProps, events?: NodeRendererEvents): AngularRenderContext;
+export declare function resolveParsedNodes(props: NodeRendererProps): AngularRenderableNode[];
+export declare function getNodeList(value: unknown): AngularRenderableNode[];
+export declare function getString(value: unknown): string;
+export declare function normalizeCustomHtmlTags(tags?: readonly string[]): string[];
+export declare function normalizeTagName(value: unknown): string;
+export declare function isSafeAttrName(value: string): boolean;
+export declare function escapeHtml(value: unknown): string;
+export declare function escapeAttr(value: unknown): string;
+export declare function sanitizeClassToken(value: string): string;
+export declare function clampHeadingLevel(value: unknown): number;
+export declare function capitalize(value: string): string;
+export declare function getHtmlTagFromContent(html: unknown): string;
+export declare function stripCustomHtmlWrapper(html: unknown, tag: string): string;
+export declare function normalizeCodeLanguage(raw: unknown): string;
+export declare function resolveCodeBlockLanguage(node: AngularRenderableNode): string;
+export declare function encodeDataPayload(value: string): any;
+export declare function normalizeTokenAttrs(attrs?: Array<[string, string | null]> | null): Record<string, string | true>;
+export declare function splitParagraphChildren(children: readonly AngularRenderableNode[]): ({
+    kind: "inline";
+    nodes: AngularRenderableNode[];
+} | {
+    kind: "block";
+    node: AngularRenderableNode;
+})[];

package/dist/types/components/shared/node-outlet-helpers.d.ts

@@ -0,0 +1,7 @@
+import { AngularRenderContext, AngularRenderableNode } from './node-helpers';
+export type CodeBlockMode = 'mermaid' | 'd2' | 'infographic' | 'pre' | 'code';
+export declare function resolveNodeOutletCodeMode(node: AngularRenderableNode, context?: AngularRenderContext): CodeBlockMode;
+export declare function resolveHtmlTag(node: AngularRenderableNode): string;
+export declare function coerceCustomHtmlNode(node: AngularRenderableNode): AngularRenderableNode;
+export declare function coerceBuiltinHtmlNode(node: AngularRenderableNode, resolvedType: string): AngularRenderableNode;
+export declare function resolveNodeOutletCustomInputs(node: AngularRenderableNode, context?: AngularRenderContext): Record<string, any>;

package/dist/types/components/shared/render-window.d.ts

@@ -0,0 +1,18 @@
+export declare const DEFAULT_NODE_HEIGHT = 32;
+export declare const MAX_DEFERRED_NODE_COUNT = 900;
+export interface LiveRange {
+    start: number;
+    end: number;
+}
+export interface DeferNodesOptions {
+    deferNodesUntilVisible?: boolean;
+    maxLiveNodes?: number;
+    parsedNodeCount: number;
+    viewportPriority?: boolean;
+    virtualizationEnabled: boolean;
+}
+export declare function resolveVirtualizationEnabled(parsedNodeCount: number, maxLiveNodes?: number): boolean;
+export declare function resolveDeferNodes(options: DeferNodesOptions): boolean;
+export declare function resolveAverageNodeHeight(nodeHeights: ReadonlyMap<number, number>, fallback?: number): number;
+export declare function estimateHeightRange(start: number, end: number, nodeHeights: ReadonlyMap<number, number>, averageNodeHeight: number): number;
+export declare function computeLiveRange(total: number, focusIndex: number, maxLiveNodes?: number, liveNodeBuffer?: number): LiveRange;

package/dist/types/components/shared/rich-block-helpers.d.ts

@@ -0,0 +1,6 @@
+export declare function copyTextToClipboard(source: string): Promise<boolean>;
+export declare function clearElement(target: HTMLElement | null | undefined): void;
+export declare function setElementHtml(target: HTMLElement | null | undefined, html: string): void;
+export declare function downloadSvgMarkup(svgMarkup: string, filename: string): void;
+export declare function resolveCssSize(value: unknown, fallback?: string): string;
+export declare function clampNumber(value: number, min: number, max: number): number;

package/dist/types/components/shared/safe-attrs.directive.d.ts

@@ -0,0 +1,11 @@
+import { OnChanges } from '@angular/core';
+export 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;
+}

package/dist/types/customComponents.d.ts

@@ -0,0 +1,9 @@
+import { Type } from '@angular/core';
+export type CustomComponentMap = Record<string, Type<any>>;
+export declare function subscribeCustomComponents(listener: () => void): () => void;
+export declare function getCustomComponentsRevision(): number;
+export declare function setCustomComponents(id: string, mapping: CustomComponentMap): void;
+export declare function setCustomComponents(mapping: CustomComponentMap): void;
+export declare function getCustomNodeComponents(customId?: string): CustomComponentMap;
+export declare function removeCustomComponents(id: string): void;
+export declare function clearGlobalCustomComponents(): void;

package/dist/types/enhanceRenderedHtml.d.ts

@@ -0,0 +1,20 @@
+export interface EnhanceRenderedHtmlOptions {
+    final?: boolean;
+    isDark?: boolean;
+    renderCodeBlocksAsPre?: boolean;
+    monacoOptions?: Record<string, any>;
+    d2ThemeId?: number | null;
+    d2DarkThemeId?: number | null;
+    showTooltips?: boolean;
+    codeBlockProps?: Record<string, any>;
+    mermaidProps?: Record<string, any>;
+    d2Props?: Record<string, any>;
+    infographicProps?: Record<string, any>;
+    onCopy?: (code: string) => void;
+    isCancelled?: () => boolean;
+}
+export interface RenderedHtmlEnhancementHandle {
+    dispose: () => void;
+}
+export declare function enhanceRenderedHtml(root: HTMLElement, options?: EnhanceRenderedHtmlOptions): Promise<RenderedHtmlEnhancementHandle>;
+export declare function disposeRenderedHtmlEnhancements(root: HTMLElement | null | undefined): void;

package/dist/types/hydrateCustomTagContent.d.ts

@@ -0,0 +1,2 @@
+import { BaseNode } from 'stream-markdown-parser';
+export declare function hydrateCustomTagContent<T extends BaseNode>(nodes: readonly T[] | null | undefined, source: string, customHtmlTags?: readonly string[]): T[];

package/dist/types/i18n/useSafeI18n.d.ts

@@ -0,0 +1,4 @@
+export declare function setDefaultI18nMap(map: Record<string, string>): void;
+export declare function useSafeI18n(): {
+    t(key: string): string;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,71 @@
+export { AdmonitionNodeComponent as AdmonitionNode } from './components/AdmonitionNode/AdmonitionNode.component';
+export { BlockquoteNodeComponent as BlockquoteNode } from './components/BlockquoteNode/BlockquoteNode.component';
+export { CheckboxNodeComponent as CheckboxNode } from './components/CheckboxNode/CheckboxNode.component';
+export { CodeBlockNodeComponent as CodeBlockNode } from './components/CodeBlockNode/CodeBlockNode.component';
+export { CodeBlockNodeComponent as AngularCodeBlockNode } from './components/CodeBlockNode/CodeBlockNode.component';
+export { CodeBlockNodeComponent as MarkdownCodeBlockNode } from './components/CodeBlockNode/CodeBlockNode.component';
+export { HtmlPreviewFrameComponent as HtmlPreviewFrame } from './components/CodeBlockNode/HtmlPreviewFrame.component';
+export { D2BlockNodeComponent as D2BlockNode } from './components/D2BlockNode/D2BlockNode.component';
+export { DefinitionListNodeComponent as DefinitionListNode } from './components/DefinitionListNode/DefinitionListNode.component';
+export { EmojiNodeComponent as EmojiNode } from './components/EmojiNode/EmojiNode.component';
+export { EmphasisNodeComponent as EmphasisNode } from './components/EmphasisNode/EmphasisNode.component';
+export { FallbackComponent } from './components/FallbackComponent/FallbackComponent.component';
+export { FootnoteAnchorNodeComponent as FootnoteAnchorNode } from './components/FootnoteAnchorNode/FootnoteAnchorNode.component';
+export { FootnoteNodeComponent as FootnoteNode } from './components/FootnoteNode/FootnoteNode.component';
+export { FootnoteReferenceNodeComponent as FootnoteReferenceNode } from './components/FootnoteReferenceNode/FootnoteReferenceNode.component';
+export { HardBreakNodeComponent as HardBreakNode } from './components/HardBreakNode/HardBreakNode.component';
+export { HeadingNodeComponent as HeadingNode } from './components/HeadingNode/HeadingNode.component';
+export { HighlightNodeComponent as HighlightNode } from './components/HighlightNode/HighlightNode.component';
+export { HtmlBlockNodeComponent as HtmlBlockNode } from './components/HtmlBlockNode/HtmlBlockNode.component';
+export { HtmlInlineNodeComponent as HtmlInlineNode } from './components/HtmlInlineNode/HtmlInlineNode.component';
+export { ImageNodeComponent as ImageNode } from './components/ImageNode/ImageNode.component';
+export { InfographicBlockNodeComponent as InfographicBlockNode } from './components/InfographicBlockNode/InfographicBlockNode.component';
+export { InlineCodeNodeComponent as InlineCodeNode } from './components/InlineCodeNode/InlineCodeNode.component';
+export { InsertNodeComponent as InsertNode } from './components/InsertNode/InsertNode.component';
+export { LinkNodeComponent as LinkNode } from './components/LinkNode/LinkNode.component';
+export { ListItemNodeComponent as ListItemNode } from './components/ListItemNode/ListItemNode.component';
+export { ListNodeComponent as ListNode } from './components/ListNode/ListNode.component';
+export { MarkstreamAngularComponent } from './markstream-angular.component';
+export { MarkstreamAngularComponent as MarkdownRenderComponent } from './markstream-angular.component';
+export { MathBlockNodeComponent as MathBlockNode } from './components/MathBlockNode/MathBlockNode.component';
+export { MathInlineNodeComponent as MathInlineNode } from './components/MathInlineNode/MathInlineNode.component';
+export { MermaidBlockNodeComponent as MermaidBlockNode } from './components/MermaidBlockNode/MermaidBlockNode.component';
+export { NestedRendererComponent as NestedRenderer } from './components/NestedRenderer/NestedRenderer.component';
+export { NodeRendererComponent as NodeRenderer } from './components/NodeRenderer/NodeRenderer.component';
+export { ParagraphNodeComponent as ParagraphNode } from './components/ParagraphNode/ParagraphNode.component';
+export { PreCodeNodeComponent as PreCodeNode } from './components/PreCodeNode/PreCodeNode.component';
+export { ReferenceNodeComponent as ReferenceNode } from './components/ReferenceNode/ReferenceNode.component';
+export { SafeAttrsDirective } from './components/shared/safe-attrs.directive';
+export { StrikethroughNodeComponent as StrikethroughNode } from './components/StrikethroughNode/StrikethroughNode.component';
+export { StrongNodeComponent as StrongNode } from './components/StrongNode/StrongNode.component';
+export { SubscriptNodeComponent as SubscriptNode } from './components/SubscriptNode/SubscriptNode.component';
+export { SuperscriptNodeComponent as SuperscriptNode } from './components/SuperscriptNode/SuperscriptNode.component';
+export { TableNodeComponent as TableNode } from './components/TableNode/TableNode.component';
+export { TextNodeComponent as TextNode } from './components/TextNode/TextNode.component';
+export { ThematicBreakNodeComponent as ThematicBreakNode } from './components/ThematicBreakNode/ThematicBreakNode.component';
+export { VmrContainerNodeComponent as VmrContainerNode } from './components/VmrContainerNode/VmrContainerNode.component';
+export { clearGlobalCustomComponents, getCustomComponentsRevision, getCustomNodeComponents, removeCustomComponents, setCustomComponents, subscribeCustomComponents, } from './customComponents';
+export type { CustomComponentMap } from './customComponents';
+export { disposeRenderedHtmlEnhancements, enhanceRenderedHtml, } from './enhanceRenderedHtml';
+export type { EnhanceRenderedHtmlOptions, RenderedHtmlEnhancementHandle } from './enhanceRenderedHtml';
+export type { AngularRenderContext, AngularRenderableNode, NodeRendererEvents, NodeRendererProps, } from './components/shared/node-helpers';
+export { buildRenderContext, resolveParsedNodes, } from './components/shared/node-helpers';
+export { setDefaultI18nMap, useSafeI18n } from './i18n/useSafeI18n';
+export { renderMarkdownNodeToHtml, renderMarkdownNodesToHtml, renderMarkdownToHtml, renderNestedMarkdownToHtml, } from './renderMarkdownHtml';
+export type { MarkstreamAngularRenderOptions, NestedMarkdownHtmlInput, NestedMarkdownHtmlOptions, RenderableMarkdownNode, } from './renderMarkdownHtml';
+export { sanitizeHtmlContent } from './sanitizeHtmlContent';
+export { getLanguageIcon, languageMap, normalizeLanguageIdentifier, resolveMonacoLanguageId, setLanguageIconResolver, } from './utils/languageIcon';
+export type { LanguageIconResolver } from './utils/languageIcon';
+export { parseNestedMarkdownToNodes, } from './parseNestedMarkdownToNodes';
+export type { NestedMarkdownNodesInput, NestedMarkdownNodesOptions, } from './parseNestedMarkdownToNodes';
+export type { D2Loader } from './optional/d2';
+export { disableD2, enableD2, isD2Enabled, setD2Loader, } from './optional/d2';
+export type { KatexLoader } from './optional/katex';
+export { disableKatex, enableKatex, getKatex, isKatexEnabled, setKatexLoader, } from './optional/katex';
+export type { MermaidLoader } from './optional/mermaid';
+export { disableMermaid, enableMermaid, getMermaid, isMermaidEnabled, setMermaidLoader, } from './optional/mermaid';
+export * from './workers/katexCdnWorker';
+export * from './workers/katexWorkerClient';
+export * from './workers/mermaidCdnWorker';
+export * from './workers/mermaidWorkerClient';
+export { MarkstreamAngularComponent as default } from './markstream-angular.component';

package/dist/types/markstream-angular.component.d.ts

@@ -0,0 +1,2 @@
+export { NodeRendererComponent as MarkstreamAngularComponent } from './components/NodeRenderer/NodeRenderer.component';
+export type { NodeRendererProps as MarkstreamAngularComponentProps } from './components/shared/node-helpers';

package/dist/types/optional/d2.d.ts

@@ -0,0 +1,6 @@
+export type D2Loader = () => Promise<any> | any;
+export declare function setD2Loader(loader: D2Loader | null): void;
+export declare function enableD2(loader?: D2Loader): void;
+export declare function disableD2(): void;
+export declare function isD2Enabled(): boolean;
+export declare function getD2(): Promise<any>;

package/dist/types/optional/infographic.d.ts

@@ -0,0 +1 @@
+export declare function getInfographic(): Promise<any>;

package/dist/types/optional/katex.d.ts

@@ -0,0 +1,6 @@
+export type KatexLoader = () => Promise<any> | any;
+export declare function setKatexLoader(loader: KatexLoader | null): void;
+export declare function enableKatex(loader?: KatexLoader): void;
+export declare function disableKatex(): void;
+export declare function isKatexEnabled(): boolean;
+export declare function getKatex(): Promise<any>;

package/dist/types/optional/mermaid.d.ts

@@ -0,0 +1,6 @@
+export type MermaidLoader = () => Promise<any> | any;
+export declare function setMermaidLoader(loader: MermaidLoader | null): void;
+export declare function enableMermaid(loader?: MermaidLoader): void;
+export declare function disableMermaid(): void;
+export declare function isMermaidEnabled(): boolean;
+export declare function getMermaid(initConfig?: Record<string, any>): Promise<any>;

package/dist/types/optional/monaco.d.ts

@@ -0,0 +1 @@
+export declare function getUseMonaco(): Promise<any>;

package/dist/types/parseNestedMarkdownToNodes.d.ts

@@ -0,0 +1,14 @@
+import { BaseNode, MarkdownIt, ParseOptions } from 'stream-markdown-parser';
+export interface NestedMarkdownNodesInput {
+    node?: (BaseNode & Record<string, any>) | null;
+    nodes?: readonly BaseNode[] | null;
+    content?: string | null;
+}
+export interface NestedMarkdownNodesOptions {
+    cacheKey?: string;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customHtmlTags?: readonly string[];
+    customMarkdownIt?: (markdown: MarkdownIt) => MarkdownIt;
+}
+export declare function parseNestedMarkdownToNodes(input: NestedMarkdownNodesInput, options?: NestedMarkdownNodesOptions): BaseNode[];

package/dist/types/renderMarkdownHtml.d.ts

@@ -0,0 +1,28 @@
+import { BaseNode, ParseOptions, ParsedNode } from 'stream-markdown-parser';
+export type RenderableMarkdownNode = (ParsedNode | BaseNode) & Record<string, unknown>;
+type NestedClassValue = string | readonly string[] | null | undefined;
+export interface MarkstreamAngularRenderOptions {
+    content?: string | null;
+    nodes?: readonly RenderableMarkdownNode[] | null;
+    final?: boolean;
+    parseOptions?: ParseOptions;
+    customHtmlTags?: readonly string[];
+    allowHtml?: boolean;
+}
+export interface NestedMarkdownHtmlOptions {
+    cacheKey?: string;
+    customHtmlTags?: readonly string[];
+    allowHtml?: boolean;
+    customNodeTag?: string;
+    customNodeClass?: NestedClassValue | ((node: RenderableMarkdownNode) => NestedClassValue);
+}
+export interface NestedMarkdownHtmlInput {
+    node?: RenderableMarkdownNode | null;
+    nodes?: readonly RenderableMarkdownNode[] | null;
+    content?: string | null;
+}
+export declare function renderMarkdownToHtml(input: MarkstreamAngularRenderOptions): string;
+export declare function renderNestedMarkdownToHtml(input: NestedMarkdownHtmlInput, options?: NestedMarkdownHtmlOptions): string;
+export declare function renderMarkdownNodesToHtml(nodes: readonly RenderableMarkdownNode[] | null | undefined, options?: NestedMarkdownHtmlOptions): string;
+export declare function renderMarkdownNodeToHtml(node: RenderableMarkdownNode | null | undefined, options?: NestedMarkdownHtmlOptions): string;
+export {};

package/dist/types/sanitizeHtmlContent.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeHtmlContent(content: string): string;

package/dist/types/sanitizeSvg.d.ts

@@ -0,0 +1,2 @@
+export declare function toSafeSvgMarkup(svg: string | null | undefined): string;
+export declare function extractRenderedSvg(renderResult: any): any;

package/dist/types/tooltip/singletonTooltip.d.ts

@@ -0,0 +1,3 @@
+export type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+export declare function showTooltipForAnchor(anchor: HTMLElement | null, content: string, placement?: TooltipPlacement, immediate?: boolean, isDark?: boolean | null): void;
+export declare function hideTooltip(immediate?: boolean): void;

package/dist/types/utils/languageIcon.d.ts

@@ -0,0 +1,6 @@
+export type LanguageIconResolver = (lang: string) => string | undefined | null;
+export declare function normalizeLanguageIdentifier(lang?: string | null): string;
+export declare function resolveMonacoLanguageId(lang?: string | null): string;
+export declare function setLanguageIconResolver(resolver?: LanguageIconResolver | null): void;
+export declare function getLanguageIcon(lang: string): string;
+export declare const languageMap: Record<string, string>;

package/dist/types/workers/katexCdnWorker.d.ts

@@ -0,0 +1,20 @@
+export type KaTeXCDNWorkerMode = 'classic' | 'module';
+export interface KaTeXCDNWorkerOptions {
+    katexUrl: string;
+    mhchemUrl?: string;
+    mode?: KaTeXCDNWorkerMode;
+    debug?: boolean;
+    workerOptions?: WorkerOptions;
+    renderOptions?: {
+        throwOnError?: boolean;
+        output?: string;
+        strict?: string;
+    };
+}
+export interface KaTeXCDNWorkerHandle {
+    worker: Worker | null;
+    dispose: () => void;
+    source: string;
+}
+export declare function buildKaTeXCDNWorkerSource(options: KaTeXCDNWorkerOptions): string;
+export declare function createKaTeXWorkerFromCDN(options: KaTeXCDNWorkerOptions): KaTeXCDNWorkerHandle;