@silvestv/migration-planificator 3.0.0

package/dist/src/core/ast/matchers/ts/expression-matcher.js

@@ -0,0 +1,237 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesExpression = matchesExpression;
+exports.matchesArguments = matchesArguments;
+exports.matchesLeft = matchesLeft;
+exports.matchesRight = matchesRight;
+exports.matchesChainContains = matchesChainContains;
+exports.matchesBody = matchesBody;
+const ts_morph_1 = require("ts-morph");
+const decorator_matcher_1 = require("./decorator-matcher");
+/**
+ * Vérifie l'expression d'un nœud (CallExpression, PropertyAccessExpression, etc.)
+ * Supporte l'imbrication : expression.expression.expression etc.
+ */
+function matchesExpression(node, expressionPattern, matchesAstPatternFn) {
+    let expression;
+    if (ts_morph_1.Node.isCallExpression(node)) {
+        expression = node.getExpression();
+    }
+    else if (ts_morph_1.Node.isPropertyAccessExpression(node)) {
+        expression = node.getExpression();
+    }
+    else if (ts_morph_1.Node.isDecorator(node)) {
+        expression = node.getExpression();
+    }
+    else if (ts_morph_1.Node.isNonNullExpression(node)) {
+        expression = node.getExpression();
+    }
+    else if (ts_morph_1.Node.isNewExpression(node)) {
+        expression = node.getExpression();
+    }
+    if (!expression) {
+        return false;
+    }
+    // Si expressionPattern est une string, vérifier que l'expression est un Identifier avec ce nom
+    if (typeof expressionPattern === 'string') {
+        if (ts_morph_1.Node.isIdentifier(expression)) {
+            return expression.getText() === expressionPattern;
+        }
+        return false;
+    }
+    return matchesAstPatternFn(expression, expressionPattern);
+}
+/**
+ * Vérifie les arguments d'un CallExpression
+ */
+function matchesArguments(node, argumentsPattern, matchesAstPatternFn) {
+    if (!ts_morph_1.Node.isCallExpression(node)) {
+        return false;
+    }
+    const args = node.getArguments();
+    // Vérifier contains
+    if (argumentsPattern.contains) {
+        const hasMatch = args.some(arg => matchesAstPatternFn(arg, argumentsPattern.contains));
+        if (!hasMatch) {
+            return false;
+        }
+    }
+    // Vérifier containsAny
+    if (argumentsPattern.containsAny) {
+        const hasMatch = args.some(arg => argumentsPattern.containsAny.some((pattern) => matchesAstPatternFn(arg, pattern)));
+        if (!hasMatch) {
+            return false;
+        }
+    }
+    // Vérifier containsCall
+    if (argumentsPattern.containsCall) {
+        const hasCall = args.some(arg => {
+            if (!ts_morph_1.Node.isCallExpression(arg)) {
+                return false;
+            }
+            // Vérifier le nom de la fonction
+            if (argumentsPattern.containsCall.functionName) {
+                const funcName = arg.getExpression().getText().split('.').pop() || '';
+                if (funcName !== argumentsPattern.containsCall.functionName) {
+                    return false;
+                }
+            }
+            // Vérifier l'objet passé en argument
+            if (argumentsPattern.containsCall.object && argumentsPattern.containsCall.object.properties) {
+                const callArgs = arg.getArguments();
+                // Si des propriétés sont définies avec missing: true
+                const hasAnyMissing = Object.values(argumentsPattern.containsCall.object.properties).some((prop) => prop.missing === true);
+                if (hasAnyMissing) {
+                    // Vérifier que l'appel n'a PAS d'objet ou que l'objet n'a PAS la propriété
+                    if (callArgs.length === 0) {
+                        // Pas d'arguments = propriété manquante
+                        return true;
+                    }
+                    if (ts_morph_1.Node.isObjectLiteralExpression(callArgs[0])) {
+                        // Vérifier que les propriétés "missing" sont bien absentes
+                        return (0, decorator_matcher_1.checkObjectProperties)(callArgs[0], argumentsPattern.containsCall.object.properties);
+                    }
+                    // Pas un objet littéral = propriété manquante
+                    return true;
+                }
+                // Vérification normale (exists, valeurs spécifiques)
+                if (callArgs.length > 0 && ts_morph_1.Node.isObjectLiteralExpression(callArgs[0])) {
+                    return (0, decorator_matcher_1.checkObjectProperties)(callArgs[0], argumentsPattern.containsCall.object.properties);
+                }
+                return false;
+            }
+            return true;
+        });
+        if (!hasCall) {
+            return false;
+        }
+    }
+    // Vérifier properties (sur les arguments objets - par défaut le 1er, sinon chercher dans tous)
+    if (argumentsPattern.properties) {
+        // Chercher dans tous les arguments pour trouver un ObjectLiteralExpression
+        for (const arg of args) {
+            if (ts_morph_1.Node.isObjectLiteralExpression(arg)) {
+                const result = (0, decorator_matcher_1.checkObjectProperties)(arg, argumentsPattern.properties);
+                // Si on trouve un objet qui matche (ou qui ne matche pas les missing), on retourne le résultat
+                if (result || Object.values(argumentsPattern.properties).some((p) => p && typeof p === 'object' && p.missing)) {
+                    return result;
+                }
+            }
+        }
+        // Aucun objet trouvé - si on cherche des "missing", c'est un match (l'objet n'existe pas du tout)
+        if (Object.values(argumentsPattern.properties).some((p) => p && typeof p === 'object' && p.missing)) {
+            return true;
+        }
+        return false;
+    }
+    // Vérifier count
+    if (argumentsPattern.count !== undefined) {
+        if (args.length !== argumentsPattern.count) {
+            return false;
+        }
+    }
+    // Vérifier secondArgument
+    if (argumentsPattern.secondArgument) {
+        if (argumentsPattern.secondArgument.missing) {
+            if (args.length >= 2) {
+                return false;
+            }
+        }
+    }
+    // Vérifier missing (vérifier que l'argument nommé n'est PAS présent)
+    if (argumentsPattern.missing) {
+        const missingName = argumentsPattern.missing;
+        // Vérifier si un argument est un CallExpression avec ce nom de fonction
+        const hasMatchingCall = args.some(arg => {
+            if (ts_morph_1.Node.isCallExpression(arg)) {
+                const funcName = arg.getExpression().getText().split('.').pop() || '';
+                return funcName === missingName;
+            }
+            // Vérifier aussi si c'est un Identifier simple
+            if (ts_morph_1.Node.isIdentifier(arg)) {
+                return arg.getText() === missingName;
+            }
+            return false;
+        });
+        // Si on trouve l'argument "missing", le pattern ne matche PAS
+        if (hasMatchingCall) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Vérifie la partie gauche d'une BinaryExpression
+ */
+function matchesLeft(node, leftPattern, matchesAstPatternFn) {
+    if (!ts_morph_1.Node.isBinaryExpression(node)) {
+        return false;
+    }
+    const left = node.getLeft();
+    return matchesAstPatternFn(left, leftPattern);
+}
+/**
+ * Vérifie la partie droite d'une BinaryExpression
+ */
+function matchesRight(node, rightPattern) {
+    if (!ts_morph_1.Node.isBinaryExpression(node)) {
+        return false;
+    }
+    const right = node.getRight();
+    // Vérifier value
+    if (rightPattern.value !== undefined) {
+        const rightValue = right.getText();
+        const expectedValue = String(rightPattern.value);
+        return rightValue === expectedValue ||
+            rightValue === `'${expectedValue}'` ||
+            rightValue === `"${expectedValue}"`;
+    }
+    return true;
+}
+/**
+ * Vérifie une chaîne de propriétés (ex: a.b.c.pipe().subscribe())
+ */
+function matchesChainContains(node, chainPatterns, matchesAstPatternFn) {
+    if (!ts_morph_1.Node.isPropertyAccessExpression(node)) {
+        return false;
+    }
+    let current = node;
+    let patternIndex = chainPatterns.length - 1;
+    while (patternIndex >= 0 && ts_morph_1.Node.isPropertyAccessExpression(current)) {
+        if (!matchesAstPatternFn(current, chainPatterns[patternIndex])) {
+            return false;
+        }
+        patternIndex--;
+        current = current.getExpression();
+    }
+    return patternIndex < 0;
+}
+/**
+ * Vérifie le corps d'une fonction
+ */
+function matchesBody(node, bodyPattern, matchesAstPatternFn) {
+    let body;
+    if (ts_morph_1.Node.isFunctionDeclaration(node)) {
+        body = node.getBody();
+    }
+    else if (ts_morph_1.Node.isMethodDeclaration(node)) {
+        body = node.getBody();
+    }
+    else if (ts_morph_1.Node.isArrowFunction(node)) {
+        body = node.getBody();
+    }
+    if (!body) {
+        return false;
+    }
+    // Vérifier contains
+    if (bodyPattern.contains) {
+        let hasMatch = false;
+        body.forEachDescendant((child) => {
+            if (matchesAstPatternFn(child, bodyPattern.contains)) {
+                hasMatch = true;
+            }
+        });
+        return hasMatch;
+    }
+    return true;
+}

package/dist/src/core/ast/matchers/ts/file-matcher.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesInFilePattern = matchesInFilePattern;
+exports.matchesTestSetup = matchesTestSetup;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Vérifie si un fichier correspond au pattern inFile
+ * @param filePath Chemin relatif du fichier
+ * @param inFilePattern Pattern de fichier (string, objet tsconfig, objet avec exclude, etc.)
+ */
+function matchesInFilePattern(filePath, inFilePattern) {
+    // Si c'est un pattern de type "*.spec.ts" ou "angular.json"
+    if (typeof inFilePattern === 'string') {
+        // Normaliser le chemin (remplacer \ par /)
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        // Convertir le pattern glob en regex
+        const regexPattern = inFilePattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*');
+        const regex = new RegExp(regexPattern + '$');
+        // Tester le chemin complet ET juste le nom de fichier
+        const fileName = normalizedPath.split('/').pop() || '';
+        return regex.test(normalizedPath) || regex.test(fileName);
+    }
+    // Si c'est un objet avec exclude (ex: { exclude: "*.spec.ts" })
+    if (typeof inFilePattern === 'object' && inFilePattern.exclude) {
+        // Normaliser le chemin (remplacer \ par /)
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        // Convertir le pattern glob en regex
+        const excludePattern = inFilePattern.exclude;
+        const regexPattern = excludePattern
+            .replace(/\./g, '\\.')
+            .replace(/\*/g, '.*');
+        const regex = new RegExp(regexPattern + '$');
+        // Tester le chemin complet ET juste le nom de fichier
+        const fileName = normalizedPath.split('/').pop() || '';
+        const isExcluded = regex.test(normalizedPath) || regex.test(fileName);
+        // Retourner l'inverse : si exclu, retourner false
+        return !isExcluded;
+    }
+    // Si c'est un objet de configuration (ex: { tsconfig: {...} })
+    if (typeof inFilePattern === 'object' && inFilePattern.tsconfig) {
+        // Pour les patterns tsconfig complexes (ex: host_bindings_type_checking)
+        // On vérifie si le fichier devrait être concerné
+        // Cette vérification nécessite de lire tsconfig.json, ce qui est coûteux
+        // Règle spécifique: host_bindings_type_checking concerne tous les fichiers .ts
+        if (inFilePattern.tsconfig.angularCompilerOptions) {
+            return filePath.endsWith('.ts') && !filePath.endsWith('.spec.ts');
+        }
+        // Par défaut, matcher tous les fichiers pour ne pas bloquer l'analyse
+        return true;
+    }
+    return true;
+}
+/**
+ * Vérifie si le setup de test correspond au pattern testSetup
+ * @param sourceFile Fichier source TypeScript
+ * @param testSetupPattern Pattern de setup de test (providers, etc.)
+ */
+function matchesTestSetup(sourceFile, testSetupPattern) {
+    // Vérifier si ErrorHandler est manquant dans les providers du TestBed
+    if (testSetupPattern.providers && testSetupPattern.providers.missing) {
+        const missingProvider = testSetupPattern.providers.missing;
+        let hasProvider = false;
+        // Chercher tous les appels à TestBed.configureTestingModule
+        sourceFile.forEachDescendant((node) => {
+            if (ts_morph_1.Node.isCallExpression(node)) {
+                const expression = node.getExpression();
+                if (ts_morph_1.Node.isPropertyAccessExpression(expression)) {
+                    const objectText = expression.getExpression().getText();
+                    const propertyText = expression.getName();
+                    if (objectText === 'TestBed' && propertyText === 'configureTestingModule') {
+                        // Analyser les arguments pour trouver providers
+                        const args = node.getArguments();
+                        if (args.length > 0 && ts_morph_1.Node.isObjectLiteralExpression(args[0])) {
+                            const configObj = args[0];
+                            const providersProperty = configObj.getProperty('providers');
+                            if (providersProperty && ts_morph_1.Node.isPropertyAssignment(providersProperty)) {
+                                const providersValue = providersProperty.getInitializer();
+                                if (providersValue) {
+                                    const providersText = providersValue.getText();
+                                    if (providersText.includes(missingProvider)) {
+                                        hasProvider = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        });
+        // Si le pattern demande "missing: ErrorHandler" et qu'on l'a trouvé, retourner false
+        // Sinon, retourner true (le provider est bien manquant)
+        return !hasProvider;
+    }
+    return true;
+}

package/dist/src/core/ast/matchers/ts/hierarchy-matcher.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesParent = matchesParent;
+exports.matchesInClass = matchesInClass;
+exports.matchesAncestor = matchesAncestor;
+exports.matchesImplements = matchesImplements;
+exports.matchesImplementsGeneric = matchesImplementsGeneric;
+const ts_morph_1 = require("ts-morph");
+const matcher_helpers_1 = require("../utils/matcher-helpers");
+/**
+ * Vérifie le parent d'un nœud
+ * Note: matchesAstPattern sera importé depuis index.ts pour éviter les dépendances circulaires
+ */
+function matchesParent(node, parentPattern, matchesAstPatternFn) {
+    const parent = node.getParent();
+    if (!parent) {
+        return false;
+    }
+    // Vérifier notNodeType et notFunctionName : chercher dans TOUS les ancêtres (pas juste parent immédiat)
+    if (parentPattern.notNodeType || parentPattern.notFunctionName) {
+        let current = node.getParent();
+        while (current) {
+            // Vérifier notNodeType
+            if (parentPattern.notNodeType && current.getKindName() === parentPattern.notNodeType) {
+                // Vérifier notFunctionName si spécifié
+                if (parentPattern.notFunctionName && ts_morph_1.Node.isCallExpression(current)) {
+                    const funcName = current.getExpression().getText().split('.').pop() || '';
+                    if (funcName === parentPattern.notFunctionName) {
+                        return false; // Trouvé le pattern à exclure
+                    }
+                }
+                else if (!parentPattern.notFunctionName) {
+                    return false; // notNodeType seul trouvé
+                }
+            }
+            current = current.getParent();
+        }
+    }
+    // D'abord vérifier le nodeType du parent
+    if (parentPattern.nodeType) {
+        const parentNodeTypes = (0, matcher_helpers_1.ensureArray)(parentPattern.nodeType);
+        // Si name est spécifié, chercher dans les ancêtres une VariableDeclaration qui matche
+        if (parentPattern.name) {
+            let current = node.getParent();
+            while (current) {
+                const currentKind = current.getKindName();
+                if (parentNodeTypes.includes(currentKind)) {
+                    // Vérifier si ce nœud a le nom recherché
+                    if (ts_morph_1.Node.isVariableDeclaration(current)) {
+                        const varName = current.getName();
+                        const expectedNames = (0, matcher_helpers_1.ensureArray)(parentPattern.name);
+                        if (expectedNames.includes(varName)) {
+                            return true;
+                        }
+                    }
+                    else if (ts_morph_1.Node.isVariableStatement(current)) {
+                        // Pour VariableStatement, vérifier les déclarations
+                        const declarations = current.getDeclarations();
+                        const expectedNames = (0, matcher_helpers_1.ensureArray)(parentPattern.name);
+                        const hasMatchingName = declarations.some(decl => expectedNames.includes(decl.getName()));
+                        if (hasMatchingName) {
+                            return true;
+                        }
+                    }
+                }
+                current = current.getParent();
+            }
+            return false;
+        }
+        // Si pas de name, vérifier seulement le nodeType du parent immédiat
+        const parentKind = parent.getKindName();
+        if (!parentNodeTypes.includes(parentKind)) {
+            return false;
+        }
+    }
+    // Vérifier initializer (pour PropertyDeclaration) APRÈS avoir vérifié le nodeType
+    if (parentPattern.initializer && ts_morph_1.Node.isPropertyDeclaration(parent)) {
+        const initializer = parent.getInitializer();
+        if (!initializer) {
+            return false;
+        }
+        // Vérifier récursivement l'initializer
+        if (!matchesAstPatternFn(initializer, parentPattern.initializer)) {
+            return false;
+        }
+        // Si l'initializer matche, on retourne true (pas besoin de vérifier tout le parent)
+        return true;
+    }
+    return matchesAstPatternFn(parent, parentPattern);
+}
+/**
+ * Vérifie si le nœud est dans une classe avec les décorateurs spécifiés
+ */
+function matchesInClass(node, classPattern, matchesAstPatternFn) {
+    let current = node.getParent();
+    while (current) {
+        if (ts_morph_1.Node.isClassDeclaration(current)) {
+            // Vérifier hasDecorator
+            if (classPattern.hasDecorator) {
+                const decorators = current.getDecorators();
+                const decoratorNames = decorators.map(d => {
+                    const expr = d.getExpression();
+                    if (ts_morph_1.Node.isCallExpression(expr)) {
+                        return expr.getExpression().getText();
+                    }
+                    return expr.getText();
+                });
+                const hasRequiredDecorator = classPattern.hasDecorator.some((name) => decoratorNames.includes(name));
+                if (!hasRequiredDecorator) {
+                    return false;
+                }
+            }
+            return matchesAstPatternFn(current, classPattern);
+        }
+        current = current.getParent();
+    }
+    return false;
+}
+/**
+ * Vérifie un ancêtre dans l'arbre AST
+ */
+function matchesAncestor(node, ancestorPattern, matchesAstPatternFn) {
+    let current = node.getParent();
+    while (current) {
+        if (matchesAstPatternFn(current, ancestorPattern)) {
+            return true;
+        }
+        current = current.getParent();
+    }
+    return false;
+}
+/**
+ * Vérifie si le nœud implémente une interface
+ */
+function matchesImplements(node, interfaceName) {
+    if (!ts_morph_1.Node.isClassDeclaration(node)) {
+        return false;
+    }
+    const implementsClauses = node.getImplements();
+    return implementsClauses.some(clause => {
+        const text = clause.getText();
+        // Matcher l'interface avec ou sans génériques (ex: "Resolve" matche "Resolve<User>")
+        return text === interfaceName || text.startsWith(interfaceName + '<');
+    });
+}
+/**
+ * Vérifie si le nœud implémente une interface générique manquante
+ */
+function matchesImplementsGeneric(node, implementsGenericPattern) {
+    if (!ts_morph_1.Node.isClassDeclaration(node)) {
+        return false;
+    }
+    const implementsClauses = node.getImplements();
+    if (implementsGenericPattern.missing) {
+        const missingType = implementsGenericPattern.missing;
+        // Vérifier qu'aucune clause implements ne contient le type manquant dans ses génériques
+        const hasGeneric = implementsClauses.some(clause => {
+            const text = clause.getText();
+            // Vérifier si le type manquant est présent dans la partie générique (entre < et >)
+            const genericMatch = text.match(/<([^>]+)>/);
+            if (genericMatch) {
+                const genericsText = genericMatch[1];
+                // Vérifier si le type manquant apparaît dans les génériques (avec ou sans espaces)
+                return genericsText.includes(missingType);
+            }
+            return false;
+        });
+        // On veut que le type soit absent, donc on retourne true si hasGeneric est false
+        return !hasGeneric;
+    }
+    return true;
+}

package/dist/src/core/ast/matchers/ts/import-matcher.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesModuleSpecifier = matchesModuleSpecifier;
+exports.matchesNamedImports = matchesNamedImports;
+const ts_morph_1 = require("ts-morph");
+/**
+ * Vérifie le module specifier d'une ImportDeclaration
+ */
+function matchesModuleSpecifier(node, moduleSpecifier) {
+    if (!ts_morph_1.Node.isImportDeclaration(node)) {
+        return false;
+    }
+    const moduleSpec = node.getModuleSpecifierValue();
+    return moduleSpec === moduleSpecifier;
+}
+/**
+ * Vérifie les named imports (contains, containsAny)
+ */
+function matchesNamedImports(node, namedImports) {
+    if (!ts_morph_1.Node.isImportDeclaration(node)) {
+        return false;
+    }
+    const importClause = node.getImportClause();
+    if (!importClause) {
+        return false;
+    }
+    const namedBindings = importClause.getNamedBindings();
+    if (!namedBindings || !ts_morph_1.Node.isNamedImports(namedBindings)) {
+        return false;
+    }
+    const importNames = namedBindings.getElements().map(el => el.getName());
+    if (namedImports.contains) {
+        return importNames.includes(namedImports.contains);
+    }
+    if (namedImports.containsAny) {
+        return namedImports.containsAny.some(name => importNames.includes(name));
+    }
+    return false;
+}

package/dist/src/core/ast/matchers/ts/index.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Index centralisé des matchers TypeScript AST
+ * Regroupe tous les matchers pour analyse de code TypeScript
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearContextCaches = exports.FileMatcher = exports.CollectionMatcher = exports.TypeMatcher = exports.ExpressionMatcher = exports.HierarchyMatcher = exports.DecoratorMatcher = exports.ImportMatcher = exports.ContextMatcher = exports.NodeMatcher = void 0;
+// Export all TypeScript matchers
+exports.NodeMatcher = __importStar(require("./node-matcher"));
+exports.ContextMatcher = __importStar(require("./context-matcher"));
+exports.ImportMatcher = __importStar(require("./import-matcher"));
+exports.DecoratorMatcher = __importStar(require("./decorator-matcher"));
+exports.HierarchyMatcher = __importStar(require("./hierarchy-matcher"));
+exports.ExpressionMatcher = __importStar(require("./expression-matcher"));
+exports.TypeMatcher = __importStar(require("./type-matcher"));
+exports.CollectionMatcher = __importStar(require("./collection-matcher"));
+exports.FileMatcher = __importStar(require("./file-matcher"));
+// Export clearContextCaches pour gestion mémoire
+var context_matcher_1 = require("./context-matcher");
+Object.defineProperty(exports, "clearContextCaches", { enumerable: true, get: function () { return context_matcher_1.clearContextCaches; } });