rag-lite-ts 2.1.1 → 2.2.0

package/dist/esm/text/embedder.js

@@ -0,0 +1,386 @@
+import '../dom-polyfills.js';
+import { createHash } from 'crypto';
+import { config } from '../core/config.js';
+import { handleError, ErrorCategory, ErrorSeverity, safeExecute } from '../core/error-handler.js';
+import { createModelLoadingError, createInvalidContentError, createMissingDependencyError } from '../core/actionable-error-messages.js';
+/**
+ * List of supported embedding models
+ */
+const SUPPORTED_MODELS = [
+    'sentence-transformers/all-MiniLM-L6-v2',
+    'Xenova/all-mpnet-base-v2'
+];
+/**
+ * Embedding engine using transformers.js for generating embeddings
+ */
+export class EmbeddingEngine {
+    model = null;
+    modelVersion = null;
+    modelName;
+    batchSize;
+    constructor(modelName, batchSize) {
+        this.modelName = modelName || config.embedding_model;
+        this.batchSize = batchSize || config.batch_size;
+        // Validate that the model is supported
+        if (!SUPPORTED_MODELS.includes(this.modelName)) {
+            throw createModelLoadingError(this.modelName, `Model not in supported list. Supported models: ${SUPPORTED_MODELS.join(', ')}`, { operationContext: 'EmbeddingEngine constructor' });
+        }
+        console.log(`🤖 EmbeddingEngine initialized with model: ${this.modelName}, batchSize: ${this.batchSize}`);
+    }
+    /**
+     * Load the embedding model
+     * @throws {Error} If model loading fails
+     */
+    async loadModel() {
+        await safeExecute(async () => {
+            console.log(`Loading embedding model: ${this.modelName}`);
+            // Ensure DOM polyfills are set up before importing transformers
+            if (typeof globalThis.self === 'undefined') {
+                globalThis.self = globalThis;
+            }
+            if (typeof global.self === 'undefined') {
+                global.self = global;
+            }
+            // Additional polyfills that might be needed
+            if (typeof globalThis.window === 'undefined') {
+                globalThis.window = {};
+            }
+            if (typeof globalThis.document === 'undefined') {
+                globalThis.document = {};
+            }
+            console.log('Embedder polyfills set up. self is now:', typeof self !== 'undefined' ? 'defined' : 'undefined');
+            // Initialize the feature extraction pipeline using dynamic import
+            // Let transformers.js handle model caching automatically
+            try {
+                const { pipeline } = await import('@huggingface/transformers');
+                this.model = await pipeline('feature-extraction', this.modelName, {
+                    cache_dir: config.model_cache_path,
+                    local_files_only: false,
+                    dtype: 'fp32' // Explicitly specify dtype to suppress warning
+                });
+            }
+            catch (error) {
+                // Enhanced error handling for model download failures
+                if (error instanceof Error && (error.message.includes('network') ||
+                    error.message.includes('download') ||
+                    error.message.includes('fetch') ||
+                    error.message.includes('ENOTFOUND') ||
+                    error.message.includes('ECONNREFUSED') ||
+                    error.message.includes('timeout'))) {
+                    throw new Error(`Failed to download model '${this.modelName}'. ` +
+                        `Check your internet connection or see models/README.md for offline setup instructions.`);
+                }
+                throw error;
+            }
+            // Generate model version hash
+            this.modelVersion = this.generateModelVersion();
+            console.log(`Model loaded successfully. Version: ${this.modelVersion}`);
+        }, 'Model Loading', {
+            category: ErrorCategory.MODEL,
+            severity: ErrorSeverity.FATAL,
+            exitCode: 6
+        });
+    }
+    /**
+     * Generate embeddings for a batch of texts
+     * @param texts - Array of text strings to embed
+     * @returns Promise resolving to array of embedding results
+     */
+    async embedBatch(texts) {
+        if (!this.model) {
+            throw createMissingDependencyError('model', 'object', {
+                operationContext: 'embedBatch',
+                includeTroubleshooting: true
+            });
+        }
+        if (texts.length === 0) {
+            return [];
+        }
+        // Split into smaller batches based on configured batch size
+        const results = [];
+        for (let i = 0; i < texts.length; i += this.batchSize) {
+            const batch = texts.slice(i, i + this.batchSize);
+            const batchResults = await this.processBatchWithErrorHandling(batch, i);
+            results.push(...batchResults);
+        }
+        return results;
+    }
+    /**
+     * Process a single batch with error handling for individual chunks
+     * @param batch - Array of text strings in this batch
+     * @param startIndex - Starting index for this batch in the original array
+     * @returns Promise resolving to array of embedding results
+     */
+    async processBatchWithErrorHandling(batch, startIndex) {
+        return await safeExecute(async () => {
+            // Try to process the entire batch first
+            const embeddings = await this.model(batch, {
+                pooling: 'mean',
+                normalize: true
+            });
+            // Convert to EmbeddingResult format
+            const results = [];
+            const embeddingData = embeddings.tolist();
+            for (let i = 0; i < batch.length; i++) {
+                const embedding_id = this.generateEmbeddingId(batch[i], startIndex + i);
+                const vector = new Float32Array(embeddingData[i]);
+                results.push({
+                    embedding_id,
+                    vector,
+                    contentType: 'text'
+                });
+            }
+            return results;
+        }, `Batch Embedding (${batch.length} chunks)`, {
+            category: ErrorCategory.EMBEDDING,
+            severity: ErrorSeverity.ERROR,
+            skipError: true,
+            fallbackValue: []
+        }) || await this.fallbackToIndividualProcessing(batch, startIndex);
+    }
+    /**
+     * Fallback to individual chunk processing when batch fails
+     */
+    async fallbackToIndividualProcessing(batch, startIndex) {
+        handleError(`Batch processing failed for ${batch.length} chunks, falling back to individual processing`, 'Embedding Batch Processing', {
+            category: ErrorCategory.EMBEDDING,
+            severity: ErrorSeverity.WARNING,
+            skipError: true
+        });
+        const results = [];
+        for (let i = 0; i < batch.length; i++) {
+            const singleResult = await safeExecute(() => this.processSingleChunk(batch[i], startIndex + i), `Individual Chunk Embedding (${startIndex + i})`, {
+                category: ErrorCategory.EMBEDDING,
+                severity: ErrorSeverity.WARNING,
+                skipError: true
+            });
+            if (singleResult) {
+                results.push(singleResult);
+            }
+        }
+        return results;
+    }
+    /**
+     * Process a single chunk with error handling
+     * @param text - Text to embed
+     * @param index - Index of this chunk
+     * @returns Promise resolving to embedding result or null if failed
+     */
+    async processSingleChunk(text, index) {
+        try {
+            const embeddings = await this.model([text], {
+                pooling: 'mean',
+                normalize: true
+            });
+            const embeddingData = embeddings.tolist();
+            const embedding_id = this.generateEmbeddingId(text, index);
+            const vector = new Float32Array(embeddingData[0]);
+            return {
+                embedding_id,
+                vector,
+                contentType: 'text'
+            };
+        }
+        catch (error) {
+            // Return null to indicate failure
+            throw error;
+        }
+    }
+    /**
+     * Generate embedding for a single text
+     * @param text - Text string to embed
+     * @returns Promise resolving to embedding result
+     */
+    async embedSingle(text) {
+        const results = await this.embedBatch([text]);
+        if (results.length === 0) {
+            throw createInvalidContentError('text', 'empty', {
+                operationContext: 'embedText'
+            });
+        }
+        return results[0];
+    }
+    /**
+     * Generate embeddings for document chunks with progress logging
+     * Optimized for large document ingestion with batch processing
+     * @param chunks - Array of text chunks from documents
+     * @returns Promise resolving to array of embedding results
+     */
+    async embedDocumentBatch(chunks) {
+        if (!this.model) {
+            throw new Error('Model not loaded. Call loadModel() first.');
+        }
+        if (chunks.length === 0) {
+            return [];
+        }
+        console.log(`Processing ${chunks.length} chunk${chunks.length === 1 ? '' : 's'} in batches of ${this.batchSize}...`);
+        const results = [];
+        const totalBatches = Math.ceil(chunks.length / this.batchSize);
+        let processedChunks = 0;
+        let skippedChunks = 0;
+        for (let batchIndex = 0; batchIndex < totalBatches; batchIndex++) {
+            const startIdx = batchIndex * this.batchSize;
+            const endIdx = Math.min(startIdx + this.batchSize, chunks.length);
+            const batch = chunks.slice(startIdx, endIdx);
+            try {
+                const batchResults = await this.processBatchWithErrorHandling(batch, startIdx);
+                results.push(...batchResults);
+                processedChunks += batchResults.length;
+                skippedChunks += (batch.length - batchResults.length);
+                // Progress logging - more frequent updates for better user experience
+                const progressInterval = Math.max(1, Math.floor(totalBatches / 20)); // Show progress every 5%
+                if ((batchIndex + 1) % progressInterval === 0 || batchIndex === totalBatches - 1) {
+                    const percentage = Math.round(((batchIndex + 1) / totalBatches) * 100);
+                    console.log(`Processed ${processedChunks} of ${chunks.length} chunks (${percentage}%)${skippedChunks > 0 ? ` - ${skippedChunks} skipped` : ''}`);
+                }
+            }
+            catch (error) {
+                console.error(`Failed to process batch ${batchIndex + 1}/${totalBatches}:`, error instanceof Error ? error.message : String(error));
+                skippedChunks += batch.length;
+            }
+        }
+        if (skippedChunks > 0) {
+            console.log(`✓ Embedding complete: ${processedChunks} successful, ${skippedChunks} skipped due to errors`);
+        }
+        else {
+            console.log(`✓ Embedding complete: ${processedChunks} chunks processed successfully`);
+        }
+        return results;
+    }
+    /**
+     * Get the current model version identifier
+     * @returns Model version string
+     */
+    getModelVersion() {
+        if (!this.modelVersion) {
+            throw new Error('Model not loaded. Call loadModel() first.');
+        }
+        return this.modelVersion;
+    }
+    /**
+     * Check if the model is loaded
+     * @returns True if model is loaded
+     */
+    isLoaded() {
+        return this.model !== null;
+    }
+    /**
+     * Get the model name
+     * @returns Model name string
+     */
+    getModelName() {
+        return this.modelName;
+    }
+    /**
+     * Get the batch size
+     * @returns Batch size number
+     */
+    getBatchSize() {
+        return this.batchSize;
+    }
+    /**
+     * Generate a deterministic model version identifier
+     * Uses model name and configuration for consistent versioning
+     * @returns Model version string
+     */
+    generateModelVersion() {
+        // Create a deterministic hash based on model name and configuration
+        // This ensures the same model configuration always produces the same version
+        const configData = JSON.stringify({
+            model: this.modelName,
+            // Add other relevant config that affects embeddings
+            quantized: false,
+            revision: 'main'
+        });
+        const hash = createHash('sha256').update(configData).digest('hex').substring(0, 16);
+        return `${this.modelName.replace('/', '_')}_${hash}`;
+    }
+    /**
+     * Generate a deterministic embedding ID for a text chunk
+     * @param text - The text content
+     * @param index - Index in the batch
+     * @returns Deterministic embedding ID
+     */
+    generateEmbeddingId(text, index) {
+        // Create deterministic ID based on content hash only
+        // This ensures the same text always gets the same ID regardless of processing order
+        const contentHash = createHash('sha256').update(text.trim()).digest('hex');
+        return contentHash.substring(0, 32);
+    }
+}
+/**
+ * Singleton instance for the embedding engine
+ * Ensures model is loaded only once across the application
+ */
+let embeddingEngineInstance = null;
+/**
+ * Get the singleton embedding engine instance
+ * @param modelName - Optional model name override
+ * @param batchSize - Optional batch size override
+ * @returns EmbeddingEngine instance
+ */
+export function getEmbeddingEngine(modelName, batchSize) {
+    // Always create a new instance if specific parameters are provided
+    // This ensures we don't use cached instances with wrong configuration
+    if (modelName || batchSize) {
+        embeddingEngineInstance = new EmbeddingEngine(modelName, batchSize);
+    }
+    else if (!embeddingEngineInstance) {
+        embeddingEngineInstance = new EmbeddingEngine();
+    }
+    return embeddingEngineInstance;
+}
+/**
+ * Initialize the embedding engine and load the model
+ * @param modelName - Optional model name override
+ * @param batchSize - Optional batch size override
+ * @returns Promise resolving to the loaded embedding engine
+ */
+export async function initializeEmbeddingEngine(modelName, batchSize) {
+    const engine = getEmbeddingEngine(modelName, batchSize);
+    if (!engine.isLoaded()) {
+        await engine.loadModel();
+    }
+    return engine;
+}
+/**
+ 
+* Create an EmbedFunction implementation using the text embedding engine
+ * This function implements the core EmbedFunction interface for dependency injection
+ * @param modelName - Optional model name override
+ * @param batchSize - Optional batch size override
+ * @returns EmbedFunction that can be injected into core components
+ */
+export function createTextEmbedFunction(modelName, batchSize) {
+    let engine = null;
+    const embedFunction = async (query, contentType) => {
+        // Only support text content type
+        if (contentType && contentType !== 'text') {
+            throw new Error(`Text embedder only supports 'text' content type, got: ${contentType}`);
+        }
+        // Initialize engine if not already done
+        if (!engine) {
+            engine = await initializeEmbeddingEngine(modelName, batchSize);
+        }
+        // Use the existing embedSingle method
+        const result = await engine.embedSingle(query);
+        // Ensure contentType is present (should already be included from embedSingle)
+        return {
+            ...result,
+            contentType: result.contentType || 'text'
+        };
+    };
+    return embedFunction;
+}
+// =============================================================================
+// REMOVED: createTextEmbedder() factory object
+// =============================================================================
+// The createTextEmbedder() function has been removed as it was redundant.
+// It was just a wrapper around initializeEmbeddingEngine() that provided no
+// additional value over using the engine directly or using createEmbedder().
+//
+// Migration guide:
+// - For public API: Use createEmbedder() from core/embedder-factory.ts
+// - For dependency injection: Use createTextEmbedFunction()
+// - For direct access: Use initializeEmbeddingEngine() or new EmbeddingEngine()
+//# sourceMappingURL=embedder.js.map

package/dist/esm/text/index.d.ts

@@ -0,0 +1,8 @@
+export { EmbeddingEngine, getEmbeddingEngine, initializeEmbeddingEngine, createTextEmbedFunction } from './embedder.js';
+export { CrossEncoderReranker, createTextRerankFunction } from './reranker.js';
+export { countTokens, getTokenizer, resetTokenizer } from './tokenizer.js';
+export { chunkDocument, type Chunk, type Document } from '../core/chunker.js';
+export { type ChunkConfig } from '../core/chunker.js';
+export { SentenceTransformerEmbedder } from './sentence-transformer-embedder.js';
+export * from './preprocessors/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/text/index.js

@@ -0,0 +1,9 @@
+// Text implementation layer exports
+export { EmbeddingEngine, getEmbeddingEngine, initializeEmbeddingEngine, createTextEmbedFunction } from './embedder.js';
+export { CrossEncoderReranker, createTextRerankFunction } from './reranker.js';
+export { countTokens, getTokenizer, resetTokenizer } from './tokenizer.js';
+export { chunkDocument } from '../core/chunker.js';
+export { SentenceTransformerEmbedder } from './sentence-transformer-embedder.js';
+// Re-export preprocessors
+export * from './preprocessors/index.js';
+//# sourceMappingURL=index.js.map

package/dist/esm/text/preprocessors/index.d.ts

@@ -0,0 +1,17 @@
+import { PreprocessorRegistry } from './registry.js';
+export { PreprocessorRegistry, ContentTypeDetector } from './registry.js';
+export { MdxPreprocessor } from './mdx.js';
+export { MermaidPreprocessor } from './mermaid.js';
+/**
+ * Global preprocessor registry instance
+ */
+export declare const preprocessorRegistry: PreprocessorRegistry;
+/**
+ * Validate that all required preprocessors are available in the registry
+ */
+export declare function validatePreprocessorConfiguration(requiredPreprocessors: string[]): void;
+/**
+ * Get all available preprocessor names
+ */
+export declare function getAvailablePreprocessors(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/text/preprocessors/index.js

@@ -0,0 +1,38 @@
+import { PreprocessorRegistry } from './registry.js';
+import { MdxPreprocessor } from './mdx.js';
+import { MermaidPreprocessor } from './mermaid.js';
+// Export all preprocessor classes
+export { PreprocessorRegistry, ContentTypeDetector } from './registry.js';
+export { MdxPreprocessor } from './mdx.js';
+export { MermaidPreprocessor } from './mermaid.js';
+/**
+ * Create and initialize the global preprocessor registry
+ */
+function createPreprocessorRegistry() {
+    const registry = new PreprocessorRegistry();
+    // Register built-in preprocessors
+    registry.register('mdx', new MdxPreprocessor());
+    registry.register('mermaid', new MermaidPreprocessor());
+    return registry;
+}
+/**
+ * Global preprocessor registry instance
+ */
+export const preprocessorRegistry = createPreprocessorRegistry();
+/**
+ * Validate that all required preprocessors are available in the registry
+ */
+export function validatePreprocessorConfiguration(requiredPreprocessors) {
+    const validation = preprocessorRegistry.validatePreprocessors(requiredPreprocessors);
+    if (!validation.valid) {
+        const missingList = validation.missing.join(', ');
+        throw new Error(`Missing required preprocessors: ${missingList}. Available: ${preprocessorRegistry.getRegisteredNames().join(', ')}`);
+    }
+}
+/**
+ * Get all available preprocessor names
+ */
+export function getAvailablePreprocessors() {
+    return preprocessorRegistry.getRegisteredNames();
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/text/preprocessors/mdx.d.ts

@@ -0,0 +1,25 @@
+import { Preprocessor, PreprocessorOptions } from '../../types.js';
+/**
+ * MDX preprocessor for handling JSX content in Markdown files
+ * Ports the existing cleanMdxContent logic with mode-aware behavior
+ */
+export declare class MdxPreprocessor implements Preprocessor {
+    /**
+     * Check if this preprocessor applies to the given language/content type
+     * Applies to .mdx files and content with JSX syntax
+     */
+    appliesTo(language: string): boolean;
+    /**
+     * Process MDX content based on the specified mode
+     */
+    process(content: string, options: PreprocessorOptions): string;
+    /**
+     * Strip JSX content entirely - ported from cleanMdxContent logic
+     */
+    private stripJsx;
+    /**
+     * Replace JSX with descriptive placeholders
+     */
+    private replaceWithPlaceholders;
+}
+//# sourceMappingURL=mdx.d.ts.map

package/dist/esm/text/preprocessors/mdx.js

@@ -0,0 +1,101 @@
+import { ContentTypeDetector } from './registry.js';
+/**
+ * MDX preprocessor for handling JSX content in Markdown files
+ * Ports the existing cleanMdxContent logic with mode-aware behavior
+ */
+export class MdxPreprocessor {
+    /**
+     * Check if this preprocessor applies to the given language/content type
+     * Applies to .mdx files and content with JSX syntax
+     */
+    appliesTo(language) {
+        return language === 'mdx';
+    }
+    /**
+     * Process MDX content based on the specified mode
+     */
+    process(content, options) {
+        // Only process if content actually contains JSX
+        if (!ContentTypeDetector.hasJsxContent(content)) {
+            return content;
+        }
+        switch (options.mode) {
+            case 'strip':
+                return this.stripJsx(content);
+            case 'keep':
+                return content; // Keep JSX as-is
+            case 'placeholder':
+                return this.replaceWithPlaceholders(content);
+            default:
+                console.log(`Unknown MDX processing mode: ${options.mode}, using placeholder`);
+                return this.replaceWithPlaceholders(content);
+        }
+    }
+    /**
+     * Strip JSX content entirely - ported from cleanMdxContent logic
+     */
+    stripJsx(content) {
+        let cleaned = content;
+        // Remove JSX import statements (requirement 11.1)
+        // Matches: import ... from '...' or import ... from "..."
+        cleaned = cleaned.replace(/^import\s+.*?from\s+['"][^'"]*['"];?\s*$/gm, '');
+        // Remove JSX export statements (requirement 11.2)  
+        // Handle both single-line and multi-line exports
+        // Multi-line function exports: export default function() { ... }
+        cleaned = cleaned.replace(/^export\s+default\s+function[^{]*\{[\s\S]*?\n\}\s*$/gm, '');
+        // Object exports: export const metadata = { ... }
+        cleaned = cleaned.replace(/^export\s+const\s+[^=]*=\s*\{[\s\S]*?\}\s*;?\s*$/gm, '');
+        // Single line exports: export const x = ...; or export default ...
+        cleaned = cleaned.replace(/^export\s+(?:default\s+)?(?:const|let|var|function|class)\s+[^;{]*;?\s*$/gm, '');
+        // Simple exports: export default Component
+        cleaned = cleaned.replace(/^export\s+default\s+[^;{]*;?\s*$/gm, '');
+        // Remove JSX components (requirements 11.3, 11.4)
+        // Self-closing tags: <Component />
+        cleaned = cleaned.replace(/<[A-Z][a-zA-Z0-9]*[^>]*\/>/g, '');
+        // Opening and closing tags with content: <Component>content</Component>
+        // This handles nested components by replacing the outermost ones first
+        let previousLength;
+        do {
+            previousLength = cleaned.length;
+            cleaned = cleaned.replace(/<[A-Z][a-zA-Z0-9]*[^>]*>.*?<\/[A-Z][a-zA-Z0-9]*>/gs, '');
+        } while (cleaned.length !== previousLength);
+        // Clean up multiple consecutive newlines and trim
+        cleaned = cleaned.replace(/\n\s*\n\s*\n/g, '\n\n').trim();
+        // Ensure we never return empty content (requirement 6.4)
+        if (!cleaned.trim()) {
+            return '[content removed]';
+        }
+        return cleaned;
+    }
+    /**
+     * Replace JSX with descriptive placeholders
+     */
+    replaceWithPlaceholders(content) {
+        let cleaned = content;
+        // Replace JSX import statements
+        cleaned = cleaned.replace(/^import\s+.*?from\s+['"][^'"]*['"];?\s*$/gm, '[import removed]');
+        // Replace JSX export statements  
+        // Multi-line function exports: export default function() { ... }
+        cleaned = cleaned.replace(/^export\s+default\s+function[^{]*\{[\s\S]*?\n\}\s*$/gm, '[export removed]');
+        // Object exports: export const metadata = { ... }
+        cleaned = cleaned.replace(/^export\s+const\s+[^=]*=\s*\{[\s\S]*?\}\s*;?\s*$/gm, '[export removed]');
+        // Single line exports: export const x = ...; or export default ...
+        cleaned = cleaned.replace(/^export\s+(?:default\s+)?(?:const|let|var|function|class)\s+[^;{]*;?\s*$/gm, '[export removed]');
+        // Simple exports: export default Component
+        cleaned = cleaned.replace(/^export\s+default\s+[^;{]*;?\s*$/gm, '[export removed]');
+        // Replace JSX components with placeholder
+        // Self-closing tags: <Component />
+        cleaned = cleaned.replace(/<[A-Z][a-zA-Z0-9]*[^>]*\/>/g, '[component removed]');
+        // Opening and closing tags with content: <Component>content</Component>
+        // This handles nested components by replacing the outermost ones first
+        let previousLength;
+        do {
+            previousLength = cleaned.length;
+            cleaned = cleaned.replace(/<[A-Z][a-zA-Z0-9]*[^>]*>.*?<\/[A-Z][a-zA-Z0-9]*>/gs, '[component removed]');
+        } while (cleaned.length !== previousLength);
+        // Clean up multiple consecutive newlines and trim
+        cleaned = cleaned.replace(/\n\s*\n\s*\n/g, '\n\n').trim();
+        return cleaned;
+    }
+}
+//# sourceMappingURL=mdx.js.map

package/dist/esm/text/preprocessors/mermaid.d.ts

@@ -0,0 +1,68 @@
+import { Preprocessor, PreprocessorOptions } from '../../types.js';
+/**
+ * Mermaid preprocessor for handling Mermaid diagrams in Markdown files
+ * Supports strip, extract, and placeholder modes
+ */
+export declare class MermaidPreprocessor implements Preprocessor {
+    /**
+     * Check if this preprocessor applies to the given language/content type
+     * Applies to mermaid code blocks and content with Mermaid syntax
+     */
+    appliesTo(language: string): boolean;
+    /**
+     * Process Mermaid content based on the specified mode
+     */
+    process(content: string, options: PreprocessorOptions): string;
+    /**
+     * Strip Mermaid diagrams entirely
+     */
+    private stripMermaid;
+    /**
+     * Replace Mermaid diagrams with descriptive placeholders
+     */
+    private replaceWithPlaceholders;
+    /**
+     * Extract semantic information from Mermaid diagrams
+     * Converts diagram edges to plain text while ignoring styling and layout instructions
+     */
+    private extractMermaidEdges;
+    /**
+     * Extract edges and relationships from a Mermaid diagram
+     * Ignores styling, layout, and formatting instructions
+     */
+    private extractEdgesFromDiagram;
+    /**
+     * Build a mapping of node IDs to their labels by scanning all lines
+     */
+    private buildNodeLabelMap;
+    /**
+     * Check if a line is a layout instruction (should be ignored)
+     */
+    private isLayoutInstruction;
+    /**
+     * Check if a line is a styling instruction (should be ignored)
+     */
+    private isStyleInstruction;
+    /**
+     * Extract the meaningful label from a node definition
+     * Examples: A[Start] -> "Start", B{Decision} -> "Decision", C((End)) -> "End", D -> "D"
+     */
+    private extractNodeLabel;
+    /**
+     * Extract edge information from a single line
+     */
+    private extractEdgeFromLine;
+    /**
+     * Interpret flowchart connector symbols
+     */
+    private interpretConnector;
+    /**
+     * Interpret class diagram connector symbols
+     */
+    private interpretClassConnector;
+    /**
+     * Interpret ER diagram connector symbols
+     */
+    private interpretERConnector;
+}
+//# sourceMappingURL=mermaid.d.ts.map