@tsslint/core 1.0.14 → 1.0.16

package/index.d.ts

@@ -1,4 +1,6 @@
-import type { Config, ProjectContext } from '@tsslint/config';
+export * from './lib/build';
+export * from './lib/watch';
+import type { Config, ProjectContext } from '@tsslint/types';
 import type * as ts from 'typescript';
 export type Linter = ReturnType<typeof createLinter>;
 export declare function createLinter(ctx: ProjectContext, config: Config, withStack: boolean): {

package/index.js

@@ -1,8 +1,24 @@
 "use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createLinter = createLinter;
 exports.combineCodeFixes = combineCodeFixes;
 exports.applyTextChanges = applyTextChanges;
+__exportStar(require("./lib/build"), exports);
+__exportStar(require("./lib/watch"), exports);
 const ErrorStackParser = require("error-stack-parser");
 const path = require("path");
 const minimatch = require("minimatch");
@@ -29,15 +45,63 @@ function createLinter(ctx, config, withStack) {
     const fileRefactors = new Map();
     const sourceFiles = new Map();
     const plugins = (config.plugins ?? []).map(plugin => plugin(ctx));
+    const includes = [];
     const excludes = [];
-    for (let exclude of config.exclude ?? []) {
+    for (const include of config.include ?? []) {
+        const basePath = path.dirname(ctx.configFile);
+        includes.push([include, path.resolve(basePath, include)]);
+    }
+    for (const exclude of config.exclude ?? []) {
         const basePath = path.dirname(ctx.configFile);
-        excludes.push(path.resolve(basePath, exclude));
+        excludes.push([exclude, path.resolve(basePath, exclude)]);
     }
     return {
         lint(fileName) {
-            if (excludes.some(pattern => minimatch.minimatch(fileName, pattern))) {
-                return [];
+            let diagnostics = [];
+            let debugInfo;
+            if (config.debug) {
+                debugInfo = {
+                    category: ts.DiagnosticCategory.Message,
+                    code: 'debug',
+                    messageText: '- Config: ' + ctx.configFile + '\n',
+                    file: ctx.languageService.getProgram().getSourceFile(fileName),
+                    start: 0,
+                    length: 0,
+                    source: 'tsslint',
+                    relatedInformation: [],
+                };
+                diagnostics.push(debugInfo);
+            }
+            for (const [exclude, pattern] of excludes) {
+                if (minimatch.minimatch(fileName, pattern)) {
+                    if (debugInfo) {
+                        debugInfo.messageText += '- Included: ❌ (via ' + JSON.stringify({ exclude: [exclude] }) + ')\n';
+                    }
+                    return diagnostics;
+                }
+            }
+            if (includes.length) {
+                let included = false;
+                for (const [include, pattern] of includes) {
+                    if (minimatch.minimatch(fileName, pattern)) {
+                        included = true;
+                        if (debugInfo) {
+                            debugInfo.messageText += '- Included: ✅ (via ' + JSON.stringify({ include: [include] }) + ')\n';
+                        }
+                        break;
+                    }
+                }
+                if (!included) {
+                    if (debugInfo) {
+                        debugInfo.messageText += '- Included: ❌ (not included in any include patterns)\n';
+                    }
+                    return diagnostics;
+                }
+            }
+            else {
+                if (debugInfo) {
+                    debugInfo.messageText += '- Included: ✅ (no include patterns)\n';
+                }
             }
             const sourceFile = ctx.languageService.getProgram()?.getSourceFile(fileName);
             if (!sourceFile) {
@@ -54,21 +118,52 @@ function createLinter(ctx, config, withStack) {
             const rules = getFileRules(sourceFile.fileName);
             const fixes = getFileFixes(sourceFile.fileName);
             const refactors = getFileRefactors(sourceFile.fileName);
-            let diagnostics = [];
             let currentRuleId;
+            let currentIssues = 0;
+            let currentFixes = 0;
+            let currentRefactors = 0;
             fixes.clear();
             refactors.clear();
+            if (debugInfo) {
+                debugInfo.messageText += '- Rules:\n';
+            }
             for (const [id, rule] of Object.entries(rules)) {
                 if (token?.isCancellationRequested()) {
                     break;
                 }
                 currentRuleId = id;
+                currentIssues = 0;
+                currentFixes = 0;
+                currentRefactors = 0;
+                const start = Date.now();
                 try {
                     rule(rulesContext);
+                    if (debugInfo) {
+                        const time = Date.now() - start;
+                        debugInfo.messageText += `  - ${id}`;
+                        const details = [];
+                        if (currentIssues) {
+                            details.push(`${currentIssues} issues`);
+                        }
+                        if (currentFixes) {
+                            details.push(`${currentFixes} fixes`);
+                        }
+                        if (currentRefactors) {
+                            details.push(`${currentRefactors} refactors`);
+                        }
+                        if (time) {
+                            details.push(`${time}ms`);
+                        }
+                        if (details.length) {
+                            debugInfo.messageText += ` (${details.join(', ')})`;
+                        }
+                        debugInfo.messageText += '\n';
+                    }
                 }
                 catch (err) {
-                    console.error(`An unexpected error occurred in rule "${id}" in file ${sourceFile.fileName}.`);
-                    console.error(err);
+                    if (debugInfo) {
+                        debugInfo.messageText += `  - ${id} (❌ ${err && typeof err === 'object' && 'stack' in err ? err.stack : String(err)}})\n`;
+                    }
                 }
             }
             for (const plugin of plugins) {
@@ -128,6 +223,7 @@ function createLinter(ctx, config, withStack) {
                     }
                 }
                 diagnostics.push(error);
+                currentIssues++;
                 return {
                     withDeprecated() {
                         error.reportsDeprecated = true;
@@ -138,6 +234,7 @@ function createLinter(ctx, config, withStack) {
                         return this;
                     },
                     withFix(title, getEdits) {
+                        currentFixes++;
                         if (!fixes.has(currentRuleId)) {
                             fixes.set(currentRuleId, []);
                         }
@@ -151,6 +248,7 @@ function createLinter(ctx, config, withStack) {
                         return this;
                     },
                     withRefactor(title, getEdits) {
+                        currentRefactors++;
                         if (!refactors.has(currentRuleId)) {
                             refactors.set(currentRuleId, []);
                         }

package/lib/build.d.ts

@@ -0,0 +1,2 @@
+import type { Config } from '@tsslint/config';
+export declare function buildConfigFile(configFilePath: string, createHash?: (path: string) => string, logger?: Pick<typeof console, 'log' | 'warn' | 'error'>): Promise<Config>;

package/lib/build.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildConfigFile = buildConfigFile;
+const watch_1 = require("./watch");
+function buildConfigFile(configFilePath, createHash, logger) {
+    return new Promise((resolve, reject) => {
+        (0, watch_1.watchConfigFile)(configFilePath, (config, result) => {
+            if (config) {
+                resolve(config);
+            }
+            else {
+                reject(result);
+            }
+        }, false, createHash, logger);
+    });
+}
+//# sourceMappingURL=build.js.map

package/lib/linter.d.ts

@@ -0,0 +1,12 @@
+import type { Config, ProjectContext } from '@tsslint/types';
+import type * as ts from 'typescript';
+export type Linter = ReturnType<typeof createLinter>;
+export declare function createLinter(ctx: ProjectContext, config: Config, withStack: boolean): {
+    lint(fileName: string): ts.DiagnosticWithLocation[];
+    hasCodeFixes(fileName: string): boolean;
+    getCodeFixes(fileName: string, start: number, end: number, diagnostics?: ts.Diagnostic[]): ts.CodeFixAction[];
+    getRefactors(fileName: string, start: number, end: number): ts.RefactorActionInfo[];
+    getRefactorEdits(fileName: string, name: string): ts.FileTextChanges[] | undefined;
+};
+export declare function combineCodeFixes(fileName: string, fixes: ts.CodeFixAction[]): ts.TextChange[];
+export declare function applyTextChanges(baseSnapshot: ts.IScriptSnapshot, textChanges: ts.TextChange[]): ts.IScriptSnapshot;

package/lib/linter.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLinter = createLinter;
+exports.combineCodeFixes = combineCodeFixes;
+exports.applyTextChanges = applyTextChanges;
+const ErrorStackParser = require("error-stack-parser");
+const path = require("path");
+const minimatch = require("minimatch");
+function createLinter(ctx, config, withStack) {
+    if (withStack) {
+        require('source-map-support').install({
+            retrieveFile(path) {
+                // monkey-fix, refs: https://github.com/typescript-eslint/typescript-eslint/issues/9352
+                if (path.replace(/\\/g, '/').includes('/@typescript-eslint/eslint-plugin/dist/rules/') && path.endsWith('.js.map')) {
+                    return JSON.stringify({
+                        version: 3,
+                        sources: [],
+                        sourcesContent: [],
+                        mappings: '',
+                        names: [],
+                    });
+                }
+            },
+        });
+    }
+    const ts = ctx.typescript;
+    const fileRules = new Map();
+    const fileFixes = new Map();
+    const fileRefactors = new Map();
+    const sourceFiles = new Map();
+    const plugins = (config.plugins ?? []).map(plugin => plugin(ctx));
+    const excludes = [];
+    for (let exclude of config.exclude ?? []) {
+        const basePath = path.dirname(ctx.configFile);
+        excludes.push(path.resolve(basePath, exclude));
+    }
+    return {
+        lint(fileName) {
+            if (excludes.some(pattern => minimatch.minimatch(fileName, pattern))) {
+                return [];
+            }
+            const sourceFile = ctx.languageService.getProgram()?.getSourceFile(fileName);
+            if (!sourceFile) {
+                throw new Error(`No source file found for ${fileName}`);
+            }
+            const rulesContext = {
+                ...ctx,
+                sourceFile,
+                reportError,
+                reportWarning,
+                reportSuggestion,
+            };
+            const token = ctx.languageServiceHost.getCancellationToken?.();
+            const rules = getFileRules(sourceFile.fileName);
+            const fixes = getFileFixes(sourceFile.fileName);
+            const refactors = getFileRefactors(sourceFile.fileName);
+            let diagnostics = [];
+            let currentRuleId;
+            fixes.clear();
+            refactors.clear();
+            for (const [id, rule] of Object.entries(rules)) {
+                if (token?.isCancellationRequested()) {
+                    break;
+                }
+                currentRuleId = id;
+                try {
+                    rule(rulesContext);
+                }
+                catch (err) {
+                    diagnostics.push({
+                        category: ts.DiagnosticCategory.Error,
+                        code: id,
+                        messageText: String(err),
+                        file: sourceFile,
+                        start: 0,
+                        length: 0,
+                        source: 'tsslint',
+                        relatedInformation: [],
+                    });
+                }
+            }
+            for (const plugin of plugins) {
+                if (plugin.resolveDiagnostics) {
+                    diagnostics = plugin.resolveDiagnostics(sourceFile.fileName, diagnostics);
+                }
+            }
+            const diagnosticSet = new Set(diagnostics);
+            for (const [ruleId, fix] of [...fixes]) {
+                const final = fix.filter(fix => diagnosticSet.has(fix.diagnostic));
+                if (final.length) {
+                    fixes.set(ruleId, final);
+                }
+                else {
+                    fixes.delete(ruleId);
+                }
+            }
+            for (const [ruleId, refactor] of [...refactors]) {
+                const final = refactor.filter(fix => diagnosticSet.has(fix.diagnostic));
+                if (final.length) {
+                    refactors.set(ruleId, final);
+                }
+                else {
+                    refactors.delete(ruleId);
+                }
+            }
+            return diagnostics;
+            function reportError(message, start, end, traceOffset = 0) {
+                return report(ts.DiagnosticCategory.Error, message, start, end, traceOffset);
+            }
+            function reportWarning(message, start, end, traceOffset = 0) {
+                return report(ts.DiagnosticCategory.Warning, message, start, end, traceOffset);
+            }
+            function reportSuggestion(message, start, end, traceOffset = 0) {
+                return report(ts.DiagnosticCategory.Suggestion, message, start, end, traceOffset);
+            }
+            function report(category, message, start, end, traceOffset) {
+                const error = {
+                    category,
+                    code: currentRuleId,
+                    messageText: message,
+                    file: sourceFile,
+                    start,
+                    length: end - start,
+                    source: 'tsslint',
+                    relatedInformation: [],
+                };
+                if (withStack) {
+                    const stacks = traceOffset === false
+                        ? []
+                        : ErrorStackParser.parse(new Error());
+                    if (typeof traceOffset === 'number') {
+                        const baseOffset = 2 + traceOffset;
+                        if (stacks.length > baseOffset) {
+                            pushRelatedInformation(error, stacks[baseOffset]);
+                        }
+                    }
+                }
+                diagnostics.push(error);
+                return {
+                    withDeprecated() {
+                        error.reportsDeprecated = true;
+                        return this;
+                    },
+                    withUnnecessary() {
+                        error.reportsUnnecessary = true;
+                        return this;
+                    },
+                    withFix(title, getEdits) {
+                        if (!fixes.has(currentRuleId)) {
+                            fixes.set(currentRuleId, []);
+                        }
+                        fixes.get(currentRuleId).push(({
+                            diagnostic: error,
+                            title,
+                            start,
+                            end,
+                            getEdits,
+                        }));
+                        return this;
+                    },
+                    withRefactor(title, getEdits) {
+                        if (!refactors.has(currentRuleId)) {
+                            refactors.set(currentRuleId, []);
+                        }
+                        refactors.get(currentRuleId).push(({
+                            diagnostic: error,
+                            title,
+                            start,
+                            end,
+                            getEdits,
+                        }));
+                        return this;
+                    },
+                };
+            }
+            function pushRelatedInformation(error, stack) {
+                if (stack.fileName && stack.lineNumber !== undefined && stack.columnNumber !== undefined) {
+                    let fileName = stack.fileName.replace(/\\/g, '/');
+                    if (fileName.startsWith('file://')) {
+                        fileName = fileName.substring('file://'.length);
+                    }
+                    if (fileName.includes('http-url:')) {
+                        fileName = fileName.split('http-url:')[1];
+                    }
+                    if (!sourceFiles.has(fileName)) {
+                        const text = ctx.languageServiceHost.readFile(fileName) ?? '';
+                        sourceFiles.set(fileName, ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true));
+                    }
+                    const stackFile = sourceFiles.get(fileName);
+                    let pos = 0;
+                    try {
+                        pos = stackFile?.getPositionOfLineAndCharacter(stack.lineNumber - 1, stack.columnNumber - 1) ?? 0;
+                    }
+                    catch { }
+                    error.relatedInformation?.push({
+                        category: ts.DiagnosticCategory.Message,
+                        code: 0,
+                        file: stackFile,
+                        start: pos,
+                        length: 0,
+                        messageText: 'at ' + (stack.functionName ?? '<anonymous>'),
+                    });
+                }
+            }
+        },
+        hasCodeFixes(fileName) {
+            const fixesMap = getFileFixes(fileName);
+            for (const [_ruleId, fixes] of fixesMap) {
+                if (fixes.length) {
+                    return true;
+                }
+            }
+            return false;
+        },
+        getCodeFixes(fileName, start, end, diagnostics) {
+            const fixesMap = getFileFixes(fileName);
+            let result = [];
+            for (const [ruleId, fixes] of fixesMap) {
+                for (let i = 0; i < fixes.length; i++) {
+                    const fix = fixes[i];
+                    if (diagnostics?.length && !diagnostics.includes(fix.diagnostic)) {
+                        continue;
+                    }
+                    if ((fix.start >= start && fix.start <= end) ||
+                        (fix.end >= start && fix.end <= end) ||
+                        (start >= fix.start && start <= fix.end) ||
+                        (end >= fix.start && end <= fix.end)) {
+                        result.push({
+                            fixName: `tsslint:${ruleId}`,
+                            description: fix.title,
+                            changes: fix.getEdits(),
+                            fixId: 'tsslint',
+                            fixAllDescription: 'Fix all TSSLint errors'
+                        });
+                    }
+                }
+            }
+            for (const plugin of plugins) {
+                if (plugin.resolveCodeFixes) {
+                    result = plugin.resolveCodeFixes(fileName, result);
+                }
+            }
+            return result;
+        },
+        getRefactors(fileName, start, end) {
+            const refactorsMap = getFileRefactors(fileName);
+            let result = [];
+            for (const [ruleId, refactors] of refactorsMap) {
+                for (let i = 0; i < refactors.length; i++) {
+                    const refactor = refactors[i];
+                    if ((refactor.start >= start && refactor.start <= end) ||
+                        (refactor.end >= start && refactor.end <= end) ||
+                        (start >= refactor.start && start <= refactor.end) ||
+                        (end >= refactor.start && end <= refactor.end)) {
+                        result.push({
+                            name: `tsslint:${ruleId}:${i}`,
+                            description: refactor.title + ' (' + ruleId + ')',
+                            kind: 'quickfix',
+                        });
+                    }
+                }
+            }
+            return result;
+        },
+        getRefactorEdits(fileName, name) {
+            if (name.startsWith('tsslint:')) {
+                const [ruleId, index] = name.slice('tsslint:'.length).split(':');
+                const refactorsMap = getFileRefactors(fileName);
+                const refactor = refactorsMap.get(ruleId)?.[Number(index)];
+                if (refactor) {
+                    return refactor.getEdits();
+                }
+            }
+        },
+    };
+    function getFileRules(fileName) {
+        let rules = fileRules.get(fileName);
+        if (!rules) {
+            rules = { ...config.rules };
+            for (const plugin of plugins) {
+                if (plugin.resolveRules) {
+                    rules = plugin.resolveRules(fileName, rules);
+                }
+            }
+            fileRules.set(fileName, rules);
+        }
+        return rules;
+    }
+    function getFileFixes(fileName) {
+        if (!fileFixes.has(fileName)) {
+            fileFixes.set(fileName, new Map());
+        }
+        return fileFixes.get(fileName);
+    }
+    function getFileRefactors(fileName) {
+        if (!fileRefactors.has(fileName)) {
+            fileRefactors.set(fileName, new Map());
+        }
+        return fileRefactors.get(fileName);
+    }
+}
+function combineCodeFixes(fileName, fixes) {
+    const changes = fixes
+        .map(fix => fix.changes)
+        .flat()
+        .filter(change => change.fileName === fileName && change.textChanges.length)
+        .sort((a, b) => b.textChanges[0].span.start - a.textChanges[0].span.start);
+    let lastChangeAt = Number.MAX_VALUE;
+    let finalTextChanges = [];
+    for (const change of changes) {
+        const textChanges = [...change.textChanges].sort((a, b) => a.span.start - b.span.start);
+        const firstChange = textChanges[0];
+        const lastChange = textChanges[textChanges.length - 1];
+        if (lastChangeAt >= lastChange.span.start + lastChange.span.length) {
+            lastChangeAt = firstChange.span.start;
+            finalTextChanges = finalTextChanges.concat(textChanges);
+        }
+    }
+    return finalTextChanges;
+}
+function applyTextChanges(baseSnapshot, textChanges) {
+    textChanges = [...textChanges].sort((a, b) => b.span.start - a.span.start);
+    let text = baseSnapshot.getText(0, baseSnapshot.getLength());
+    for (const change of textChanges) {
+        text = text.slice(0, change.span.start) + change.newText + text.slice(change.span.start + change.span.length);
+    }
+    return {
+        getText(start, end) {
+            return text.substring(start, end);
+        },
+        getLength() {
+            return text.length;
+        },
+        getChangeRange(oldSnapshot) {
+            if (oldSnapshot === baseSnapshot) {
+                // TODO
+            }
+            return undefined;
+        },
+    };
+}
+//# sourceMappingURL=linter.js.map

package/lib/watch.d.ts

@@ -0,0 +1,14 @@
+import esbuild = require('esbuild');
+import type { Config } from '@tsslint/config';
+export declare function watchConfigFile(configFilePath: string, onBuild: (config: Config | undefined, result: esbuild.BuildResult) => void, watch?: boolean, createHash?: (path: string) => string, logger?: Pick<typeof console, 'log' | 'warn' | 'error'>): Promise<esbuild.BuildContext<{
+    entryPoints: string[];
+    bundle: true;
+    sourcemap: true;
+    outfile: string;
+    format: "esm";
+    platform: "node";
+    plugins: {
+        name: string;
+        setup(build: esbuild.PluginBuild): void;
+    }[];
+}>>;

package/lib/watch.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchConfigFile = watchConfigFile;
+const esbuild = require("esbuild");
+const _path = require("path");
+const fs = require("fs");
+async function watchConfigFile(configFilePath, onBuild, watch = true, createHash = btoa, logger = console) {
+    let start;
+    const outDir = _path.resolve(configFilePath, '..', 'node_modules', '.tsslint');
+    const outFileName = createHash(_path.relative(outDir, configFilePath)) + '.mjs';
+    const outFile = _path.join(outDir, outFileName);
+    const resultHandler = async (result) => {
+        let config;
+        if (!result.errors.length) {
+            try {
+                config = (await import(outFile + '?time=' + Date.now())).default;
+            }
+            catch (e) {
+                result.errors.push({ text: String(e) });
+            }
+        }
+        logger.log(`Built ${_path.relative(process.cwd(), configFilePath)} in ${Date.now() - start}ms`);
+        onBuild(config, result);
+    };
+    const cacheDir = _path.resolve(outDir, 'http_resources');
+    const cachePathToOriginalPath = new Map();
+    const ctx = await esbuild.context({
+        entryPoints: [configFilePath],
+        bundle: true,
+        sourcemap: true,
+        outfile: outFile,
+        format: 'esm',
+        platform: 'node',
+        plugins: [{
+                name: 'tsslint',
+                setup(build) {
+                    build.onStart(() => {
+                        start = Date.now();
+                    });
+                    build.onResolve({ filter: /^https?:\/\// }, ({ path }) => {
+                        const cachePath = _path.join(cacheDir, createHash(path));
+                        cachePathToOriginalPath.set(cachePath, path);
+                        return { path: cachePath, namespace: 'http-url' };
+                    });
+                    build.onResolve({ filter: /.*/ }, ({ path, resolveDir }) => {
+                        if (!path.endsWith('.ts')) {
+                            try {
+                                const maybeJsPath = require.resolve(path, { paths: [resolveDir] });
+                                if (!maybeJsPath.endsWith('.ts')) {
+                                    return {
+                                        path: maybeJsPath,
+                                        external: true,
+                                    };
+                                }
+                            }
+                            catch { }
+                        }
+                        return {};
+                    });
+                    build.onLoad({ filter: /.*/, namespace: 'http-url' }, async ({ path: cachePath }) => {
+                        const path = cachePathToOriginalPath.get(cachePath);
+                        if (fs.existsSync(cachePath)) {
+                            return {
+                                contents: fs.readFileSync(cachePath, 'utf8'),
+                                loader: 'ts',
+                            };
+                        }
+                        const response = await fetch(path);
+                        if (!response.ok) {
+                            throw new Error(`Failed to load ${path}`);
+                        }
+                        const text = await response.text();
+                        fs.mkdirSync(cacheDir, { recursive: true });
+                        fs.writeFileSync(cachePath, text, 'utf8');
+                        return {
+                            contents: text,
+                            loader: path.substring(path.lastIndexOf('.') + 1),
+                        };
+                    });
+                    if (watch) {
+                        build.onEnd(resultHandler);
+                    }
+                },
+            }],
+    });
+    if (watch) {
+        await ctx.watch();
+    }
+    else {
+        const result = await ctx.rebuild();
+        await ctx.dispose();
+        resultHandler(result);
+    }
+    return ctx;
+}
+//# sourceMappingURL=watch.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@tsslint/core",
-	"version": "1.0.14",
+	"version": "1.0.16",
 	"license": "MIT",
 	"files": [
 		"**/*.js",
@@ -12,12 +12,11 @@
 		"directory": "packages/core"
 	},
 	"dependencies": {
+		"@tsslint/types": "1.0.16",
 		"error-stack-parser": "^2.1.4",
+		"esbuild": "^0.23.0",
 		"minimatch": "^10.0.1",
 		"source-map-support": "^0.5.21"
 	},
-	"devDependencies": {
-		"@tsslint/config": "1.0.14"
-	},
-	"gitHead": "84ea99432b44827a79ac034896202652bf21c912"
+	"gitHead": "e430814fd394da5afbcd3157d02c246592162f75"
 }