ai-prompt-guide-mcp 1.0.0

package/dist/constants/defaults.js

@@ -0,0 +1,78 @@
+/**
+ * Central constants and limits for the Spec-Docs MCP server
+ */
+export const DEFAULT_LIMITS = {
+    /** Maximum file size in bytes (10MB) */
+    MAX_FILE_SIZE: 10 * 1024 * 1024,
+    /** Maximum number of files to process in a single operation */
+    MAX_FILES_PER_OPERATION: 100,
+    /** Maximum heading depth to process */
+    MAX_HEADING_DEPTH: 6,
+    /** Maximum length of a heading title */
+    MAX_HEADING_TITLE_LENGTH: 200,
+    /** Maximum length of section body */
+    MAX_SECTION_BODY_LENGTH: 100 * 1024, // 100KB
+    /** Maximum number of headings in a single document */
+    MAX_HEADINGS_PER_DOCUMENT: 1000,
+    /** Maximum total headings loaded across all cached documents (DoS protection) */
+    MAX_TOTAL_HEADINGS: 100000,
+};
+export const ERROR_CODES = {
+    /** File operation errors */
+    PRECONDITION_FAILED: 'PRECONDITION_FAILED',
+    FILE_NOT_FOUND: 'FILE_NOT_FOUND',
+    FILE_TOO_LARGE: 'FILE_TOO_LARGE',
+    /** Markdown operation errors */
+    DUPLICATE_HEADING: 'DUPLICATE_HEADING',
+    HEADING_NOT_FOUND: 'HEADING_NOT_FOUND',
+    INVALID_HEADING_DEPTH: 'INVALID_HEADING_DEPTH',
+    INVALID_SECTION_CONTENT: 'INVALID_SECTION_CONTENT',
+    /** Validation errors */
+    INVALID_SLUG: 'INVALID_SLUG',
+    INVALID_TITLE: 'INVALID_TITLE',
+    INVALID_OPERATION: 'INVALID_OPERATION',
+    /** Configuration errors */
+    CONFIG_VALIDATION_ERROR: 'CONFIG_VALIDATION_ERROR',
+    ENVIRONMENT_ERROR: 'ENVIRONMENT_ERROR',
+    /** Resource exhaustion errors */
+    RESOURCE_EXHAUSTED: 'RESOURCE_EXHAUSTED',
+};
+export const LOG_LEVELS = {
+    ERROR: 'error',
+    WARN: 'warn',
+    INFO: 'info',
+    DEBUG: 'debug',
+};
+export const HEADING_DEPTHS = [1, 2, 3, 4, 5, 6];
+export const INSERT_MODES = ['insert_before', 'insert_after', 'append_child'];
+/**
+ * Default MCP server configuration values
+ * These are reasonable defaults for most users and don't need to be user-configurable
+ */
+export const DEFAULT_CONFIG = {
+    /** Default log level for MCP server */
+    LOG_LEVEL: LOG_LEVELS.INFO,
+    /** Maximum file size in bytes (10MB) - not currently enforced but defined for future use */
+    MAX_FILE_SIZE: DEFAULT_LIMITS.MAX_FILE_SIZE,
+    /** Maximum files per operation - not currently enforced but defined for future use */
+    MAX_FILES_PER_OPERATION: DEFAULT_LIMITS.MAX_FILES_PER_OPERATION,
+    /** Rate limiting - not currently implemented, reasonable defaults for future use */
+    RATE_LIMIT_REQUESTS_PER_MINUTE: 1000,
+    RATE_LIMIT_BURST_SIZE: 100,
+    /** Safety features - not currently implemented, defaults for future use */
+    ENABLE_FILE_SAFETY_CHECKS: true,
+    ENABLE_MTIME_PRECONDITION: true,
+    /** Reference extraction depth - controls how deep to traverse document references */
+    REFERENCE_EXTRACTION_DEPTH: 3,
+    /** Default workflows directory - relative to plugin root */
+    WORKFLOWS_BASE_PATH: '.ai-prompt-guide/workflows',
+    /** Default guides directory - relative to plugin root */
+    GUIDES_BASE_PATH: '.ai-prompt-guide/guides',
+    /** Default docs directory - relative to workspace */
+    DOCS_BASE_PATH: 'docs',
+    /** Default archived directory - relative to workspace */
+    ARCHIVED_BASE_PATH: 'archived',
+    /** Default coordinator directory - relative to workspace */
+    COORDINATOR_BASE_PATH: 'coordinator',
+};
+//# sourceMappingURL=defaults.js.map

package/dist/constants/defaults.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaults.js","sourceRoot":"","sources":["../../src/constants/defaults.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,wCAAwC;IACxC,aAAa,EAAE,EAAE,GAAG,IAAI,GAAG,IAAI;IAE/B,+DAA+D;IAC/D,uBAAuB,EAAE,GAAG;IAE5B,uCAAuC;IACvC,iBAAiB,EAAE,CAAC;IAEpB,wCAAwC;IACxC,wBAAwB,EAAE,GAAG;IAE7B,qCAAqC;IACrC,uBAAuB,EAAE,GAAG,GAAG,IAAI,EAAE,QAAQ;IAE7C,sDAAsD;IACtD,yBAAyB,EAAE,IAAI;IAE/B,iFAAiF;IACjF,kBAAkB,EAAE,MAAM;CAClB,CAAC;AAEX,MAAM,CAAC,MAAM,WAAW,GAAG;IACzB,4BAA4B;IAC5B,mBAAmB,EAAE,qBAAqB;IAC1C,cAAc,EAAE,gBAAgB;IAChC,cAAc,EAAE,gBAAgB;IAEhC,gCAAgC;IAChC,iBAAiB,EAAE,mBAAmB;IACtC,iBAAiB,EAAE,mBAAmB;IACtC,qBAAqB,EAAE,uBAAuB;IAC9C,uBAAuB,EAAE,yBAAyB;IAElD,wBAAwB;IACxB,YAAY,EAAE,cAAc;IAC5B,aAAa,EAAE,eAAe;IAC9B,iBAAiB,EAAE,mBAAmB;IAEtC,2BAA2B;IAC3B,uBAAuB,EAAE,yBAAyB;IAClD,iBAAiB,EAAE,mBAAmB;IAEtC,iCAAiC;IACjC,kBAAkB,EAAE,oBAAoB;CAChC,CAAC;AAEX,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,KAAK,EAAE,OAAO;IACd,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,KAAK,EAAE,OAAO;CACN,CAAC;AAEX,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAU,CAAC;AAE1D,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,eAAe,EAAE,cAAc,EAAE,cAAc,CAAU,CAAC;AAEvF;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,uCAAuC;IACvC,SAAS,EAAE,UAAU,CAAC,IAAI;IAE1B,4FAA4F;IAC5F,aAAa,EAAE,cAAc,CAAC,aAAa;IAE3C,sFAAsF;IACtF,uBAAuB,EAAE,cAAc,CAAC,uBAAuB;IAE/D,oFAAoF;IACpF,8BAA8B,EAAE,IAAI;IACpC,qBAAqB,EAAE,GAAG;IAE1B,2EAA2E;IAC3E,yBAAyB,EAAE,IAAI;IAC/B,yBAAyB,EAAE,IAAI;IAE/B,qFAAqF;IACrF,0BAA0B,EAAE,CAAC;IAE7B,4DAA4D;IAC5D,mBAAmB,EAAE,4BAA4B;IAEjD,yDAAyD;IACzD,gBAAgB,EAAE,yBAAyB;IAE3C,qDAAqD;IACrD,cAAc,EAAE,MAAM;IAEtB,yDAAyD;IACzD,kBAAkB,EAAE,UAAU;IAE9B,4DAA4D;IAC5D,qBAAqB,EAAE,aAAa;CAC5B,CAAC"}

package/dist/document-cache.d.ts

@@ -0,0 +1,485 @@
+/**
+ * Document cache system with file watching and lazy loading
+ */
+import { EventEmitter } from 'node:events';
+import type { Heading, TocNode } from './types/index.js';
+/**
+ * Access context for cache operations
+ *
+ * Tracks the purpose of document access to apply appropriate caching strategies.
+ * Different contexts receive different eviction resistance (boost factors).
+ */
+export declare enum AccessContext {
+    /** Search operations (lowest eviction resistance) */
+    SEARCH = "search",
+    /** Direct document access (standard eviction resistance) */
+    DIRECT = "direct",
+    /** Reference loading (highest eviction resistance, 2x boost) */
+    REFERENCE = "reference"
+}
+export interface DocumentMetadata {
+    path: string;
+    title: string;
+    lastModified: Date;
+    contentHash: string;
+    wordCount: number;
+    linkCount: number;
+    codeBlockCount: number;
+    lastAccessed: Date;
+    cacheGeneration: number;
+    /** Document namespace derived from path for categorization */
+    namespace: string;
+    /** Lightweight keyword fingerprints for document discovery */
+    keywords: string[];
+    /** Timestamp when fingerprints were generated */
+    fingerprintGenerated: Date;
+}
+/**
+ * Fingerprint entry interface for document discovery improvements
+ *
+ * Stores lightweight metadata for fast document discovery without requiring
+ * full document parsing. Used for efficient relevance scoring and cache
+ * invalidation detection.
+ */
+export interface FingerprintEntry {
+    /** Keywords extracted from document content for discovery */
+    keywords: string[];
+    /** Last modification time for cache invalidation */
+    lastModified: Date;
+    /** Content hash for change detection */
+    contentHash: string;
+    /** Document namespace for categorization */
+    namespace: string;
+}
+/**
+ * Interface Segregation Principle: Split CachedDocument into focused interfaces
+ * to reduce coupling and allow tools to depend only on what they need.
+ *
+ * These interfaces follow the Interface Segregation Principle by breaking down
+ * the complex CachedDocument into focused contracts that tools can implement
+ * based on their specific needs, reducing unnecessary dependencies.
+ */
+/**
+ * Core document information interface
+ *
+ * Provides access to essential document metadata without requiring knowledge
+ * of document structure or content. Used by tools that only need basic
+ * document information like title, path, and namespace.
+ *
+ * @example Basic document info usage
+ * ```typescript
+ * function getDocumentTitle(doc: DocumentCore): string {
+ *   return doc.metadata.title;
+ * }
+ *
+ * function getDocumentNamespace(doc: DocumentCore): string {
+ *   return doc.metadata.namespace;
+ * }
+ * ```
+ *
+ * @example Tool implementation with minimal dependencies
+ * ```typescript
+ * class DocumentInfoTool {
+ *   async execute(doc: DocumentCore): Promise<DocumentInfo> {
+ *     return {
+ *       title: doc.metadata.title,
+ *       path: doc.metadata.path,
+ *       namespace: doc.metadata.namespace,
+ *       lastModified: doc.metadata.lastModified
+ *     };
+ *   }
+ * }
+ * ```
+ *
+ * @see {@link DocumentMetadata} Complete metadata interface
+ * @see {@link CachedDocument} Full document interface
+ */
+export interface DocumentCore {
+    /** Document metadata including title, path, namespace, and timestamps */
+    metadata: DocumentMetadata;
+}
+/**
+ * Document structure interface
+ *
+ * Provides access to document structure information including headings and
+ * table of contents. Used by tools that need to navigate or analyze document
+ * hierarchy without requiring access to actual content.
+ *
+ * @example Structure navigation
+ * ```typescript
+ * function findHeadingBySlug(doc: DocumentStructure, slug: string): Heading | null {
+ *   return doc.headings.find(h => h.slug === slug) ?? null;
+ * }
+ *
+ * function getDocumentOutline(doc: DocumentStructure): TocNode[] {
+ *   return [...doc.toc]; // Return copy of TOC
+ * }
+ * ```
+ *
+ * @example Hierarchical analysis
+ * ```typescript
+ * function analyzeDocumentStructure(doc: DocumentStructure): StructureAnalysis {
+ *   const maxDepth = Math.max(...doc.headings.map(h => h.depth));
+ *   const sectionCount = doc.headings.length;
+ *   const rootSections = doc.toc.filter(node => node.depth === 1);
+ *
+ *   return {
+ *     maxDepth,
+ *     sectionCount,
+ *     rootSectionCount: rootSections.length,
+ *     avgSectionsPerLevel: sectionCount / maxDepth
+ *   };
+ * }
+ * ```
+ *
+ * @see {@link Heading} Individual heading interface
+ * @see {@link TocNode} Table of contents node interface
+ */
+export interface DocumentStructure {
+    /** Ordered list of all headings in the document */
+    headings: readonly Heading[];
+    /** Hierarchical table of contents structure */
+    toc: readonly TocNode[];
+}
+/**
+ * Document indexing interface
+ *
+ * Provides access to optimized lookup structures for fast document querying.
+ * Primarily used internally by the cache system and performance-critical
+ * operations that need O(1) heading lookups.
+ *
+ * @example Fast heading lookup
+ * ```typescript
+ * function getHeadingIndex(doc: DocumentIndex, slug: string): number | undefined {
+ *   return doc.slugIndex.get(slug);
+ * }
+ *
+ * function hasHeading(doc: DocumentIndex, slug: string): boolean {
+ *   return doc.slugIndex.has(slug);
+ * }
+ * ```
+ *
+ * @example Bulk heading operations
+ * ```typescript
+ * function validateHeadingSlugs(
+ *   doc: DocumentIndex,
+ *   requiredSlugs: string[]
+ * ): ValidationResult {
+ *   const missing = requiredSlugs.filter(slug => !doc.slugIndex.has(slug));
+ *   const existing = requiredSlugs.filter(slug => doc.slugIndex.has(slug));
+ *
+ *   return {
+ *     valid: missing.length === 0,
+ *     missing,
+ *     existing
+ *   };
+ * }
+ * ```
+ *
+ * @see {@link DocumentCache} Cache implementation that builds indices
+ */
+export interface DocumentIndex {
+    /** Map from section slug to heading index for O(1) lookups */
+    slugIndex: ReadonlyMap<string, number>;
+}
+/**
+ * Document content interface
+ *
+ * Placeholder interface for future content-related functionality.
+ * Section content is not cached - it's parsed on-demand from the document.
+ *
+ * @see {@link DocumentCache} Cache implementation managing content lifecycle
+ */
+export interface DocumentContent {
+}
+/**
+ * Backward compatible composed interface
+ * Maintains compatibility with existing code while allowing focused usage
+ */
+export interface CachedDocument extends DocumentCore, DocumentStructure, DocumentIndex, DocumentContent {
+}
+interface CacheOptions {
+    maxCacheSize: number;
+    enableWatching: boolean;
+    watchIgnorePatterns: string[];
+    evictionPolicy: 'lru' | 'mru';
+    boostFactors?: {
+        search?: number;
+        direct?: number;
+        reference?: number;
+    };
+}
+/**
+ * Document cache with file watching and intelligent invalidation
+ */
+export declare class DocumentCache extends EventEmitter {
+    private readonly cache;
+    private readonly accessOrder;
+    private readonly accessMetadata;
+    private readonly options;
+    private readonly docsRoot;
+    private readonly coordinatorRoot;
+    private watcher;
+    private accessCounter;
+    private readonly boostFactors;
+    private watcherErrorCount;
+    private readonly MAX_WATCHER_ERRORS;
+    private pollingInterval;
+    private totalHeadingsLoaded;
+    constructor(docsRoot: string, options?: Partial<CacheOptions>, coordinatorRoot?: string);
+    /**
+     * Setup integration with addressing system cache to maintain consistency
+     */
+    private setupAddressingCacheIntegration;
+    /**
+     * Initialize file system watcher
+     */
+    private initializeWatcher;
+    /**
+     * Reinitialize file watcher with exponential backoff after error
+     */
+    private reinitializeWatcher;
+    /**
+     * Switch to polling mode after repeated watcher failures
+     *
+     * Implements fallback polling mechanism that validates cache consistency
+     * every 30 seconds by checking file modification times. This ensures the
+     * cache stays synchronized even when the file watcher is unavailable.
+     */
+    private switchToPollingMode;
+    /**
+     * Validate cache consistency by checking file modification times
+     *
+     * Used in polling mode to detect file changes when the watcher is unavailable.
+     * Compares cached modification times with current file stats and invalidates
+     * stale entries.
+     */
+    private validateCacheConsistency;
+    /**
+     * Convert absolute path to relative document path
+     */
+    private getRelativePath;
+    /**
+     * Get absolute file path from document path
+     */
+    private getAbsolutePath;
+    /**
+     * Calculate content hash for cache validation
+     */
+    private calculateHash;
+    /**
+     * Extract lightweight keywords from document content for fingerprinting
+     *
+     * Optimized for cache operations - extracts meaningful keywords from
+     * title and content while being lightweight enough for frequent use.
+     *
+     * @param title - Document title
+     * @param content - Full document content
+     * @returns Array of keywords limited to 20 items for performance
+     */
+    private extractKeywordsForFingerprint;
+    /**
+     * Extract metadata from markdown content
+     */
+    private extractMetadata;
+    /**
+     * Build slug index for fast section lookups
+     */
+    private buildSlugIndex;
+    /**
+     * Enforce cache size limits with boost-aware LRU/MRU eviction
+     *
+     * Uses access metadata to calculate eviction scores that incorporate
+     * both access time and boost factors. Documents with higher boost factors
+     * (e.g., search-accessed) are less likely to be evicted.
+     */
+    private enforceCacheSize;
+    /**
+     * Update access tracking for cache policies with context-aware boost
+     *
+     * @param docPath - Document path
+     * @param context - Access context (search, direct, reference)
+     */
+    private updateAccess;
+    /**
+     * Retrieves a document from cache or loads it from the filesystem
+     *
+     * Uses boost-aware LRU eviction policy and automatic cache invalidation on file changes.
+     * Documents are parsed to extract headings, table of contents, and metadata.
+     *
+     * @param docPath - Relative path to the document (e.g., "api/auth.md")
+     * @param context - Access context for boost-aware caching (search, direct, reference)
+     * @returns Cached document with metadata and structure, or null if file doesn't exist
+     *
+     * @example Basic usage (default DIRECT context)
+     * const doc = await cache.getDocument("api/authentication.md");
+     * if (doc) {
+     *   console.log(`Title: ${doc.metadata.title}`);
+     *   console.log(`Headings: ${doc.headings.length}`);
+     * }
+     *
+     * @example Search context (3x eviction resistance)
+     * const doc = await cache.getDocument("api/authentication.md", AccessContext.SEARCH);
+     *
+     * @example Reference context (2x eviction resistance)
+     * const doc = await cache.getDocument("api/tokens.md", AccessContext.REFERENCE);
+     *
+     * @throws {Error} When file access fails due to permissions or other filesystem errors
+     */
+    getDocument(docPath: string, context?: AccessContext): Promise<CachedDocument | null>;
+    /**
+     * Retrieves the content of a specific section from a document
+     *
+     * Uses slugIndex for O(1) validation before parsing section content.
+     * No caching of section content (sections typically accessed once).
+     *
+     * @param docPath - Relative path to the document
+     * @param slug - Section slug (flat or hierarchical path)
+     * @returns Section content or null if section not found
+     *
+     * @example
+     * // Flat addressing
+     * const content = await cache.getSectionContent("api/auth.md", "overview");
+     *
+     * // Hierarchical addressing
+     * const content = await cache.getSectionContent("api/auth.md", "api/auth/jwt-tokens");
+     *
+     * @throws {Error} When document cannot be loaded or section extraction fails
+     */
+    getSectionContent(docPath: string, slug: string): Promise<string | null>;
+    /**
+     * Invalidate a document in the cache
+     */
+    invalidateDocument(docPath: string): boolean;
+    /**
+     * Get all cached document paths
+     */
+    getCachedPaths(): string[];
+    /**
+     * Get all cached document paths (alias for getCachedPaths)
+     *
+     * Provides explicit API for retrieving cached document paths without
+     * requiring access to cache internals. Preferred over direct cache access.
+     *
+     * @returns Array of document paths currently in cache
+     *
+     * @example
+     * ```typescript
+     * const paths = cache.getCachedDocumentPaths();
+     * console.log(`Currently caching ${paths.length} documents`);
+     * paths.forEach(path => console.log(`  - ${path}`));
+     * ```
+     */
+    getCachedDocumentPaths(): string[];
+    /**
+     * Invalidate all documents matching a path prefix
+     *
+     * Useful for invalidating entire folders when archiving or moving documents.
+     * Uses proper encapsulation instead of accessing cache internals directly.
+     *
+     * @param prefix - Path prefix to match (e.g., '/api/' to invalidate all /api/* documents)
+     * @returns Number of documents invalidated
+     *
+     * @example Invalidate all documents in a folder
+     * ```typescript
+     * const count = cache.invalidateDocumentsByPrefix('/api/');
+     * console.log(`Invalidated ${count} documents in /api/ folder`);
+     * ```
+     *
+     * @example Invalidate documents before archiving
+     * ```typescript
+     * // Before moving folder to archive
+     * const invalidated = cache.invalidateDocumentsByPrefix('/old-docs/');
+     * logger.info('Prepared folder for archival', { invalidated });
+     * ```
+     */
+    invalidateDocumentsByPrefix(prefix: string): number;
+    /**
+     * Get cache statistics including boost information
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+        hitRate: number;
+        oldestAccess: Date | null;
+        newestAccess: Date | null;
+        boostedDocuments?: {
+            search: number;
+            reference: number;
+            direct: number;
+        };
+    };
+    /**
+     * Clear all cached documents
+     */
+    clear(): void;
+    /**
+     * Create a fingerprint entry from document metadata
+     *
+     * Extracts the fingerprint-relevant information from cached metadata
+     * for use in document discovery and cache invalidation operations.
+     *
+     * @param metadata - Document metadata containing fingerprint information
+     * @returns FingerprintEntry with extracted data
+     */
+    createFingerprintEntry(metadata: DocumentMetadata): FingerprintEntry;
+    /**
+     * Check if a document's fingerprint is stale compared to file system
+     *
+     * Compares the cached fingerprint timestamp and content hash with the
+     * actual file modification time to determine if the cache needs updating.
+     *
+     * @param docPath - Relative path to the document
+     * @returns Promise resolving to true if fingerprint is stale, false if current
+     *
+     * @example
+     * ```typescript
+     * const isStale = await cache.isFingerprintStale('/api/auth.md');
+     * if (isStale) {
+     *   cache.invalidateDocument('/api/auth.md');
+     *   // Fingerprint will be regenerated on next getDocument call
+     * }
+     * ```
+     */
+    isFingerprintStale(docPath: string): Promise<boolean>;
+    /**
+     * Read the complete content of a document from the filesystem
+     *
+     * Provides direct access to the full document content without going through
+     * the section-based cache system. Used for operations that need the entire
+     * document content like relevance analysis and keyword extraction.
+     *
+     * @param docPath - Relative path to the document (e.g., "api/auth.md")
+     * @returns Promise resolving to full document content or null if file doesn't exist
+     *
+     * @example
+     * const content = await cache.readDocumentContent("api/authentication.md");
+     * if (content) {
+     *   console.log(`Document length: ${content.length} characters`);
+     * }
+     *
+     * @throws {Error} When file access fails due to permissions or other filesystem errors
+     */
+    readDocumentContent(docPath: string): Promise<string | null>;
+    /**
+     * Cleanup resources
+     */
+    destroy(): Promise<void>;
+}
+/**
+ * Initialize global document cache
+ * @deprecated Use dependency injection with DocumentCache constructor instead
+ */
+export declare function initializeGlobalCache(docsRoot: string, options?: Partial<CacheOptions>): DocumentCache;
+/**
+ * Get global cache instance
+ * @deprecated Use dependency injection with DocumentCache constructor instead
+ */
+export declare function getGlobalCache(): DocumentCache;
+/**
+ * Factory function for creating DocumentCache instances with explicit configuration
+ * This is the recommended approach for new code instead of global singletons
+ */
+export declare function createDocumentCache(docsRoot: string, options?: Partial<CacheOptions>, coordinatorRoot?: string): DocumentCache;
+export {};
+//# sourceMappingURL=document-cache.d.ts.map

package/dist/document-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-cache.d.ts","sourceRoot":"","sources":["../src/document-cache.ts"],"names":[],"mappings":"AAAA;;GAEG;AAMH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAiB,MAAM,kBAAkB,CAAC;AAuBxE;;;;;GAKG;AACH,oBAAY,aAAa;IACvB,qDAAqD;IACrD,MAAM,WAAW;IACjB,4DAA4D;IAC5D,MAAM,WAAW;IACjB,gEAAgE;IAChE,SAAS,cAAc;CACxB;AAoCD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,IAAI,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,IAAI,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,iDAAiD;IACjD,oBAAoB,EAAE,IAAI,CAAC;CAC5B;AAGD;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,6DAA6D;IAC7D,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,oDAAoD;IACpD,YAAY,EAAE,IAAI,CAAC;IACnB,wCAAwC;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,MAAM,WAAW,YAAY;IAC3B,yEAAyE;IACzE,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,QAAQ,EAAE,SAAS,OAAO,EAAE,CAAC;IAE7B,+CAA+C;IAC/C,GAAG,EAAE,SAAS,OAAO,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,WAAW,aAAa;IAC5B,8DAA8D;IAC9D,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED;;;;;;;GAOG;AAEH,MAAM,WAAW,eAAe;CAE/B;AAED;;;GAGG;AACH,MAAM,WAAW,cAAe,SAC9B,YAAY,EACZ,iBAAiB,EACjB,aAAa,EACb,eAAe;CAAG;AAEpB,UAAU,YAAY;IACpB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,OAAO,CAAC;IACxB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,cAAc,EAAE,KAAK,GAAG,KAAK,CAAC;IAC9B,YAAY,CAAC,EAAE;QACb,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH;AAcD;;GAEG;AACH,qBAAa,aAAc,SAAQ,YAAY;IAC7C,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqC;IAC3D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IACzD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqC;IACpE,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAe;IACvC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAS;IACzC,OAAO,CAAC,OAAO,CAAuC;IACtD,OAAO,CAAC,aAAa,CAAK;IAC1B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAwD;IACrF,OAAO,CAAC,iBAAiB,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAC,kBAAkB,CAAK;IACxC,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,mBAAmB,CAAK;gBAEpB,QAAQ,EAAE,MAAM,EAAE,OAAO,GAAE,OAAO,CAAC,YAAY,CAAM,EAAE,eAAe,CAAC,EAAE,MAAM;IA6B3F;;OAEG;IACH,OAAO,CAAC,+BAA+B;IAmCvC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA8DzB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAoB3B;;;;;;OAMG;IACH,OAAO,CAAC,mBAAmB;IAsB3B;;;;;;OAMG;YACW,wBAAwB;IAwCtC;;OAEG;IACH,OAAO,CAAC,eAAe;IAKvB;;OAEG;IACH,OAAO,CAAC,eAAe;IAgBvB;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;;;;;;;;OASG;IACH,OAAO,CAAC,6BAA6B;IA+CrC;;OAEG;IACH,OAAO,CAAC,eAAe;IAoCvB;;OAEG;IACH,OAAO,CAAC,cAAc;IAQtB;;;;;;OAMG;IACH,OAAO,CAAC,gBAAgB;IA+CxB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAYpB;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,aAAoC,GAAG,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;IA4EjH;;;;;;;;;;;;;;;;;;OAkBG;IACG,iBAAiB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IA+C9E;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAwC5C;;OAEG;IACH,cAAc,IAAI,MAAM,EAAE;IAI1B;;;;;;;;;;;;;;OAcG;IACH,sBAAsB,IAAI,MAAM,EAAE;IAIlC;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;IAgBnD;;OAEG;IACH,QAAQ,IAAI;QACV,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE,MAAM,CAAC;QAChB,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;QAC1B,YAAY,EAAE,IAAI,GAAG,IAAI,CAAC;QAC1B,gBAAgB,CAAC,EAAE;YACjB,MAAM,EAAE,MAAM,CAAC;YACf,SAAS,EAAE,MAAM,CAAC;YAClB,MAAM,EAAE,MAAM,CAAC;SAChB,CAAC;KACH;IAyBD;;OAEG;IACH,KAAK,IAAI,IAAI;IAWb;;;;;;;;OAQG;IACH,sBAAsB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,gBAAgB;IASpE;;;;;;;;;;;;;;;;;OAiBG;IACG,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAoE3D;;;;;;;;;;;;;;;;;OAiBG;IACG,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAsBlE;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CAgC/B;AAQD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,GAAG,aAAa,CAOtG;AAED;;;GAGG;AACH,wBAAgB,cAAc,IAAI,aAAa,CAM9C;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,YAAY,CAAC,EAAE,eAAe,CAAC,EAAE,MAAM,GAAG,aAAa,CAE9H"}

package/dist/document-cache.hierarchical.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=document-cache.hierarchical.test.d.ts.map

package/dist/document-cache.hierarchical.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document-cache.hierarchical.test.d.ts","sourceRoot":"","sources":["../src/document-cache.hierarchical.test.ts"],"names":[],"mappings":""}