@lostgradient/cinder 0.4.0 → 0.5.0

package/dist/server/markdown/pipeline/frontmatter.d.ts

@@ -1,127 +0,0 @@
-/**
- * YAML Front Matter Parsing and Serialization
- *
- * DEP-61: Front matter (YAML) parsing and editing support
- *
- * This module provides functions for parsing and serializing YAML front matter
- * in Markdown documents. Front matter is a YAML block at the start of a document
- * delimited by `---` markers.
- *
- * @module
- */
-import type { FrontMatterParseResult, FrontMatterSerializeOptions } from './types.js';
-/**
- * Parse YAML front matter from a Markdown document.
- *
- * Front matter must be at the very start of the document, delimited by `---`:
- *
- * ```markdown
- * ---
- * title: My Document
- * date: 2025-01-04
- * ---
- *
- * # Content starts here
- * ```
- *
- * @param markdown - The full Markdown document (may or may not contain front matter)
- * @returns Parsed result with data, raw YAML, and body content
- *
- * @example
- * ```ts
- * const result = parseFrontMatter('---\ntitle: Hello\n---\n\n# Content');
- * console.log(result.data);           // { title: 'Hello' }
- * console.log(result.raw);            // 'title: Hello'
- * console.log(result.body);           // '\n# Content'
- * console.log(result.hasFrontMatter); // true
- * ```
- */
-export declare function parseFrontMatter(markdown: string): FrontMatterParseResult;
-/**
- * Parse front matter and return a normalized block view.
- * Includes a preformatted front matter text block (with delimiters) for diffing.
- */
-export interface FrontMatterBlock extends FrontMatterParseResult {
-    /** Front matter block text with delimiters (empty string if none) */
-    text: string;
-}
-export declare function getFrontMatterBlock(markdown: string): FrontMatterBlock;
-/**
- * Serialize front matter and body back to a complete Markdown document.
- *
- * @param data - Front matter data to serialize (null or empty object = no front matter)
- * @param body - Markdown body content
- * @param options - Serialization options
- * @returns Complete Markdown document with front matter (if data is non-empty)
- *
- * @example
- * ```ts
- * // With front matter
- * const doc = stringifyFrontMatter({ title: 'Hello' }, '# Content');
- * // => '---\ntitle: Hello\n---\n\n# Content'
- *
- * // Without front matter
- * const docNoMeta = stringifyFrontMatter(null, '# Content');
- * // => '# Content'
- * ```
- */
-export declare function stringifyFrontMatter(data: Record<string, unknown> | null, body: string, options?: FrontMatterSerializeOptions): string;
-/**
- * Serialize data to YAML with deterministic key ordering.
- * Keys are sorted alphabetically for consistent output.
- *
- * @param data - The data object to serialize
- * @returns The YAML string (without delimiters)
- *
- * @example
- * ```ts
- * const yaml = serializeYaml({ title: 'Hello', tags: ['a', 'b'] });
- * // "tags: [a, b]\ntitle: Hello"
- * ```
- */
-export declare function serializeYaml(data: Record<string, unknown>): string;
-/**
- * Extract front matter and body for separate processing.
- *
- * This is a convenience wrapper around parseFrontMatter that returns
- * a tuple-like result for destructuring.
- *
- * @param markdown - The full Markdown document
- * @returns Tuple of [frontMatterData, frontMatterRaw, body]
- *
- * @example
- * ```ts
- * const [data, raw, body] = extractFrontMatter(markdown);
- * ```
- */
-export declare function extractFrontMatter(markdown: string): [Record<string, unknown> | null, string | null, string];
-/**
- * Check if a Markdown document has front matter.
- *
- * Front matter must be at the very beginning of the document (no leading whitespace)
- * for it to be recognized by `parseFrontMatter()`. This function mirrors that behavior
- * to ensure consistency.
- *
- * @param markdown - The Markdown document to check
- * @returns True if the document starts with `---` front matter delimiters
- */
-export declare function hasFrontMatter(markdown: string): boolean;
-/**
- * Validate YAML front matter syntax.
- *
- * @param raw - Raw YAML string (without delimiters)
- * @returns Object with `valid` boolean and optional `error` message
- */
-export declare function validateFrontMatter(raw: string): {
-    valid: boolean;
-    error?: string;
-};
-/**
- * Merge front matter data with new values.
- * New values override existing ones; undefined removes a key.
- *
- * @param existing - Current front matter data
- * @param updates - Values to merge (undefined = remove key)
- * @returns Merged front matter data
- */
-export declare function mergeFrontMatter(existing: Record<string, unknown> | null, updates: Record<string, unknown>): Record<string, unknown>;

package/dist/server/markdown/pipeline/index.d.ts

@@ -1,37 +0,0 @@
-/**
- * Markdown Pipeline - Public API
- *
- * DEP-35: Markdown dialect + deterministic serialization pipeline
- *
- * This module provides a complete Markdown processing pipeline with:
- * - CommonMark + GFM parsing (tables, task lists, strikethrough)
- * - Deterministic serialization with consistent formatting
- * - AST utilities for comparison and validation
- *
- * @example
- * ```ts
- * import { parse, serialize, roundTrip } from '$lib/document/pipeline';
- *
- * // Parse Markdown to AST
- * const result = parse('# Hello *world*');
- * if (result.success) {
- *   // Serialize AST back to Markdown
- *   const markdown = serialize(result.ast);
- *
- *   // Test round-trip fidelity
- *   const trip = roundTrip('# Hello');
- *   console.log(trip.passes); // true
- * }
- * ```
- *
- * @module
- */
-export { parse, parseOrThrow } from './parser.js';
-export { serialize, serializerOptions } from './serializer.js';
-export { astEquals, clearNormalizeCache, contentEquals, contentEqualsWithFrontMatter, diffAsts, normalize, normalizeWithCache, normalizeWithFrontMatter, roundTrip, roundTripWithFrontMatter, stripPositions, validatePositions, } from './ast.js';
-export type { RoundTripResult, RoundTripWithFrontMatterResult } from './ast.js';
-export type { Blockquote, Break, Code, Content, Delete, Emphasis, Heading, Html, Image, InlineCode, Link, List, ListItem, Paragraph, ParseFailure, ParseOptions, ParseResult, ParseSuccess, Position, Root, SerializeOptions, Strong, Table, TableCell, TableRow, Text, ThematicBreak, } from './types.js';
-export { MarkdownParseError, PositionValidationError } from './errors.js';
-export { extractFrontMatter, getFrontMatterBlock, hasFrontMatter, mergeFrontMatter, parseFrontMatter, serializeYaml, stringifyFrontMatter, validateFrontMatter, } from './frontmatter.js';
-export type { DocumentWithFrontMatter, FrontMatterParseResult, FrontMatterSerializeOptions, } from './types.js';
-export type { FrontMatterBlock } from './frontmatter.js';

package/dist/server/markdown/pipeline/parser.d.ts

@@ -1,65 +0,0 @@
-/**
- * Markdown parser with GFM support.
- *
- * DEP-35: Markdown dialect + deterministic serialization pipeline
- *
- * This module provides parsing functions that convert Markdown strings
- * to mdast AST. The parser supports CommonMark + GFM (tables, task lists,
- * strikethrough).
- *
- * @module
- */
-import type { Root } from 'mdast';
-import type { ParseOptions, ParseResult } from './types.js';
-/**
- * Parse a Markdown string to an mdast AST.
- *
- * Returns a discriminated union for explicit error handling.
- * Use pattern matching to handle success/failure cases.
- *
- * Note: remark-parse is very lenient and rarely fails. Most malformed
- * Markdown is parsed as paragraph text rather than causing errors.
- *
- * @param markdown - The Markdown string to parse
- * @param options - Parse options
- * @returns A discriminated union with `success: true` and `ast`, or `success: false` and `error`
- *
- * @example
- * ```ts
- * import { parse } from '$lib/document/pipeline';
- *
- * const result = parse('# Hello\n\nWorld');
- * if (result.success) {
- *   console.log(result.ast.children.length); // 2
- * } else {
- *   console.error(result.error.message);
- * }
- * ```
- */
-export declare function parse(markdown: string, options?: ParseOptions): ParseResult;
-/**
- * Parse a Markdown string to an mdast AST, throwing on failure.
- *
- * Use this when you expect valid input and prefer exceptions over
- * explicit error handling.
- *
- * @param markdown - The Markdown string to parse
- * @param options - Parse options
- * @returns The parsed mdast AST
- * @throws {MarkdownParseError} If parsing fails
- *
- * @example
- * ```ts
- * import { parseOrThrow } from '$lib/document/pipeline';
- *
- * try {
- *   const ast = parseOrThrow('# Hello');
- *   console.log(ast.children[0].type); // 'heading'
- * } catch (err) {
- *   if (err instanceof MarkdownParseError) {
- *     console.error('Parse failed:', err.message);
- *   }
- * }
- * ```
- */
-export declare function parseOrThrow(markdown: string, options?: ParseOptions): Root;

package/dist/server/markdown/pipeline/serializer.d.ts

@@ -1,67 +0,0 @@
-/**
- * Deterministic Markdown serializer.
- *
- * DEP-35: Markdown dialect + deterministic serialization pipeline
- *
- * This module provides a serialization function that converts mdast AST
- * back to Markdown strings with deterministic output. The same AST will
- * always produce the same Markdown string.
- *
- * @module
- */
-import type { Root } from 'mdast';
-/**
- * Deterministic serialization options.
- *
- * These are LOCKED to ensure consistent output across all serializations.
- * Changing these would break semantic equivalence guarantees.
- *
- * All variations (e.g., `*` vs `_` for emphasis) are semantically equivalent
- * in Markdown, but we pick one style to ensure `serialize(parse(a))` always
- * produces the same output for equivalent inputs.
- */
-export declare const serializerOptions: {
-    /** Use `-` for unordered list bullets (not `*` or `+`) */
-    readonly bullet: "-";
-    /** Use `*` for emphasis (not `_`) */
-    readonly emphasis: "*";
-    /** Use backticks for code fences (not `~`) */
-    readonly fence: "`";
-    /** Always use fenced code blocks (never indented) */
-    readonly fences: true;
-    /** Always use ATX headings `# H1` (never setext `===`) */
-    readonly setext: false;
-    /** Single space after bullet in list items */
-    readonly listItemIndent: "one";
-    /** Use `-` for horizontal rules */
-    readonly rule: "-";
-    /** Use `*` for strong (not `_`) */
-    readonly strong: "*";
-    /** No blank lines in definition lists */
-    readonly tightDefinitions: true;
-};
-/**
- * Serialize an mdast AST to a Markdown string.
- *
- * This function produces deterministic output: the same AST will always
- * produce the same Markdown string. This is essential for:
- * - Diff computation (DEP-42): comparing serialized output
- * - Round-trip testing: `parse(serialize(ast))` should equal `ast`
- *
- * @param ast - The mdast AST to serialize
- * @returns The serialized Markdown string
- *
- * @example
- * ```ts
- * import { serialize } from '$lib/document/pipeline';
- *
- * const markdown = serialize({
- *   type: 'root',
- *   children: [
- *     { type: 'paragraph', children: [{ type: 'text', value: 'Hello' }] }
- *   ]
- * });
- * // => 'Hello\n'
- * ```
- */
-export declare function serialize(ast: Root): string;

package/dist/server/markdown/pipeline/strip-positions.d.ts

@@ -1,20 +0,0 @@
-/**
- * AST position stripping utility.
- *
- * Extracted to a separate module to avoid circular dependency
- * between ast.ts and parser.ts.
- *
- * @module
- */
-import type { Root } from 'mdast';
-/**
- * Remove position data from an AST for comparison purposes.
- *
- * Creates a deep clone of the AST with all `position` properties removed.
- * This is used for AST comparison (ignoring source positions) and when
- * parsing with `positions: false`.
- *
- * @param ast - The AST to strip positions from
- * @returns A new AST with positions removed
- */
-export declare function stripPositions(ast: Root): Root;

package/dist/server/markdown/pipeline/types.d.ts

@@ -1,116 +0,0 @@
-/**
- * Type definitions for the Markdown pipeline.
- *
- * DEP-35: Markdown dialect + deterministic serialization pipeline
- *
- * @module
- */
-import type { Content, Root } from 'mdast';
-import type { Position } from 'unist';
-import type { MarkdownParseError } from './errors.js';
-export type { Content, Position, Root };
-export type { Blockquote, Break, Code, Delete, Emphasis, Heading, Html, Image, InlineCode, Link, List, ListItem, Paragraph, Strong, Table, TableCell, TableRow, Text, ThematicBreak, } from 'mdast';
-/**
- * Options for parsing Markdown to AST.
- */
-export interface ParseOptions {
-    /**
-     * Whether to preserve source positions in the AST.
-     * Required for comment anchoring (DEP-39) and diff computation (DEP-42).
-     * @default true
-     */
-    positions?: boolean;
-}
-/**
- * Successful parse result.
- */
-export interface ParseSuccess {
-    success: true;
-    ast: Root;
-}
-/**
- * Failed parse result.
- */
-export interface ParseFailure {
-    success: false;
-    error: MarkdownParseError;
-}
-/**
- * Discriminated union for parse results.
- * Use pattern matching to handle success/failure:
- *
- * @example
- * ```ts
- * const result = parse(markdown);
- * if (result.success) {
- *   console.log(result.ast);
- * } else {
- *   console.error(result.error.message);
- * }
- * ```
- */
-export type ParseResult = ParseSuccess | ParseFailure;
-/**
- * Options for serializing AST to Markdown.
- * Most options are locked for deterministic output.
- *
- * Currently no user-configurable options - all serialization
- * options are locked for determinism.
- */
-export type SerializeOptions = Record<string, never>;
-export type { MarkdownParseError };
-/**
- * Result of parsing front matter from a Markdown document.
- * DEP-61: Front matter (YAML) parsing and editing support
- */
-export interface FrontMatterParseResult {
-    /** Parsed front matter data (null if no front matter present) */
-    data: Record<string, unknown> | null;
-    /** Raw YAML string (null if no front matter present) */
-    raw: string | null;
-    /** Document body (Markdown content after front matter) */
-    body: string;
-    /** Whether front matter was present in the document */
-    hasFrontMatter: boolean;
-}
-/**
- * Options for serializing front matter.
- * DEP-61: Front matter (YAML) parsing and editing support
- */
-export interface FrontMatterSerializeOptions {
-    /**
-     * Whether to preserve the original raw YAML string when no edits were made.
-     * When false, always regenerates YAML from data using deterministic ordering.
-     * @default true
-     */
-    preserveRaw?: boolean;
-    /**
-     * Original raw YAML to preserve when preserveRaw is true and data is unchanged.
-     * If provided and data hasn't changed, this exact string is used.
-     */
-    originalRaw?: string | null;
-    /**
-     * Original parsed data to compare against for detecting changes.
-     * Only used when preserveRaw is true and originalRaw is provided.
-     */
-    originalData?: Record<string, unknown> | null;
-    /**
-     * Whether to preserve empty front matter block (`---\n---\n`) when data is null/empty.
-     * When true and data is null/empty, outputs `---\n---\n{body}` instead of just body.
-     * This is useful when editing a document that originally had empty front matter.
-     * @default false
-     */
-    preserveEmptyFrontMatter?: boolean;
-}
-/**
- * Complete document with front matter and body separated.
- * DEP-61: Front matter (YAML) parsing and editing support
- */
-export interface DocumentWithFrontMatter {
-    /** Parsed front matter data (null if no front matter present) */
-    frontMatter: Record<string, unknown> | null;
-    /** Raw YAML string (null if no front matter present) */
-    frontMatterRaw: string | null;
-    /** Document body (Markdown content after front matter) */
-    body: string;
-}

package/dist/server/markdown/rendering/extract-code-blocks.d.ts

@@ -1,16 +0,0 @@
-/**
- * Code block metadata extraction from mdast.
- *
- * DEP-49: Extract code block info for copy hooks in chat messages.
- *
- * @module
- */
-import type { Root } from 'mdast';
-import type { CodeBlockInfo } from './types.js';
-/**
- * Extract metadata from all code blocks in the AST.
- *
- * @param root - mdast Root node
- * @returns Array of code block metadata in document order
- */
-export declare function extractCodeBlocks(root: Root): CodeBlockInfo[];

package/dist/server/markdown/rendering/highlighter.d.ts

@@ -1,109 +0,0 @@
-/**
- * Syntax highlighting configuration for the markdown rendering pipeline.
- *
- * This module provides a Shiki highlighter configured with:
- * - CSS variable theme that maps to design system tokens
- * - Common languages for software development content
- * - Singleton pattern to avoid repeated initialization
- *
- * The CSS variable approach enables instant light/dark theme switching
- * without re-highlighting, since colors are resolved at render time.
- *
- * Why this file uses `shiki/core` + per-language dynamic imports rather
- * than `import { createHighlighter } from 'shiki'`: the default `shiki`
- * entry resolves to `bundle-full.mjs`, which statically references all
- * 253 bundled grammars. Even with `langs: BUNDLED_LANGUAGES` (12 langs)
- * passed at runtime, the bundler can't see the runtime filter and ships
- * every grammar (~10 MB). Switching to `shiki/core` and importing each
- * grammar individually as a dynamic import keeps the bundle to only the
- * languages we actually use.
- *
- * @module
- */
-import type { HighlighterCore, ThemeRegistration } from '@shikijs/types';
-/**
- * Special language value for plain text (no highlighting).
- * Shiki doesn't have a built-in 'plaintext' language, so we handle it
- * separately from the bundled languages.
- */
-export declare const PLAINTEXT_LANGUAGE: "plaintext";
-export type PlaintextLanguage = typeof PLAINTEXT_LANGUAGE;
-/**
- * Bundled languages loaded into the highlighter.
- *
- * These are real Shiki grammars and will be highlighted at render time.
- * To add a language: add it to this array AND add a corresponding loader
- * to `LANGUAGE_LOADERS` below. The exhaustive `Record` type forces both
- * to stay in sync — the file won't compile if a language is missing a
- * loader.
- */
-export declare const BUNDLED_LANGUAGES: readonly ["typescript", "javascript", "python", "sql", "bash", "json", "yaml", "markdown", "svelte", "css", "html", "diff"];
-export type BundledLanguage = (typeof BUNDLED_LANGUAGES)[number];
-/** Re-export under the original name for backward compat with existing call sites. */
-export type SupportedLanguage = BundledLanguage | PlaintextLanguage;
-/**
- * All supported languages including plaintext.
- *
- * This list covers the most common languages in software documentation
- * and chat contexts. Additional languages can be loaded dynamically via
- * `highlighter.loadLanguage()` if needed.
- */
-export declare const SUPPORTED_LANGUAGES: readonly SupportedLanguage[];
-/**
- * CSS variable theme for syntax highlighting.
- *
- * Maps TextMate scopes to CSS custom properties defined in tokens.css.
- * Using CSS variables enables instant theme switching without re-highlighting,
- * since the browser resolves `var()` references at render time based on
- * the current `color-scheme` or `data-theme` attribute.
- *
- * The theme type is set to 'dark' but this is arbitrary since actual colors
- * come from CSS variables that adapt to light/dark mode automatically.
- */
-export declare const CSS_VARIABLE_THEME: ThemeRegistration;
-/**
- * Get the shared Shiki highlighter instance (async).
- *
- * Creates the highlighter on first call and returns the cached instance
- * for subsequent calls. The highlighter is configured with our CSS variable
- * theme and supported languages.
- *
- * @returns Promise resolving to the configured Shiki highlighter
- */
-export declare function getHighlighter(): Promise<HighlighterCore>;
-/**
- * Get the highlighter instance synchronously.
- *
- * Returns the cached highlighter if it has been initialized, or null if not.
- * Use this when you need synchronous access and can handle the case where
- * the highlighter isn't ready yet.
- *
- * @returns The highlighter instance, or null if not yet initialized
- */
-export declare function getHighlighterSync(): HighlighterCore | null;
-/**
- * Initialize the highlighter and return it.
- *
- * Convenience wrapper around `getHighlighter()`. Call at app startup to
- * ensure synchronous access is available.
- *
- * @returns Promise resolving to the configured Shiki highlighter
- */
-export declare function initializeHighlighter(): Promise<HighlighterCore>;
-/**
- * Check if a language is a bundled Shiki language (not plaintext).
- */
-export declare function isBundledLanguage(language: string): language is BundledLanguage;
-/**
- * Check if a language is supported (bundled or plaintext).
- */
-export declare function isLanguageSupported(language: string): language is SupportedLanguage;
-/**
- * Reset the highlighter instance.
- *
- * Primarily useful for testing. Clears the singleton so the next
- * `getHighlighter()` call creates a fresh instance.
- */
-export declare function resetHighlighter(): void;
-/** Re-exported for tests and consumers of the public type. */
-export type { HighlighterCore as Highlighter, ThemeRegistration } from '@shikijs/types';

package/dist/server/markdown/rendering/index.d.ts

@@ -1,41 +0,0 @@
-/**
- * Markdown Rendering Pipeline - Public API
- *
- * DEP-49: Chat markdown rendering pipeline + sanitization.
- *
- * This module provides a lightweight, SSR-safe markdown-to-HTML rendering
- * pipeline for chat messages. It reuses the existing CommonMark + GFM
- * parsing from the document pipeline while adding sanitization and code
- * block metadata extraction.
- *
- * @example
- * ```ts
- * import { renderMarkdown } from '$lib/document/rendering';
- *
- * const result = renderMarkdown('# Hello\n\n```typescript\nconst x = 1;\n```');
- *
- * // Sanitized HTML for rendering
- * console.log(result.html);
- *
- * // Code blocks for copy hooks
- * console.log(result.codeBlocks[0].language); // 'typescript'
- * console.log(result.codeBlocks[0].value);    // 'const x = 1;'
- *
- * // Original markdown for copy/export
- * console.log(result.rawMarkdown);
- *
- * // Safety flag
- * console.log(result.hadUnsafeContent); // false
- * ```
- *
- * @module
- */
-export { clearRenderCache, probablyHasMath, renderMarkdown, renderMarkdownWithMath, } from './render.js';
-export type { CodeBlockInfo, RenderOptions, RenderResult } from './types.js';
-export { findSafeRenderBoundary, splitStreamingContent } from './render-streaming.js';
-export { extractCodeBlocks } from './extract-code-blocks.js';
-export { createSanitizeSchema, sanitizeSchema } from './sanitize-schema.js';
-export { transformUrls, type TransformUrlsResult } from './transform-urls.js';
-export { BUNDLED_LANGUAGES, PLAINTEXT_LANGUAGE, SUPPORTED_LANGUAGES, getHighlighter, getHighlighterSync, initializeHighlighter, isBundledLanguage, isLanguageSupported, type SupportedLanguage, } from './highlighter.js';
-export { initializeWorkerHighlighter, renderMarkdownAsync, terminateMarkdownWorker, } from './render-async.js';
-export { clearMermaidCache, getCacheKey as getMermaidCacheKey, getMermaidCacheSize, getCachedSvg as getMermaidCachedSvg, setCachedSvg as setMermaidCachedSvg, } from './mermaid-cache.js';

package/dist/server/markdown/rendering/mermaid-cache.d.ts

@@ -1,55 +0,0 @@
-/**
- * LRU cache for rendered Mermaid SVGs.
- *
- * DEP-95: Mermaid diagram support for MarkdownPreview.
- *
- * Separate from the HTML render cache because:
- * - Different invalidation patterns (theme changes require re-render)
- * - Theme-aware keys: `${theme}:${hash(code)}`
- * - Different size constraints (SVGs can be larger)
- *
- * Also provides a render mutex to serialize Mermaid operations, since
- * Mermaid is a singleton and concurrent renders can corrupt state.
- *
- * @module
- */
-/**
- * Execute a function with exclusive access to Mermaid.
- *
- * Serializes access to prevent concurrent renders from corrupting
- * Mermaid's internal state (theme config, DOM manipulation, etc.).
- *
- * @param fn - Async function that uses Mermaid
- * @returns Result of the function
- */
-export declare function withMermaidLock<T>(fn: () => Promise<T>): Promise<T>;
-/**
- * Generate a cache key from mermaid code and theme.
- *
- * @param code - Mermaid diagram source code
- * @param theme - Current theme ('default', 'dark', etc.)
- */
-export declare function getCacheKey(code: string, theme: string): string;
-/**
- * Get a cached SVG if available.
- *
- * @param key - Cache key from getCacheKey()
- * @returns Cached SVG string or undefined
- */
-export declare function getCachedSvg(key: string): string | undefined;
-/**
- * Store an SVG in the cache.
- *
- * @param key - Cache key from getCacheKey()
- * @param svg - Rendered SVG string
- */
-export declare function setCachedSvg(key: string, svg: string): void;
-/**
- * Clear all cached SVGs.
- * Useful when theme changes globally or for testing.
- */
-export declare function clearMermaidCache(): void;
-/**
- * Get current cache size (for testing/debugging).
- */
-export declare function getMermaidCacheSize(): number;