tinylint 0.1.0

package/chunks/index-CanivEwi.js

@@ -0,0 +1,1211 @@
+var RuleScope;
+(function (RuleScope) {
+    RuleScope[RuleScope["File"] = 1] = "File";
+    RuleScope[RuleScope["Project"] = 2] = "Project";
+})(RuleScope || (RuleScope = {}));
+var RuleTrigger;
+(function (RuleTrigger) {
+    RuleTrigger[RuleTrigger["Immediate"] = 1] = "Immediate";
+    RuleTrigger[RuleTrigger["Debounced"] = 2] = "Debounced";
+    RuleTrigger[RuleTrigger["Idle"] = 3] = "Idle";
+})(RuleTrigger || (RuleTrigger = {}));
+var LintPhase;
+(function (LintPhase) {
+    LintPhase[LintPhase["Immediate"] = 1] = "Immediate";
+    LintPhase[LintPhase["Debounced"] = 2] = "Debounced";
+    LintPhase[LintPhase["Idle"] = 3] = "Idle";
+    LintPhase[LintPhase["All"] = 4] = "All";
+})(LintPhase || (LintPhase = {}));
+var DiagnosticSeverity;
+(function (DiagnosticSeverity) {
+    DiagnosticSeverity[DiagnosticSeverity["Suggestion"] = 1] = "Suggestion";
+    DiagnosticSeverity[DiagnosticSeverity["Warning"] = 2] = "Warning";
+    DiagnosticSeverity[DiagnosticSeverity["Error"] = 3] = "Error";
+})(DiagnosticSeverity || (DiagnosticSeverity = {}));
+class RuleMeta {
+    constructor(ruleName, options) {
+        this.ruleName = ruleName;
+        this.defaultSeverity = options?.defaultSeverity ?? DiagnosticSeverity.Warning;
+        this.requiresTypeInfo = options?.requiresTypeInfo ?? true;
+        this.scope = options?.scope ?? RuleScope.File;
+        this.trigger = options?.trigger ?? RuleTrigger.Debounced;
+    }
+}
+
+function normalizePath(fileName, useCaseSensitive) {
+    let normalized = fileName;
+    const count = normalized.length;
+    for (let index = 0; index < count; index++) {
+        if (normalized.charCodeAt(index) === 92) {
+            normalized = replaceBackslashes(normalized);
+            break;
+        }
+    }
+    const prefixLength = getPrefixLength(normalized);
+    const prefix = prefixLength === 0 ? "" : normalized.slice(0, prefixLength);
+    const parts = [];
+    let segmentStart = prefixLength;
+    const segmentCount = normalized.length;
+    for (let index = prefixLength; index <= segmentCount; index++) {
+        if (index === segmentCount || normalized.charCodeAt(index) === 47) {
+            if (index > segmentStart) {
+                const segment = normalized.slice(segmentStart, index);
+                if (segment === ".") {
+                    segmentStart = index + 1;
+                    continue;
+                }
+                if (segment === "..") {
+                    if (parts.length > 0 && parts[parts.length - 1] !== "..") {
+                        parts.length -= 1;
+                    }
+                    else if (prefixLength === 0) {
+                        parts.push(segment);
+                    }
+                    segmentStart = index + 1;
+                    continue;
+                }
+                parts.push(segment);
+            }
+            segmentStart = index + 1;
+        }
+    }
+    let result = prefix;
+    const partCount = parts.length;
+    for (let index = 0; index < partCount; index++) {
+        if (result.length > 0 && result.charCodeAt(result.length - 1) !== 47) {
+            result += "/";
+        }
+        result += parts[index];
+    }
+    if (result.length === 0) {
+        result = ".";
+    }
+    return useCaseSensitive ? result : result.toLowerCase();
+}
+function joinPath(basePath, relativePath, useCaseSensitive) {
+    if (relativePath.length === 0) {
+        return normalizePath(basePath, useCaseSensitive);
+    }
+    if (isAbsolutePath(relativePath)) {
+        return normalizePath(relativePath, useCaseSensitive);
+    }
+    if (basePath.length === 0 || basePath === ".") {
+        return normalizePath(relativePath, useCaseSensitive);
+    }
+    return normalizePath(basePath + "/" + relativePath, useCaseSensitive);
+}
+function getDirectoryPath(fileName, useCaseSensitive) {
+    const normalized = normalizePath(fileName, useCaseSensitive);
+    for (let index = normalized.length - 1; index >= 0; index--) {
+        if (normalized.charCodeAt(index) === 47) {
+            if (index === 0) {
+                return "/";
+            }
+            return normalized.slice(0, index);
+        }
+    }
+    return ".";
+}
+function isRelativePath(value) {
+    if (value.length === 0) {
+        return false;
+    }
+    const code = value.charCodeAt(0);
+    return code === 46 || code === 47;
+}
+function getScriptKindFromFileName(tsApi, fileName) {
+    const length = fileName.length;
+    if (length >= 4) {
+        const tail4 = fileName.slice(length - 4).toLowerCase();
+        if (tail4 === ".tsx") {
+            return tsApi.ScriptKind.TSX;
+        }
+        if (tail4 === ".jsx") {
+            return tsApi.ScriptKind.JSX;
+        }
+        if (tail4 === ".mts") {
+            return tsApi.ScriptKind.TS;
+        }
+        if (tail4 === ".cts") {
+            return tsApi.ScriptKind.TS;
+        }
+    }
+    if (length >= 3) {
+        const tail3 = fileName.slice(length - 3).toLowerCase();
+        if (tail3 === ".ts") {
+            return tsApi.ScriptKind.TS;
+        }
+        if (tail3 === ".js") {
+            return tsApi.ScriptKind.JS;
+        }
+    }
+    if (length >= 5 && fileName.slice(length - 5).toLowerCase() === ".json") {
+        return tsApi.ScriptKind.JSON;
+    }
+    return tsApi.ScriptKind.Unknown;
+}
+function getExtensionForFileName(tsApi, fileName) {
+    const lower = fileName.toLowerCase();
+    if (lower.endsWith(".tsx")) {
+        return tsApi.Extension.Tsx;
+    }
+    if (lower.endsWith(".jsx")) {
+        return tsApi.Extension.Jsx;
+    }
+    if (lower.endsWith(".d.ts")) {
+        return tsApi.Extension.Dts;
+    }
+    if (lower.endsWith(".cts")) {
+        return tsApi.Extension.Cts;
+    }
+    if (lower.endsWith(".mts")) {
+        return tsApi.Extension.Mts;
+    }
+    return tsApi.Extension.Ts;
+}
+function useCaseSensitiveFileNames(tsApi, override) {
+    if (typeof override === "boolean") {
+        return override;
+    }
+    const sys = tsApi.sys;
+    if (sys !== undefined && typeof sys.useCaseSensitiveFileNames === "boolean") {
+        return sys.useCaseSensitiveFileNames;
+    }
+    return true;
+}
+function replaceBackslashes(value) {
+    let result = "";
+    const count = value.length;
+    for (let index = 0; index < count; index++) {
+        const code = value.charCodeAt(index);
+        result += code === 92 ? "/" : value.charAt(index);
+    }
+    return result;
+}
+function getPrefixLength(value) {
+    if (value.length === 0) {
+        return 0;
+    }
+    if (value.charCodeAt(0) === 47) {
+        return 1;
+    }
+    if (value.length > 1 && value.charCodeAt(1) === 58) {
+        if (value.length > 2 && value.charCodeAt(2) === 47) {
+            return 3;
+        }
+        return 2;
+    }
+    return 0;
+}
+function isAbsolutePath(value) {
+    if (value.length === 0) {
+        return false;
+    }
+    if (value.charCodeAt(0) === 47) {
+        return true;
+    }
+    return value.length > 1 && value.charCodeAt(1) === 58;
+}
+
+const EMPTY_DIAGNOSTICS = [];
+const EMPTY_SOURCE_FILES = [];
+function defineRule(rule) {
+    return rule;
+}
+function defineConfig(config) {
+    return config;
+}
+function lintWithProgram(options) {
+    const phase = normalizePhase(options.phase);
+    const compiledRules = compileRules(options.config);
+    const diagnostics = runProgramLint(options.typescript, options.program, compiledRules, phase, options.fileNames, options.changedFiles, options.currentFile, useCaseSensitiveFileNames(options.typescript, undefined));
+    return buildLintResult(diagnostics, phase, options.projectVersion);
+}
+function createLinter(options) {
+    if ("programProvider" in options) {
+        return new ProviderProgramLinter(options);
+    }
+    return new ManagedProgramLinter(options);
+}
+class ProviderProgramLinter {
+    constructor(options) {
+        this.aggregateCache = Object.create(null);
+        this.fileCache = Object.create(null);
+        this.projectCache = Object.create(null);
+        this.disposed = false;
+        this.compiledRules = compileRules(options.config);
+        this.getChangedFiles = options.getChangedFiles;
+        this.getCurrentFile = options.getCurrentFile;
+        this.getPhase = options.getPhase;
+        this.getProjectVersion = options.getProjectVersion;
+        this.programProvider = options.programProvider;
+        this.typescript = options.typescript;
+        this.useCaseSensitive = useCaseSensitiveFileNames(options.typescript, undefined);
+    }
+    dispose() {
+        this.disposed = true;
+        this.lastProgramSignature = undefined;
+        clearRecord(this.aggregateCache);
+        clearRecord(this.fileCache);
+        clearRecord(this.projectCache);
+    }
+    getProgram() {
+        if (this.disposed) {
+            return undefined;
+        }
+        return this.programProvider();
+    }
+    lint(request) {
+        const phase = normalizePhase(request?.phase ?? this.getPhase?.());
+        const projectVersion = this.getProjectVersion?.();
+        if (this.disposed) {
+            return buildLintResult(EMPTY_DIAGNOSTICS, phase, projectVersion);
+        }
+        const program = this.programProvider();
+        if (program === undefined) {
+            return buildLintResult(EMPTY_DIAGNOSTICS, phase, projectVersion);
+        }
+        const currentFile = request?.currentFile ?? this.getCurrentFile?.();
+        const changedFiles = request?.changedFiles ?? this.getChangedFiles?.();
+        const hasExplicitTargets = hasTargetRequest(request?.fileNames, currentFile, changedFiles, phase);
+        const aggregateKey = phase;
+        if (hasExplicitTargets) {
+            const targetFiles = resolveExplicitTargetFiles(program, request?.fileNames, currentFile, changedFiles, phase, this.useCaseSensitive);
+            const diagnostics = runFileSet(this.typescript, program, this.compiledRules, phase, targetFiles, false, this.fileCache);
+            return buildLintResult(diagnostics, phase, projectVersion);
+        }
+        if (hasExplicitTargets === false && projectVersion !== undefined) {
+            const aggregate = this.aggregateCache[aggregateKey];
+            if (aggregate !== undefined && aggregate.signature === projectVersion) {
+                return {
+                    diagnostics: aggregate.diagnostics,
+                    phase,
+                    projectVersion,
+                };
+            }
+        }
+        const sourceFiles = collectSourceFiles(program, this.useCaseSensitive);
+        const programSignature = createSourceFileSetSignature(sourceFiles, this.useCaseSensitive);
+        if (this.lastProgramSignature !== undefined && this.lastProgramSignature !== programSignature) {
+            this.clearCaches();
+        }
+        this.lastProgramSignature = programSignature;
+        const changedSet = createFileSet(changedFiles, this.useCaseSensitive);
+        const fileRulePlan = createFileRulePlan(this.compiledRules, phase);
+        const diagnostics = [];
+        const fileCount = sourceFiles.length;
+        for (let index = 0; index < fileCount; index++) {
+            const file = sourceFiles[index];
+            const cacheKey = createFileCacheKey(phase, file.fileName);
+            let fileDiagnostics = this.fileCache[cacheKey];
+            if (fileDiagnostics === undefined || changedSet === undefined || changedSet[normalizePath(file.fileName, this.useCaseSensitive)] === 1) {
+                const nextDiagnostics = [];
+                runFileRules(this.typescript, program, fileRulePlan, file, nextDiagnostics);
+                fileDiagnostics = nextDiagnostics;
+                this.fileCache[cacheKey] = fileDiagnostics;
+            }
+            pushDiagnostics(diagnostics, fileDiagnostics);
+        }
+        if (phase === LintPhase.All || phase === LintPhase.Idle) {
+            const projectKey = createProjectCacheKey(phase);
+            let projectDiagnostics = this.projectCache[projectKey];
+            if (projectDiagnostics === undefined || changedSet !== undefined) {
+                projectDiagnostics = runProjectRules(this.typescript, program, this.compiledRules, phase);
+                this.projectCache[projectKey] = projectDiagnostics;
+            }
+            pushDiagnostics(diagnostics, projectDiagnostics);
+        }
+        const readonlyDiagnostics = diagnostics;
+        if (projectVersion !== undefined) {
+            this.aggregateCache[aggregateKey] = {
+                diagnostics: readonlyDiagnostics,
+                signature: projectVersion,
+            };
+        }
+        return buildLintResult(readonlyDiagnostics, phase, projectVersion);
+    }
+    clearCaches() {
+        clearRecord(this.aggregateCache);
+        clearRecord(this.fileCache);
+        clearRecord(this.projectCache);
+    }
+}
+class ManagedProgramLinter {
+    constructor(options) {
+        this.aggregateCache = Object.create(null);
+        this.disposed = false;
+        this.fileCache = Object.create(null);
+        this.files = Object.create(null);
+        this.libContents = Object.create(null);
+        this.libSnapshots = Object.create(null);
+        this.projectVersion = 1;
+        this.projectRuleCache = Object.create(null);
+        this.compilerOptions = options.compilerOptions ?? {};
+        this.compiledRules = compileRules(options.config);
+        this.typescript = options.typescript;
+        this.useCaseSensitive = true;
+        this.currentDirectory = "/";
+        this.defaultLibFileName = "lib.d.ts";
+        this.languageService = this.createLanguageService();
+        this.resetProject(options);
+    }
+    dispose() {
+        if (this.disposed === false) {
+            this.disposed = true;
+            this.languageService.dispose();
+            this.clearState();
+        }
+    }
+    getProgram() {
+        if (this.disposed) {
+            return undefined;
+        }
+        return this.languageService.getProgram();
+    }
+    lint(request) {
+        const phase = normalizePhase(request?.phase);
+        const projectVersion = this.projectVersion;
+        if (this.disposed) {
+            return buildLintResult(EMPTY_DIAGNOSTICS, phase, projectVersion);
+        }
+        const program = this.languageService.getProgram();
+        if (program === undefined) {
+            return buildLintResult(EMPTY_DIAGNOSTICS, phase, projectVersion);
+        }
+        const aggregateKey = phase;
+        const hasExplicitTargets = hasTargetRequest(request?.fileNames, request?.currentFile, request?.changedFiles, phase);
+        if (hasExplicitTargets === false) {
+            const aggregate = this.aggregateCache[aggregateKey];
+            if (aggregate !== undefined && aggregate.signature === projectVersion) {
+                return {
+                    diagnostics: aggregate.diagnostics,
+                    phase,
+                    projectVersion,
+                };
+            }
+        }
+        const fileRulePlan = createFileRulePlan(this.compiledRules, phase);
+        if (hasExplicitTargets) {
+            const targetFiles = resolveExplicitTargetFiles(program, request?.fileNames, request?.currentFile, request?.changedFiles, phase, this.useCaseSensitive);
+            const diagnostics = this.runManagedFileSet(program, phase, targetFiles, fileRulePlan);
+            return buildLintResult(diagnostics, phase, projectVersion);
+        }
+        const sourceFiles = collectSourceFiles(program, this.useCaseSensitive);
+        const diagnostics = [];
+        const fileCount = sourceFiles.length;
+        for (let index = 0; index < fileCount; index++) {
+            const file = sourceFiles[index];
+            const fileVersion = this.getManagedFileVersion(file.fileName);
+            const cacheKey = createFileCacheKey(phase, file.fileName);
+            let cached = this.fileCache[cacheKey];
+            if (cached === undefined || cached.version !== fileVersion) {
+                const fileDiagnostics = this.runManagedFile(program, phase, file, fileRulePlan);
+                cached = {
+                    diagnostics: fileDiagnostics,
+                    version: fileVersion,
+                };
+                this.fileCache[cacheKey] = cached;
+            }
+            pushDiagnostics(diagnostics, cached.diagnostics);
+        }
+        if (phase === LintPhase.All || phase === LintPhase.Idle) {
+            const projectKey = createProjectCacheKey(phase);
+            let projectCache = this.projectRuleCache[projectKey];
+            if (projectCache === undefined || projectCache.signature !== projectVersion) {
+                projectCache = {
+                    diagnostics: runProjectRules(this.typescript, program, this.compiledRules, phase),
+                    signature: projectVersion,
+                };
+                this.projectRuleCache[projectKey] = projectCache;
+            }
+            pushDiagnostics(diagnostics, projectCache.diagnostics);
+        }
+        const readonlyDiagnostics = diagnostics;
+        this.aggregateCache[aggregateKey] = {
+            diagnostics: readonlyDiagnostics,
+            signature: projectVersion,
+        };
+        return buildLintResult(readonlyDiagnostics, phase, projectVersion);
+    }
+    resetProject(options) {
+        this.clearState();
+        this.useCaseSensitive = useCaseSensitiveFileNames(this.typescript, options.useCaseSensitiveFileNames);
+        this.compilerOptions = options.compilerOptions ?? {};
+        this.currentDirectory = normalizePath(options.currentDirectory ?? "/", this.useCaseSensitive);
+        this.defaultLibFileName = normalizePath(options.defaultLibFileName ?? getDefaultLibFileName(this.typescript, this.compilerOptions), this.useCaseSensitive);
+        if (options.libFiles !== undefined) {
+            for (const fileName in options.libFiles) {
+                if (Object.prototype.hasOwnProperty.call(options.libFiles, fileName)) {
+                    const normalized = normalizePath(fileName, this.useCaseSensitive);
+                    this.libContents[normalized] = options.libFiles[fileName];
+                }
+            }
+        }
+        for (const fileName in options.files) {
+            if (Object.prototype.hasOwnProperty.call(options.files, fileName)) {
+                this.setManagedFile(fileName, options.files[fileName], false);
+            }
+        }
+        this.projectVersion += 1;
+        this.languageService.dispose();
+        this.languageService = this.createLanguageService();
+    }
+    removeFile(fileName) {
+        const normalized = normalizePath(fileName, this.useCaseSensitive);
+        if (this.files[normalized] === undefined) {
+            return false;
+        }
+        delete this.files[normalized];
+        delete this.libContents[normalized];
+        delete this.libSnapshots[normalized];
+        deleteFileCacheEntries(this.fileCache, normalized);
+        this.fileNameList = undefined;
+        this.projectVersion += 1;
+        this.invalidateProjectCaches();
+        return true;
+    }
+    updateFile(fileName, content, kind) {
+        return this.setManagedFile(fileName, kind === undefined ? content : { content, kind }, true);
+    }
+    directoryExists(directoryName) {
+        const normalized = normalizePath(directoryName, this.useCaseSensitive);
+        const names = this.getScriptFileNames();
+        const count = names.length;
+        for (let index = 0; index < count; index++) {
+            if (isInDirectory(names[index], normalized)) {
+                return true;
+            }
+        }
+        for (const fileName in this.libContents) {
+            if (this.libContents[fileName] !== undefined && isInDirectory(fileName, normalized)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    fileExists(fileName) {
+        const normalized = normalizePath(fileName, this.useCaseSensitive);
+        if (this.files[normalized] !== undefined) {
+            return true;
+        }
+        if (this.libContents[normalized] !== undefined) {
+            return true;
+        }
+        const sys = this.typescript.sys;
+        if (sys === undefined || sys.fileExists === undefined) {
+            return false;
+        }
+        return sys.fileExists(fileName);
+    }
+    getManagedFileVersion(fileName) {
+        const normalized = normalizePath(fileName, this.useCaseSensitive);
+        const file = this.files[normalized];
+        if (file === undefined) {
+            return 0;
+        }
+        return file.version;
+    }
+    getScriptFileNames() {
+        if (this.fileNameList !== undefined) {
+            return this.fileNameList;
+        }
+        const names = [];
+        for (const fileName in this.files) {
+            if (this.files[fileName] !== undefined) {
+                names.push(fileName);
+            }
+        }
+        this.fileNameList = names;
+        return names;
+    }
+    getScriptKind(fileName) {
+        const normalized = normalizePath(fileName, this.useCaseSensitive);
+        const file = this.files[normalized];
+        if (file !== undefined) {
+            return file.kind;
+        }
+        return getScriptKindFromFileName(this.typescript, normalized);
+    }
+    getScriptSnapshot(fileName) {
+        const normalized = normalizePath(fileName, this.useCaseSensitive);
+        const file = this.files[normalized];
+        if (file !== undefined) {
+            if (file.snapshot === undefined) {
+                file.snapshot = this.typescript.ScriptSnapshot.fromString(file.content);
+            }
+            return file.snapshot;
+        }
+        const libText = this.readLibraryFile(normalized, fileName);
+        if (libText === undefined) {
+            return undefined;
+        }
+        let snapshot = this.libSnapshots[normalized];
+        if (snapshot === undefined) {
+            snapshot = this.typescript.ScriptSnapshot.fromString(libText);
+            this.libSnapshots[normalized] = snapshot;
+        }
+        return snapshot;
+    }
+    getScriptVersion(fileName) {
+        const normalized = normalizePath(fileName, this.useCaseSensitive);
+        const file = this.files[normalized];
+        if (file !== undefined) {
+            return String(file.version);
+        }
+        return "0";
+    }
+    readDirectory(rootDir, extensions) {
+        const normalizedRoot = normalizePath(rootDir, this.useCaseSensitive);
+        const result = [];
+        const files = this.getScriptFileNames();
+        const count = files.length;
+        for (let index = 0; index < count; index++) {
+            const fileName = files[index];
+            if (isInDirectory(fileName, normalizedRoot) && matchesExtension(fileName, extensions)) {
+                result.push(fileName);
+            }
+        }
+        return result;
+    }
+    readFile(fileName) {
+        const normalized = normalizePath(fileName, this.useCaseSensitive);
+        const file = this.files[normalized];
+        if (file !== undefined) {
+            return file.content;
+        }
+        return this.readLibraryFile(normalized, fileName);
+    }
+    readLibraryFile(normalizedFileName, originalFileName) {
+        const fromMemory = this.libContents[normalizedFileName];
+        if (fromMemory !== undefined) {
+            return fromMemory;
+        }
+        const sys = this.typescript.sys;
+        if (sys !== undefined && sys.readFile !== undefined) {
+            const text = sys.readFile(originalFileName);
+            if (text !== undefined) {
+                this.libContents[normalizedFileName] = text;
+                return text;
+            }
+        }
+        return undefined;
+    }
+    resolveModuleNames(moduleNames, containingFile) {
+        const resolved = [];
+        const count = moduleNames.length;
+        for (let index = 0; index < count; index++) {
+            const moduleName = moduleNames[index];
+            const local = this.resolveSingleModule(moduleName, containingFile);
+            if (local !== undefined) {
+                resolved.push(local);
+            }
+            else {
+                resolved.push(undefined);
+            }
+        }
+        return resolved;
+    }
+    resolveSingleModule(moduleName, containingFile) {
+        if (isRelativePath(moduleName)) {
+            const basePath = getDirectoryPath(containingFile, this.useCaseSensitive);
+            const resolvedFileName = resolveKnownFile(this.typescript, this.files, this.libContents, joinPath(basePath, moduleName, this.useCaseSensitive), this.useCaseSensitive);
+            if (resolvedFileName !== undefined) {
+                return {
+                    extension: getExtensionForFileName(this.typescript, resolvedFileName),
+                    isExternalLibraryImport: this.files[resolvedFileName] === undefined,
+                    resolvedFileName,
+                };
+            }
+        }
+        const sys = this.typescript.sys;
+        if (sys !== undefined && this.typescript.resolveModuleName !== undefined) {
+            const resolved = this.typescript.resolveModuleName(moduleName, containingFile, this.compilerOptions, sys);
+            if (resolved.resolvedModule !== undefined) {
+                return resolved.resolvedModule;
+            }
+        }
+        return undefined;
+    }
+    runManagedFile(program, phase, file, fileRulePlan) {
+        const diagnostics = [];
+        runFileRules(this.typescript, program, fileRulePlan, file, diagnostics);
+        const readonlyDiagnostics = diagnostics;
+        this.fileCache[createFileCacheKey(phase, file.fileName)] = {
+            diagnostics: readonlyDiagnostics,
+            version: this.getManagedFileVersion(file.fileName),
+        };
+        return readonlyDiagnostics;
+    }
+    runManagedFileSet(program, phase, files, fileRulePlan) {
+        const diagnostics = [];
+        const count = files.length;
+        for (let index = 0; index < count; index++) {
+            const file = files[index];
+            const fileVersion = this.getManagedFileVersion(file.fileName);
+            const cacheKey = createFileCacheKey(phase, file.fileName);
+            let cached = this.fileCache[cacheKey];
+            if (cached === undefined || cached.version !== fileVersion) {
+                const fileDiagnostics = this.runManagedFile(program, phase, file, fileRulePlan);
+                cached = {
+                    diagnostics: fileDiagnostics,
+                    version: fileVersion,
+                };
+                this.fileCache[cacheKey] = cached;
+            }
+            pushDiagnostics(diagnostics, cached.diagnostics);
+        }
+        if (phase === LintPhase.All || phase === LintPhase.Idle) {
+            pushDiagnostics(diagnostics, runProjectRules(this.typescript, program, this.compiledRules, phase));
+        }
+        return diagnostics;
+    }
+    setManagedFile(fileName, input, bumpProjectVersion) {
+        const normalized = normalizePath(fileName, this.useCaseSensitive);
+        const nextContent = typeof input === "string" ? input : input.content;
+        const nextKind = typeof input === "string"
+            ? getScriptKindFromFileName(this.typescript, normalized)
+            : (input.kind ?? getScriptKindFromFileName(this.typescript, normalized));
+        let file = this.files[normalized];
+        if (file === undefined) {
+            this.files[normalized] = {
+                content: nextContent,
+                fileName: normalized,
+                kind: nextKind,
+                snapshot: undefined,
+                version: 1,
+            };
+            this.fileNameList = undefined;
+            if (bumpProjectVersion) {
+                this.projectVersion += 1;
+                this.invalidateProjectCaches();
+            }
+            return true;
+        }
+        if (file.content === nextContent && file.kind === nextKind) {
+            return false;
+        }
+        file.content = nextContent;
+        file.kind = nextKind;
+        file.snapshot = undefined;
+        file.version += 1;
+        if (bumpProjectVersion) {
+            this.projectVersion += 1;
+            this.invalidateProjectCaches();
+        }
+        return true;
+    }
+    clearState() {
+        clearRecord(this.aggregateCache);
+        clearRecord(this.fileCache);
+        clearRecord(this.files);
+        clearRecord(this.libContents);
+        clearRecord(this.libSnapshots);
+        clearRecord(this.projectRuleCache);
+        this.fileNameList = undefined;
+    }
+    createLanguageService() {
+        const host = {
+            directoryExists: (directoryName) => this.directoryExists(directoryName),
+            fileExists: (fileName) => this.fileExists(fileName),
+            getCompilationSettings: () => this.compilerOptions,
+            getCurrentDirectory: () => this.currentDirectory,
+            getDefaultLibFileName: () => this.defaultLibFileName,
+            getProjectVersion: () => String(this.projectVersion),
+            getScriptFileNames: () => this.getScriptFileNames(),
+            getScriptKind: (fileName) => this.getScriptKind(fileName),
+            getScriptSnapshot: (fileName) => this.getScriptSnapshot(fileName),
+            getScriptVersion: (fileName) => this.getScriptVersion(fileName),
+            readDirectory: (rootDir, extensions) => this.readDirectory(rootDir, extensions),
+            readFile: (fileName) => this.readFile(fileName),
+            resolveModuleNames: (moduleNames, containingFile) => this.resolveModuleNames(moduleNames, containingFile),
+            useCaseSensitiveFileNames: () => this.useCaseSensitive,
+        };
+        return this.typescript.createLanguageService(host);
+    }
+    invalidateProjectCaches() {
+        clearRecord(this.aggregateCache);
+        clearRecord(this.projectRuleCache);
+    }
+}
+function compileRules(config) {
+    const result = [];
+    const rules = config.rules;
+    for (const ruleName in rules) {
+        if (Object.prototype.hasOwnProperty.call(rules, ruleName) === false) {
+            continue;
+        }
+        const value = rules[ruleName];
+        if (value === undefined || value === false) {
+            continue;
+        }
+        let definition;
+        let options;
+        if (Array.isArray(value)) {
+            definition = value[0];
+            options = value[1];
+        }
+        else {
+            definition = value;
+            options = undefined;
+        }
+        const meta = definition.meta;
+        result.push({
+            defaultSeverity: meta.defaultSeverity,
+            definition,
+            name: meta.ruleName.length === 0 ? ruleName : meta.ruleName,
+            options,
+            requiresTypeInfo: meta.requiresTypeInfo,
+            scope: meta.scope,
+            trigger: meta.trigger,
+        });
+    }
+    return result;
+}
+function createDiagnosticBuilder(diagnostic) {
+    return {
+        asError() {
+            diagnostic.severity = DiagnosticSeverity.Error;
+            return this;
+        },
+        asSuggestion() {
+            diagnostic.severity = DiagnosticSeverity.Suggestion;
+            return this;
+        },
+        asWarning() {
+            diagnostic.severity = DiagnosticSeverity.Warning;
+            return this;
+        },
+    };
+}
+function buildLintResult(diagnostics, phase, projectVersion) {
+    if (projectVersion === undefined) {
+        return {
+            diagnostics,
+            phase,
+        };
+    }
+    return {
+        diagnostics,
+        phase,
+        projectVersion,
+    };
+}
+function createFileCacheKey(phase, fileName) {
+    return phase + "|" + fileName;
+}
+function createFileReporter(file, rule, diagnostics) {
+    function report(nodeOrStart, lengthOrMessage, messageText) {
+        let start = 0;
+        let length = 0;
+        let message = "";
+        if (typeof nodeOrStart === "number") {
+            start = nodeOrStart;
+            length = lengthOrMessage;
+            message = messageText ?? "";
+        }
+        else {
+            start = nodeOrStart.getStart(file, false);
+            length = nodeOrStart.getEnd() - start;
+            message = lengthOrMessage;
+        }
+        const diagnostic = {
+            fileName: file.fileName,
+            length,
+            message,
+            phase: rule.trigger,
+            ruleName: rule.name,
+            severity: rule.defaultSeverity,
+            start,
+        };
+        diagnostics.push(diagnostic);
+        return createDiagnosticBuilder(diagnostic);
+    }
+    return report;
+}
+function createProjectCacheKey(phase) {
+    return "project|" + phase;
+}
+function createFileRulePlan(rules, phase) {
+    const activeRules = [];
+    let requiresChecker = false;
+    const ruleCount = rules.length;
+    for (let index = 0; index < ruleCount; index++) {
+        const rule = rules[index];
+        if (rule.scope === RuleScope.File && matchesPhase(rule.trigger, phase) && rule.definition.create) {
+            activeRules.push(rule);
+            requiresChecker = requiresChecker || rule.requiresTypeInfo;
+        }
+    }
+    if (activeRules.length === 0) {
+        return undefined;
+    }
+    return {
+        requiresChecker,
+        rules: activeRules,
+    };
+}
+function createSourceFileSetSignature(files, useCaseSensitive) {
+    const count = files.length;
+    if (count === 0) {
+        return "";
+    }
+    let result = normalizePath(files[0].fileName, useCaseSensitive);
+    if (count === 1) {
+        return result;
+    }
+    for (let index = 1; index < count; index++) {
+        result += "\n" + normalizePath(files[index].fileName, useCaseSensitive);
+    }
+    return result;
+}
+function createProjectReporter(rule, diagnostics) {
+    function report(file, start, length, message) {
+        const diagnostic = {
+            fileName: typeof file === "string" ? file : file.fileName,
+            length,
+            message,
+            phase: rule.trigger,
+            ruleName: rule.name,
+            severity: rule.defaultSeverity,
+            start,
+        };
+        diagnostics.push(diagnostic);
+        return createDiagnosticBuilder(diagnostic);
+    }
+    return report;
+}
+function createFileSet(fileNames, useCaseSensitive) {
+    if (fileNames === undefined || fileNames.length === 0) {
+        return undefined;
+    }
+    const result = Object.create(null);
+    const count = fileNames.length;
+    for (let index = 0; index < count; index++) {
+        result[normalizePath(fileNames[index], useCaseSensitive)] = 1;
+    }
+    return result;
+}
+function collectSourceFiles(program, useCaseSensitive) {
+    const files = program.getSourceFiles();
+    const lintable = [];
+    const count = files.length;
+    for (let index = 0; index < count; index++) {
+        const file = files[index];
+        if (file.isDeclarationFile === false) {
+            lintable.push(file);
+        }
+    }
+    return lintable;
+}
+function getDefaultLibFileName(tsApi, compilerOptions) {
+    if (compilerOptions.noLib === true) {
+        return "lib.d.ts";
+    }
+    if (tsApi.getDefaultLibFilePath !== undefined) {
+        try {
+            return tsApi.getDefaultLibFilePath(compilerOptions);
+        }
+        catch {
+            return "lib.d.ts";
+        }
+    }
+    return "lib.d.ts";
+}
+function hasTargetRequest(fileNames, currentFile, changedFiles, phase) {
+    if (fileNames !== undefined && fileNames.length > 0) {
+        return true;
+    }
+    if (phase === LintPhase.All || phase === LintPhase.Idle) {
+        return false;
+    }
+    if (currentFile !== undefined && currentFile.length > 0) {
+        return true;
+    }
+    return changedFiles !== undefined && changedFiles.length > 0;
+}
+function isInDirectory(fileName, directoryName) {
+    if (directoryName === "." || directoryName.length === 0) {
+        return true;
+    }
+    if (fileName === directoryName) {
+        return true;
+    }
+    if (fileName.length <= directoryName.length) {
+        return false;
+    }
+    return fileName.slice(0, directoryName.length) === directoryName && fileName.charCodeAt(directoryName.length) === 47;
+}
+function matchesExtension(fileName, extensions) {
+    if (extensions === undefined || extensions.length === 0) {
+        return true;
+    }
+    const count = extensions.length;
+    for (let index = 0; index < count; index++) {
+        if (fileName.endsWith(extensions[index])) {
+            return true;
+        }
+    }
+    return false;
+}
+function matchesPhase(trigger, phase) {
+    const phaseTrigger = toRuleTrigger(phase);
+    return phase === LintPhase.All || phaseTrigger === trigger;
+}
+function normalizePhase(phase) {
+    return phase ?? LintPhase.All;
+}
+function toRuleTrigger(phase) {
+    if (phase === LintPhase.All) {
+        return undefined;
+    }
+    return phase;
+}
+function pushDiagnostics(target, source) {
+    if (source === undefined || source.length === 0) {
+        return;
+    }
+    const count = source.length;
+    for (let index = 0; index < count; index++) {
+        target.push(source[index]);
+    }
+}
+function resolveKnownFile(tsApi, files, libContents, basePath, useCaseSensitive) {
+    const candidates = [
+        basePath,
+        basePath + ".ts",
+        basePath + ".tsx",
+        basePath + ".d.ts",
+        basePath + ".cts",
+        basePath + ".mts",
+        basePath + "/index.ts",
+        basePath + "/index.tsx",
+        basePath + "/index.d.ts",
+    ];
+    const count = candidates.length;
+    for (let index = 0; index < count; index++) {
+        const candidate = normalizePath(candidates[index], useCaseSensitive);
+        if (files[candidate] !== undefined || libContents[candidate] !== undefined) {
+            return candidate;
+        }
+        const sys = tsApi.sys;
+        if (sys !== undefined && sys.fileExists !== undefined && sys.fileExists(candidate)) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function resolveExplicitTargetFiles(program, fileNames, currentFile, changedFiles, phase, useCaseSensitive) {
+    if (fileNames !== undefined && fileNames.length > 0) {
+        return resolveRequestedProgramFiles(program, fileNames, useCaseSensitive);
+    }
+    if (phase !== LintPhase.All && phase !== LintPhase.Idle) {
+        if (currentFile !== undefined && currentFile.length > 0) {
+            return resolveRequestedProgramFile(program, currentFile, useCaseSensitive);
+        }
+        if (changedFiles !== undefined && changedFiles.length > 0) {
+            return resolveRequestedProgramFiles(program, changedFiles, useCaseSensitive);
+        }
+    }
+    return EMPTY_SOURCE_FILES;
+}
+function resolveRequestedProgramFile(program, fileName, useCaseSensitive) {
+    const exactFile = program.getSourceFile(fileName);
+    if (exactFile !== undefined && exactFile.isDeclarationFile === false) {
+        return [exactFile];
+    }
+    const normalized = normalizePath(fileName, useCaseSensitive);
+    const files = program.getSourceFiles();
+    const count = files.length;
+    for (let index = 0; index < count; index++) {
+        const file = files[index];
+        if (file.isDeclarationFile === false && normalizePath(file.fileName, useCaseSensitive) === normalized) {
+            return [file];
+        }
+    }
+    return EMPTY_SOURCE_FILES;
+}
+function resolveRequestedProgramFiles(program, fileNames, useCaseSensitive) {
+    if (fileNames.length === 1) {
+        return resolveRequestedProgramFile(program, fileNames[0], useCaseSensitive);
+    }
+    const requested = createFileSet(fileNames, useCaseSensitive);
+    if (requested === undefined) {
+        return EMPTY_SOURCE_FILES;
+    }
+    const result = [];
+    const files = program.getSourceFiles();
+    const count = files.length;
+    for (let index = 0; index < count; index++) {
+        const file = files[index];
+        if (file.isDeclarationFile === false && requested[normalizePath(file.fileName, useCaseSensitive)] === 1) {
+            result.push(file);
+        }
+    }
+    return result;
+}
+function runFileRules(tsApi, program, fileRulePlan, file, diagnostics) {
+    if (fileRulePlan === undefined) {
+        return;
+    }
+    const activeRules = fileRulePlan.rules;
+    const checker = fileRulePlan.requiresChecker ? program.getTypeChecker() : undefined;
+    const anyKindVisitors = [];
+    const buckets = [];
+    const activeRuleCount = activeRules.length;
+    for (let index = 0; index < activeRuleCount; index++) {
+        const rule = activeRules[index];
+        const report = createFileReporter(file, rule, diagnostics);
+        const context = {
+            checker: rule.requiresTypeInfo ? checker : undefined,
+            file,
+            options: rule.options,
+            phase: rule.trigger,
+            program,
+            report,
+            sourceText: file.text,
+            typescript: tsApi,
+        };
+        const visitor = rule.definition.create(context);
+        if (visitor !== undefined) {
+            const state = { rule, visitor };
+            const nodeKinds = rule.definition.nodeKinds;
+            if (nodeKinds === undefined || nodeKinds.length === 0) {
+                anyKindVisitors.push(state);
+            }
+            else {
+                const nodeKindCount = nodeKinds.length;
+                for (let kindIndex = 0; kindIndex < nodeKindCount; kindIndex++) {
+                    const kind = nodeKinds[kindIndex];
+                    let bucket = buckets[kind];
+                    if (bucket === undefined) {
+                        bucket = [];
+                        buckets[kind] = bucket;
+                    }
+                    bucket.push(state);
+                }
+            }
+        }
+    }
+    function visit(node) {
+        dispatchVisitors(node, true, anyKindVisitors, buckets);
+        tsApi.forEachChild(node, visit);
+        dispatchVisitors(node, false, anyKindVisitors, buckets);
+    }
+    visit(file);
+    const anyKindVisitorCount = anyKindVisitors.length;
+    for (let index = 0; index < anyKindVisitorCount; index++) {
+        anyKindVisitors[index].visitor.finish?.();
+    }
+    const bucketCount = buckets.length;
+    for (let index = 0; index < bucketCount; index++) {
+        const bucket = buckets[index];
+        if (bucket !== undefined) {
+            const visitorCount = bucket.length;
+            for (let bucketIndex = 0; bucketIndex < visitorCount; bucketIndex++) {
+                bucket[bucketIndex].visitor.finish?.();
+            }
+        }
+    }
+}
+function runFileSet(tsApi, program, rules, phase, files, includeProjectRules, fileCache) {
+    const diagnostics = [];
+    const fileRulePlan = createFileRulePlan(rules, phase);
+    const count = files.length;
+    for (let index = 0; index < count; index++) {
+        const file = files[index];
+        const fileDiagnostics = [];
+        runFileRules(tsApi, program, fileRulePlan, file, fileDiagnostics);
+        const readonlyFileDiagnostics = fileDiagnostics;
+        fileCache[createFileCacheKey(phase, file.fileName)] = readonlyFileDiagnostics;
+        pushDiagnostics(diagnostics, readonlyFileDiagnostics);
+    }
+    return diagnostics;
+}
+function runProgramLint(tsApi, program, rules, phase, fileNames, changedFiles, currentFile, useCaseSensitive, includeProjectRules) {
+    const explicitTargetFiles = resolveExplicitTargetFiles(program, fileNames, currentFile, changedFiles, phase, useCaseSensitive);
+    const targetFiles = explicitTargetFiles.length > 0 || hasTargetRequest(fileNames, currentFile, changedFiles, phase)
+        ? explicitTargetFiles
+        : collectSourceFiles(program);
+    const diagnostics = [];
+    const fileRulePlan = createFileRulePlan(rules, phase);
+    const count = targetFiles.length;
+    for (let index = 0; index < count; index++) {
+        runFileRules(tsApi, program, fileRulePlan, targetFiles[index], diagnostics);
+    }
+    return diagnostics;
+}
+function runProjectRules(tsApi, program, rules, phase) {
+    const diagnostics = [];
+    let requiresChecker = false;
+    let count = 0;
+    const ruleCount = rules.length;
+    for (let index = 0; index < ruleCount; index++) {
+        const rule = rules[index];
+        if (rule.scope === RuleScope.Project && matchesPhase(rule.trigger, phase) && rule.definition.createProject) {
+            requiresChecker = requiresChecker || rule.requiresTypeInfo;
+            count += 1;
+        }
+    }
+    if (count === 0) {
+        return EMPTY_DIAGNOSTICS;
+    }
+    const checker = requiresChecker ? program.getTypeChecker() : undefined;
+    for (let index = 0; index < ruleCount; index++) {
+        const rule = rules[index];
+        if (rule.scope === RuleScope.Project && matchesPhase(rule.trigger, phase) && rule.definition.createProject) {
+            rule.definition.createProject({
+                checker: rule.requiresTypeInfo ? checker : undefined,
+                options: rule.options,
+                phase: rule.trigger,
+                program,
+                report: createProjectReporter(rule, diagnostics),
+                typescript: tsApi,
+            });
+        }
+    }
+    return diagnostics;
+}
+function dispatchVisitors(node, entering, anyKindVisitors, buckets) {
+    const anyKindVisitorCount = anyKindVisitors.length;
+    for (let index = 0; index < anyKindVisitorCount; index++) {
+        const visitor = anyKindVisitors[index].visitor;
+        if (entering) {
+            visitor.enter?.(node);
+        }
+        else {
+            visitor.exit?.(node);
+        }
+    }
+    const bucket = buckets[node.kind];
+    if (bucket === undefined) {
+        return;
+    }
+    const count = bucket.length;
+    for (let index = 0; index < count; index++) {
+        const visitor = bucket[index].visitor;
+        if (entering) {
+            visitor.enter?.(node);
+        }
+        else {
+            visitor.exit?.(node);
+        }
+    }
+}
+function clearRecord(record) {
+    for (const key in record) {
+        if (Object.prototype.hasOwnProperty.call(record, key)) {
+            delete record[key];
+        }
+    }
+}
+function deleteFileCacheEntries(cache, fileName) {
+    const suffix = "|" + fileName;
+    for (const key in cache) {
+        if (Object.prototype.hasOwnProperty.call(cache, key) && key.endsWith(suffix)) {
+            delete cache[key];
+        }
+    }
+}
+
+export { DiagnosticSeverity as D, LintPhase as L, RuleMeta as R, RuleScope as a, RuleTrigger as b, createLinter as c, defineConfig as d, defineRule as e, getScriptKindFromFileName as g, lintWithProgram as l, normalizePath as n };
+//# sourceMappingURL=index-CanivEwi.js.map