markstream-solid 0.0.0-stage → 2.0.23

package/dist/client/workers/mermaidCdnWorker.js

@@ -0,0 +1,226 @@
+import { applyMermaidThemeDirective as s } from "markstream-core";
+function o(e) {
+  return JSON.stringify(e);
+}
+function l(e) {
+  const i = e.mode ?? "module", a = o(e.mermaidUrl), t = o({
+    startOnLoad: !1,
+    securityLevel: "strict",
+    flowchart: { htmlLabels: !1 },
+    ...e.initializeOptions || {}
+  }), r = `
+let DEBUG = false
+let mermaid = null
+let mermaidLoadError = null
+
+const applyMermaidThemeDirective = ${s.toString()}
+
+function normalizeMermaidModule(mod) {
+  if (!mod)
+    return mod
+  const candidate = mod && mod.default ? mod.default : mod
+  if (candidate && (typeof candidate.render === 'function' || typeof candidate.parse === 'function' || typeof candidate.initialize === 'function'))
+    return candidate
+  if (candidate && candidate.mermaidAPI && (typeof candidate.mermaidAPI.render === 'function' || typeof candidate.mermaidAPI.parse === 'function')) {
+    const api = candidate.mermaidAPI
+    return {
+      ...candidate,
+      render: api.render ? api.render.bind(api) : undefined,
+      parse: api.parse ? api.parse.bind(api) : undefined,
+      initialize: (opts) => {
+        if (typeof candidate.initialize === 'function')
+          return candidate.initialize(opts)
+        return api.initialize ? api.initialize(opts) : undefined
+      },
+    }
+  }
+  if (mod && mod.mermaid && typeof mod.mermaid.parse === 'function')
+    return mod.mermaid
+  return candidate
+}
+
+function applyThemeTo(code, theme) {
+  const themeValue = theme === 'dark' ? 'dark' : 'default'
+  const themeConfig = \`%%{init: {"theme": "\${themeValue}"}}%%\\n\`
+  return applyMermaidThemeDirective(code || '', themeConfig)
+}
+
+function findHeaderIndex(lines) {
+  const headerRe = /^(?:graph|flowchart|flowchart\\s+tb|flowchart\\s+lr|sequenceDiagram|gantt|classDiagram|stateDiagram(?:-v2)?|erDiagram|journey|pie|quadrantChart|timeline|xychart(?:-beta)?)\\b/
+  let inFrontmatter = lines[0]?.trimEnd() === '---'
+  for (let i = 0; i < lines.length; i++) {
+    const line = (lines[i] || '').trim()
+    if (inFrontmatter) {
+      if (i > 0 && lines[i].trimEnd() === '---')
+        inFrontmatter = false
+      continue
+    }
+    if (!line || line.startsWith('%%'))
+      continue
+    if (headerRe.test(line))
+      return i
+  }
+  return -1
+}
+
+async function canParse(code, theme) {
+  const themed = applyThemeTo(code, theme)
+  if (mermaid && typeof mermaid.parse === 'function') {
+    await mermaid.parse(themed)
+    return true
+  }
+  throw new Error('mermaid.parse not available in worker')
+}
+
+async function findLastRenderablePrefix(baseCode, theme) {
+  const lines = String(baseCode || '').split(/\\r\\n?|\\n/)
+  const headerIndex = findHeaderIndex(lines)
+  if (headerIndex === -1)
+    return null
+  const head = lines.slice(0, headerIndex + 1)
+  await canParse(head.join('\\n'), theme)
+
+  let low = headerIndex + 1
+  let high = lines.length
+  let lastGood = headerIndex + 1
+  let tries = 0
+  const MAX_TRIES = 12
+
+  while (low <= high && tries < MAX_TRIES) {
+    const mid = Math.floor((low + high) / 2)
+    const candidate = [...head, ...lines.slice(headerIndex + 1, mid)].join('\\n')
+    tries += 1
+    try {
+      await canParse(candidate, theme)
+      lastGood = mid
+      low = mid + 1
+    }
+    catch {
+      high = mid - 1
+    }
+  }
+
+  return [...head, ...lines.slice(headerIndex + 1, lastGood)].join('\\n')
+}
+
+function initMermaidOnce() {
+  if (!mermaid)
+    return
+  try {
+    if (typeof mermaid.initialize === 'function')
+      mermaid.initialize(${t})
+  }
+  catch (e) {
+    if (DEBUG)
+      console.warn('[markstream-solid:mermaid-cdn-worker] initialize failed', e)
+  }
+}
+
+globalThis.addEventListener('message', async (ev) => {
+  const msg = ev.data || {}
+  if (msg.type === 'init') {
+    DEBUG = !!msg.debug
+    return
+  }
+
+  const id = msg.id
+  const action = msg.action
+  const payload = msg.payload || {}
+
+  if (!mermaid) {
+    const error = mermaidLoadError ? String(mermaidLoadError?.message || mermaidLoadError) : 'Mermaid is not available in worker'
+    globalThis.postMessage({ id, ok: false, error })
+    return
+  }
+
+  try {
+    if (action === 'canParse') {
+      const ok = await canParse(payload.code, payload.theme)
+      globalThis.postMessage({ id, ok: true, result: ok })
+      return
+    }
+    if (action === 'findPrefix') {
+      const result = await findLastRenderablePrefix(payload.code, payload.theme)
+      globalThis.postMessage({ id, ok: true, result })
+      return
+    }
+    globalThis.postMessage({ id, ok: false, error: 'Unknown action' })
+  }
+  catch (e) {
+    globalThis.postMessage({ id, ok: false, error: String(e?.message || e) })
+  }
+})
+`.trimStart();
+  return i === "module" ? `
+${r}
+
+let loadPromise = null
+async function loadMermaid() {
+  if (mermaid || mermaidLoadError)
+    return
+  if (!loadPromise) {
+    loadPromise = (async () => {
+      try {
+        const mod = await import(${a})
+        mermaid = normalizeMermaidModule(mod) || null
+        initMermaidOnce()
+      }
+      catch (e) {
+        mermaidLoadError = e
+      }
+    })()
+  }
+  await loadPromise
+}
+
+await loadMermaid()
+`.trimStart() : `
+${r}
+
+function loadMermaidClassic() {
+  if (mermaid || mermaidLoadError)
+    return
+  try {
+    importScripts(${a})
+    mermaid = normalizeMermaidModule(globalThis.mermaid) || null
+    initMermaidOnce()
+  }
+  catch (e) {
+    mermaidLoadError = e
+  }
+}
+
+loadMermaidClassic()
+`.trimStart();
+}
+function u(e) {
+  const i = l(e);
+  if (typeof Worker > "u" || typeof URL > "u" || typeof Blob > "u")
+    return {
+      worker: null,
+      dispose: () => {
+      },
+      source: i
+    };
+  const a = new Blob([i], { type: "text/javascript" }), t = URL.createObjectURL(a);
+  let r = !1;
+  const d = () => {
+    if (!r) {
+      r = !0;
+      try {
+        URL.revokeObjectURL(t);
+      } catch {
+      }
+    }
+  }, m = (e.mode ?? "module") === "module" ? { ...e.workerOptions ?? {}, type: "module" } : e.workerOptions, n = new Worker(t, m);
+  if (e.debug)
+    try {
+      n.postMessage({ type: "init", debug: !0 });
+    } catch {
+    }
+  return { worker: n, dispose: d, source: i };
+}
+export {
+  l as buildMermaidCDNWorkerSource,
+  u as createMermaidWorkerFromCDN
+};

package/dist/client/workers/mermaidParser.worker.js

@@ -0,0 +1,73 @@
+import { applyMermaidThemeDirective as u } from "markstream-core";
+import f from "mermaid";
+f.initialize({ startOnLoad: !1, securityLevel: "strict", flowchart: { htmlLabels: !1 } });
+function p(r, t) {
+  return u(r, `%%{init: {"theme": "${t === "dark" ? "dark" : "default"}"}}%%
+`);
+}
+function g(r) {
+  const t = /^(?:graph|flowchart|flowchart\s+tb|flowchart\s+lr|sequenceDiagram|gantt|classDiagram|stateDiagram(?:-v2)?|erDiagram|journey|pie|quadrantChart|timeline|xychart(?:-beta)?)\b/;
+  let a = r[0]?.trimEnd() === "---";
+  for (let e = 0; e < r.length; e += 1) {
+    const n = r[e].trim();
+    if (a) {
+      e > 0 && r[e].trimEnd() === "---" && (a = !1);
+      continue;
+    }
+    if (!(!n || n.startsWith("%%")) && t.test(n))
+      return e;
+  }
+  return -1;
+}
+async function c(r, t) {
+  const a = p(r, t), e = f;
+  if (typeof e.parse == "function")
+    return await e.parse(a), !0;
+  throw new Error("mermaid.parse not available in worker");
+}
+async function y(r, t) {
+  const a = r.split(/\r\n?|\n/), e = g(a);
+  if (e === -1)
+    return null;
+  const n = a.slice(0, e + 1);
+  await c(n.join(`
+`), t);
+  let o = e + 1, s = a.length, l = e + 1, d = 0;
+  const m = 12;
+  for (; o <= s && d < m; ) {
+    const i = Math.floor((o + s) / 2), h = [...n, ...a.slice(e + 1, i)].join(`
+`);
+    d += 1;
+    try {
+      await c(h, t), l = i, o = i + 1;
+    } catch {
+      s = i - 1;
+    }
+  }
+  return [...n, ...a.slice(e + 1, l)].join(`
+`);
+}
+self.onmessage = async (r) => {
+  const t = r.data, a = (e) => self.postMessage(e);
+  try {
+    if (t.action === "canParse") {
+      a({
+        id: t.id,
+        ok: !0,
+        result: await c(t.payload.code, t.payload.theme)
+      });
+      return;
+    }
+    if (t.action === "findPrefix") {
+      a({
+        id: t.id,
+        ok: !0,
+        result: await y(t.payload.code, t.payload.theme)
+      });
+      return;
+    }
+    a({ id: t.id, ok: !1, error: "Unknown action" });
+  } catch (e) {
+    a({ id: t.id, ok: !1, error: e?.message ?? String(e) });
+  }
+};

package/dist/client/workers/mermaidWorkerClient.js

@@ -0,0 +1,13 @@
+import { M as a, a as s, c as t, b as M, f as o, h as d, j as i, k as f, l as k, t as m } from "../mermaidWorkerClient-BAvGYsCO.js";
+export {
+  a as MERMAID_DISABLED_CODE,
+  s as MERMAID_WORKER_BUSY_CODE,
+  t as canParseOffthread,
+  M as clearMermaidWorker,
+  o as findPrefixOffthread,
+  d as getMermaidWorkerLoad,
+  i as setMermaidWorker,
+  f as setMermaidWorkerClientDebug,
+  k as setMermaidWorkerMaxConcurrency,
+  m as terminateWorker
+};

package/dist/components/BuiltinNodes.d.ts

@@ -0,0 +1,42 @@
+import type { JSX } from 'solid-js';
+import type { NodeComponentProps } from '../customComponents';
+import type { ImageNodeProps, LinkNodeProps, MathBlockNodeProps, MathInlineNodeProps, ReferenceNodeProps } from '../types/component-props';
+export declare function ParagraphNode(props: NodeComponentProps): JSX.Element;
+export declare function HeadingNode(props: NodeComponentProps): JSX.Element;
+export declare function StrongNode(props: NodeComponentProps): JSX.Element;
+export declare function EmphasisNode(props: NodeComponentProps): JSX.Element;
+export declare function StrikethroughNode(props: NodeComponentProps): JSX.Element;
+export declare function HighlightNode(props: NodeComponentProps): JSX.Element;
+export declare function InsertNode(props: NodeComponentProps): JSX.Element;
+export declare function SubscriptNode(props: NodeComponentProps): JSX.Element;
+export declare function SuperscriptNode(props: NodeComponentProps): JSX.Element;
+export declare function BlockquoteNode(props: NodeComponentProps): JSX.Element;
+export declare function ListNode(props: NodeComponentProps): JSX.Element;
+export declare function ListItemNode(props: NodeComponentProps): JSX.Element;
+export declare function HardBreakNode(): JSX.Element;
+export declare function ThematicBreakNode(): JSX.Element;
+export declare function InlineCodeNode(props: NodeComponentProps): JSX.Element;
+export declare function CheckboxNode(props: NodeComponentProps): JSX.Element;
+export declare function EmojiNode(props: NodeComponentProps): JSX.Element;
+export declare function ReferenceNode(props: ReferenceNodeProps & Omit<NodeComponentProps, 'node'>): JSX.Element;
+export declare function HtmlInlineNode(props: NodeComponentProps): JSX.Element;
+export declare function HtmlBlockNode(props: NodeComponentProps): JSX.Element;
+export declare function MathInlineNode(props: MathInlineNodeProps & Omit<NodeComponentProps, 'node'>): JSX.Element;
+export declare function MathBlockNode(props: MathBlockNodeProps & Omit<NodeComponentProps, 'node'>): JSX.Element;
+export declare function FallbackComponent(props: NodeComponentProps): JSX.Element;
+export declare function VmrContainerNode(props: NodeComponentProps): JSX.Element;
+export declare function DefinitionListNode(props: NodeComponentProps): JSX.Element;
+export declare function AdmonitionNode(props: NodeComponentProps): JSX.Element;
+export declare function FootnoteNode(props: NodeComponentProps): JSX.Element;
+export declare function FootnoteReferenceNode(props: NodeComponentProps): JSX.Element;
+export declare function FootnoteAnchorNode(props: NodeComponentProps): JSX.Element;
+export declare function LinkNode(props: LinkNodeProps & Omit<NodeComponentProps, 'node' | 'indexKey'>): JSX.Element;
+export declare function ImageNode(props: ImageNodeProps & Omit<NodeComponentProps, 'node'> & {
+    onLoad?: (src: string) => void;
+    onError?: (src: string) => void;
+    onClick?: (payload: [
+        Event,
+        string
+    ]) => void;
+}): JSX.Element;
+export declare function TableNode(props: NodeComponentProps): JSX.Element;

package/dist/components/CodeBlockNode.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from 'solid-js';
+import type { NodeComponentProps } from '../customComponents';
+import type { CodeBlockNodeProps, CodeBlockPreviewPayload } from '../types/component-props';
+export type SolidCodeBlockNodeProps = CodeBlockNodeProps & Omit<NodeComponentProps, 'node'> & {
+    headerLeft?: JSX.Element | (() => JSX.Element);
+    headerRight?: JSX.Element | (() => JSX.Element);
+    onCopy?: (code: string) => void;
+    onPreviewCode?: (payload: CodeBlockPreviewPayload) => void;
+};
+export declare function CodeBlockNode(input: SolidCodeBlockNodeProps): JSX.Element;

package/dist/components/DiagramBlockNode.d.ts

@@ -0,0 +1,27 @@
+import type { JSX } from 'solid-js';
+import type { NodeComponentProps } from '../customComponents';
+import type { D2BlockNodeProps, InfographicBlockNodeProps, MermaidBlockEvent, MermaidBlockNodeProps } from '../types/component-props';
+interface DiagramEvents {
+    onCopy?: (event: MermaidBlockEvent<{
+        type: 'copy';
+        text: string;
+    }>) => void;
+    onExport?: (event: MermaidBlockEvent<{
+        type: 'export';
+    }>) => void;
+    onOpenModal?: (event: MermaidBlockEvent<{
+        type: 'open-modal';
+    }>) => void;
+    onToggleMode?: (mode: 'source' | 'preview', event: MermaidBlockEvent<{
+        type: 'toggle-mode';
+        target: 'source' | 'preview';
+    }>) => void;
+}
+type DiagramProps = MermaidBlockNodeProps & D2BlockNodeProps & InfographicBlockNodeProps & Omit<NodeComponentProps, 'node'> & DiagramEvents & {
+    kind: 'mermaid' | 'd2' | 'infographic';
+};
+export declare function DiagramBlockNode(input: DiagramProps): JSX.Element;
+export declare function MermaidBlockNode(props: MermaidBlockNodeProps & Omit<NodeComponentProps, 'node'> & DiagramEvents): JSX.Element;
+export declare function D2BlockNode(props: D2BlockNodeProps & Omit<NodeComponentProps, 'node'> & DiagramEvents): JSX.Element;
+export declare function InfographicBlockNode(props: InfographicBlockNodeProps & Omit<NodeComponentProps, 'node'> & DiagramEvents): JSX.Element;
+export {};

package/dist/components/HtmlPreviewFrame.d.ts

@@ -0,0 +1,10 @@
+import type { JSX } from 'solid-js';
+export interface HtmlPreviewFrameProps {
+    code: string;
+    isDark?: boolean;
+    htmlPreviewAllowScripts?: boolean;
+    htmlPreviewSandbox?: string;
+    onClose?: () => void;
+    title?: string;
+}
+export declare function HtmlPreviewFrame(props: HtmlPreviewFrameProps): JSX.Element;

package/dist/components/MarkstreamProvider.d.ts

@@ -0,0 +1,5 @@
+import type { JSX } from 'solid-js';
+import type { MarkstreamSolidOptions } from '../configuration';
+export declare function MarkstreamProvider(props: MarkstreamSolidOptions & {
+    children?: JSX.Element;
+}): JSX.Element;

package/dist/components/MarkstreamVirtualTimeline.d.ts

@@ -0,0 +1,35 @@
+import type { JSX } from 'solid-js';
+import type { MarkstreamVirtualMetrics, MarkstreamVirtualState } from '../types/node-renderer-props';
+import type { MarkstreamThreadVirtualState, MarkstreamTimelineItem, MarkstreamVirtualTimelineProps } from '../virtual-adapter';
+export interface MarkstreamVirtualTimelineHandle {
+    captureThreadState: () => MarkstreamThreadVirtualState;
+    restoreThreadState: (state: MarkstreamThreadVirtualState) => void;
+    scrollToBottom: () => void;
+    scrollToIndex: (index: number, align?: 'start' | 'center' | 'end') => void;
+    scrollToOffset: (offset: number) => void;
+    getItemSize: (key: string) => number | undefined;
+    getTotalHeight: () => number;
+    getVisibleRange: () => {
+        start: number;
+        end: number;
+    };
+}
+export declare function MarkstreamVirtualTimeline<T = MarkstreamTimelineItem>(props: MarkstreamVirtualTimelineProps<T> & {
+    class?: string;
+    style?: JSX.CSSProperties;
+    ref?: (handle: MarkstreamVirtualTimelineHandle) => void;
+    renderItem?: (item: T, index: number) => JSX.Element;
+    onHeightChange?: (payload: {
+        itemKey: string;
+        metrics: MarkstreamVirtualMetrics;
+    }) => void;
+    onVirtualStateChange?: (payload: {
+        itemKey: string;
+        state: MarkstreamVirtualState;
+    }) => void;
+    onThreadStateChange?: (state: MarkstreamThreadVirtualState) => void;
+    onRangeChange?: (range: {
+        start: number;
+        end: number;
+    }) => void;
+}): JSX.Element;

package/dist/components/MathNode.d.ts

@@ -0,0 +1,6 @@
+import type { JSX } from 'solid-js';
+import type { NodeComponentProps } from '../customComponents';
+export declare function MathNode(props: NodeComponentProps & {
+    block: boolean;
+    cacheScope?: string | number;
+}): JSX.Element;

package/dist/components/NodeRenderer.d.ts

@@ -0,0 +1,27 @@
+import type { JSX } from 'solid-js';
+import type { CodeBlockPreviewPayload } from '../types/component-props';
+import type { MarkstreamRendererHandle, MarkstreamVirtualAnchor, MarkstreamVirtualMetrics, MarkstreamVirtualState } from '../types/node-renderer-props';
+import type { NodeRendererProps } from './shared/node-helpers';
+export interface MarkdownRenderProps extends NodeRendererProps {
+    'data-theme'?: string;
+    'class'?: string;
+    'className'?: string;
+    'style'?: JSX.CSSProperties;
+    'onCopy'?: (code: string) => void;
+    'onCopyCode'?: (payload: {
+        type: 'copy';
+        text: string;
+    }) => void;
+    'onHandleArtifactClick'?: (payload: CodeBlockPreviewPayload) => void;
+    'ref'?: (handle: MarkstreamRendererHandle) => void;
+    'onHeightChange'?: (metrics: MarkstreamVirtualMetrics) => void;
+    'onVirtualStateChange'?: (state: MarkstreamVirtualState) => void;
+    'onAnchorChange'?: (anchor: MarkstreamVirtualAnchor) => void;
+    'onRenderSettled'?: (metrics: MarkstreamVirtualMetrics) => void;
+    'onRenderFinal'?: (metrics: MarkstreamVirtualMetrics) => void;
+    'onClick'?: JSX.EventHandlerUnion<HTMLDivElement, MouseEvent>;
+    'onMouseover'?: JSX.EventHandlerUnion<HTMLDivElement, MouseEvent>;
+    'onMouseout'?: JSX.EventHandlerUnion<HTMLDivElement, MouseEvent>;
+}
+export declare function NodeRenderer(input: MarkdownRenderProps): JSX.Element;
+export default NodeRenderer;

package/dist/components/NodeSlot.d.ts

@@ -0,0 +1,11 @@
+import type { JSX } from 'solid-js';
+import type { SolidRenderableNode, SolidRenderContext } from './shared/node-helpers';
+export declare function NodeSlot(props: {
+    node: SolidRenderableNode;
+    index: number;
+    indexKey: string;
+    context: SolidRenderContext;
+    defer: boolean;
+    margin: string;
+    estimatedHeight: number;
+}): JSX.Element;

package/dist/components/PreCodeBlock.d.ts

@@ -0,0 +1,3 @@
+import type { JSX } from 'solid-js';
+import type { SolidCodeBlockNodeProps } from './CodeBlockNode';
+export declare function PreCodeBlock(input: SolidCodeBlockNodeProps): JSX.Element;

package/dist/components/PreCodeNode.d.ts

@@ -0,0 +1,9 @@
+import type { JSX } from 'solid-js';
+import type { NodeComponentProps } from '../customComponents';
+import type { CodeBlockOptions, PreCodeNodeProps } from '../types/component-props';
+export declare function PreCodeNode(props: PreCodeNodeProps & Omit<NodeComponentProps, 'node'> & {
+    codeBlockOptions?: CodeBlockOptions;
+    themeName?: string;
+    class?: string;
+    style?: JSX.CSSProperties;
+}): JSX.Element;

package/dist/components/RenderNode.d.ts

@@ -0,0 +1,11 @@
+import type { JSX } from 'solid-js';
+import type { NodeComponentProps } from '../customComponents';
+import type { SolidRenderableNode } from './shared/node-helpers';
+export declare function RenderChildren(props: NodeComponentProps & {
+    nodes?: readonly SolidRenderableNode[];
+}): JSX.Element;
+export declare function TextNode(props: NodeComponentProps): JSX.Element;
+export declare function RichNode(props: NodeComponentProps): JSX.Element;
+export declare function RenderNode(props: NodeComponentProps): JSX.Element;
+export { CodeBlockNode } from './CodeBlockNode';
+export { PreCodeNode } from './PreCodeNode';

package/dist/components/StreamingTextNode.d.ts

@@ -0,0 +1,2 @@
+import type { NodeComponentProps } from '../customComponents';
+export declare function StreamingTextNode(props: NodeComponentProps): import("solid-js").JSX.Element;

package/dist/components/ToolbarButton.d.ts

@@ -0,0 +1,14 @@
+import type { JSX } from 'solid-js';
+export declare function ToolbarButton(props: {
+    class?: string;
+    label: string;
+    children?: JSX.Element;
+    onClick?: JSX.EventHandler<HTMLButtonElement, MouseEvent>;
+    disabled?: boolean;
+    pressed?: boolean;
+    expanded?: boolean;
+    menu?: boolean;
+    hasPopup?: boolean;
+    showTooltips?: boolean;
+    isDark?: boolean;
+}): JSX.Element;

package/dist/components/ToolbarIcon.d.ts

@@ -0,0 +1,18 @@
+declare const paths: {
+    copy: string;
+    check: string;
+    source: string;
+    preview: string;
+    collapse: string;
+    expand: string;
+    export: string;
+    open: string;
+    close: string;
+    zoomIn: string;
+    zoomOut: string;
+    reset: string;
+};
+export declare function ToolbarIcon(props: {
+    name: keyof typeof paths;
+}): import("solid-js").JSX.Element;
+export {};

package/dist/components/Tooltip.d.ts

@@ -0,0 +1,13 @@
+import type { JSX } from 'solid-js';
+export interface TooltipProps {
+    visible: boolean;
+    anchorEl: HTMLElement | null;
+    content: string;
+    placement?: 'top' | 'bottom' | 'left' | 'right';
+    offset?: number;
+    originX?: number | null;
+    originY?: number | null;
+    id?: string | null;
+    isDark?: boolean | null;
+}
+export declare function Tooltip(props: TooltipProps): JSX.Element;

package/dist/components/lifecycle.d.ts

@@ -0,0 +1,6 @@
+import type { Accessor } from 'solid-js';
+import type { NodeComponentProps } from '../customComponents';
+import type { MarkstreamNodeLifecycle } from '../types/node-renderer-props';
+export declare const NodeLifecycleContext: import("solid-js").Context<MarkstreamNodeLifecycle | undefined>;
+export declare function useNodeLifecycle(props: Pick<NodeComponentProps, 'indexKey'>, pending: Accessor<boolean>, element: Accessor<HTMLElement | undefined>): void;
+export declare function useMarkstreamNodeLifecycle(): MarkstreamNodeLifecycle | null;

package/dist/components/mathHeightCache.d.ts

@@ -0,0 +1,5 @@
+import type { Accessor } from 'solid-js';
+export declare const MathHeightCacheContext: import("solid-js").Context<{
+    scope: Accessor<string>;
+    cache: Map<string, number>;
+} | undefined>;

package/dist/components/rendererModeDefaults.d.ts

@@ -0,0 +1,4 @@
+import type { NodeRendererMode, NodeRendererProps } from './shared/node-helpers';
+export type RendererModeDefaults = Pick<NodeRendererProps, 'showTooltips' | 'fade' | 'batchRendering' | 'initialRenderBatchSize' | 'renderBatchSize' | 'renderBatchDelay' | 'renderBatchBudgetMs' | 'renderBatchIdleTimeoutMs' | 'deferNodesUntilVisible' | 'maxLiveNodes' | 'liveNodeBuffer' | 'nodeVirtual'>;
+export declare const RENDERER_MODE_DEFAULTS: Record<NodeRendererMode, RendererModeDefaults>;
+export declare function normalizeRendererMode(value: unknown): NodeRendererMode;

package/dist/components/shared/diagram-height.d.ts

@@ -0,0 +1,16 @@
+export declare const MERMAID_PREVIEW_MIN_HEIGHT = 360;
+export declare const MERMAID_PREVIEW_MAX_HEIGHT = 500;
+export declare const INFOGRAPHIC_PREVIEW_MIN_HEIGHT = 360;
+export declare const INFOGRAPHIC_PREVIEW_MAX_HEIGHT = 500;
+export declare function parsePositiveNumber(value: unknown): number | null;
+export declare function getMermaidDiagramKind(code: string): string;
+export declare function estimateMermaidPreviewHeight(code: string): number;
+export declare function estimateInfographicPreviewHeight(code: string): number;
+export declare function clampPreviewHeight(height: number, minHeight?: number, maxHeight?: number | null): number;
+/**
+ * Resolve the diagram preview minimum height from the CSS token
+ * (`--ms-size-diagram-min-height`), falling back to the provided default.
+ * SSR-safe: without a mounted container (Svelte SSR) the token is unreadable,
+ * so the fallback applies instead.
+ */
+export declare function resolveDiagramMinPreviewHeight(container: HTMLElement | null | undefined, fallback: number): number;