@esportsplus/typescript 0.29.6 → 0.31.0

package/README.md

@@ -72,13 +72,13 @@ export default defineConfig({
 tsc
 ```
 
-The CLI detects plugins in `tsconfig.json` `compilerOptions.plugins`, loads them, runs coordinated compilation, and automatically calls `tsc-alias` afterward.
+The CLI detects plugins in `tsconfig.json` `compilerOptions.plugins`, loads them, runs coordinated compilation, and automatically calls `tsc-alias` afterward. The package installs `tsc`/`tsc-alias` bins (also under the unambiguous `esportsplus-tsc`/`esportsplus-tsc-alias` names).
 
 ## API
 
 ### `@esportsplus/typescript`
 
-Re-exports the TypeScript compiler API (`ts`).
+No exports. Import the TypeScript compiler API directly from `typescript/unstable/*` (see [TypeScript 7 migration](#typescript-7-migration)).
 
 ### `@esportsplus/typescript/compiler`
 
@@ -90,7 +90,6 @@ Re-exports the TypeScript compiler API (`ts`).
 | `imports` | Import detection and modification (WeakMap cached) |
 | `plugin` | Built-in plugins (`tsc`, `vite`) |
 | `uid` | Unique identifier generation |
-| `languageService` | Cached TypeScript language service |
 
 ### Types
 
@@ -137,6 +136,15 @@ Importable base tsconfig files:
 { "extends": "@esportsplus/typescript/tsconfig.package.json" }
 ```
 
+## TypeScript 7 migration
+
+This package targets `typescript@^7`, shipped as a regular `dependencies` entry. Breaking changes for consumers:
+
+- **Root export removed.** `@esportsplus/typescript` no longer re-exports `ts`. Import the compiler API directly from the `typescript/unstable/*` subpaths you need — `typescript/unstable/ast`, `typescript/unstable/ast/is`, `typescript/unstable/sync`, `typescript/unstable/fs`, etc.
+- **Plugin-facing types.** `TransformContext` and `ReplacementIntent` now carry `typescript/unstable/ast` + `typescript/unstable/sync` identities instead of the classic `ts` namespace types.
+- **`coordinator.transform` signature.** Takes the `{ checker, program }` project pair instead of a single `ts.Program`.
+- **`imports.includes` signature.** Takes the API `Checker` type, and symbol declarations are represented as NodeHandles rather than `ts.Node`.
+
 ## Scripts
 
 ```bash

package/bin/tsc-alias

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 
-(await import ('@esportsplus/cli-passthrough')).default('tsc-alias');
+(await import ('@esportsplus/cli-passthrough')).default('tsc-alias');

package/build/cli/diagnostics.d.ts

@@ -0,0 +1,4 @@
+import { type Diagnostic } from 'typescript/unstable/sync';
+declare const flatten: (diagnostic: Diagnostic, indent?: number) => string;
+declare const format: (diagnostics: readonly Diagnostic[], root: string) => string;
+export { flatten, format };

package/build/cli/diagnostics.js

@@ -0,0 +1,90 @@
+import { readFileSync } from 'fs';
+import { computeLineStarts } from 'typescript/unstable/ast/scanner';
+import { DiagnosticCategory } from 'typescript/unstable/sync';
+import path from 'path';
+const ANSI_BLUE = '\x1b[94m';
+const ANSI_CYAN = '\x1b[96m';
+const ANSI_GREY = '\x1b[90m';
+const ANSI_RED = '\x1b[91m';
+const ANSI_RESET = '\x1b[0m';
+const ANSI_YELLOW = '\x1b[93m';
+const BACKSLASH_REGEX = /\\/g;
+const TRAILING_NEWLINE_REGEX = /\r?\n$/;
+function categoryColor(category) {
+    switch (category) {
+        case DiagnosticCategory.Error:
+            return ANSI_RED;
+        case DiagnosticCategory.Suggestion:
+            return ANSI_BLUE;
+        case DiagnosticCategory.Warning:
+            return ANSI_YELLOW;
+        default:
+            return ANSI_GREY;
+    }
+}
+function categoryLabel(category) {
+    switch (category) {
+        case DiagnosticCategory.Error:
+            return 'error';
+        case DiagnosticCategory.Suggestion:
+            return 'suggestion';
+        case DiagnosticCategory.Warning:
+            return 'warning';
+        default:
+            return 'message';
+    }
+}
+function formatOne(diagnostic, root) {
+    let category = categoryLabel(diagnostic.category), code = `${ANSI_GREY}TS${diagnostic.code}${ANSI_RESET}`, color = categoryColor(diagnostic.category), message = flatten(diagnostic);
+    if (diagnostic.fileName === undefined) {
+        return `${color}${category}${ANSI_RESET} ${code}: ${message}`;
+    }
+    let location = `${ANSI_CYAN}${path.relative(root, diagnostic.fileName).replace(BACKSLASH_REGEX, '/')}${ANSI_RESET}`, text = readSource(diagnostic.fileName);
+    if (text === undefined) {
+        return `${location} - ${color}${category}${ANSI_RESET} ${code}: ${message}`;
+    }
+    let lineStarts = computeLineStarts(text), line = lineOfPosition(lineStarts, diagnostic.pos), character = diagnostic.pos - lineStarts[line], lineEnd = line + 1 < lineStarts.length ? lineStarts[line + 1] : text.length, source = text.slice(lineStarts[line], lineEnd).replace(TRAILING_NEWLINE_REGEX, ''), width = Math.max(1, Math.min(diagnostic.end, lineEnd) - diagnostic.pos), underline = `${' '.repeat(character)}${color}${'~'.repeat(width)}${ANSI_RESET}`, header = `${location}:${ANSI_YELLOW}${line + 1}${ANSI_RESET}:${ANSI_YELLOW}${character + 1}${ANSI_RESET} - ${color}${category}${ANSI_RESET} ${code}: ${message}`;
+    return `${header}\n\n${source}\n${underline}`;
+}
+function lineOfPosition(lineStarts, position) {
+    let high = lineStarts.length - 1, low = 0;
+    while (low <= high) {
+        let middle = (low + high) >> 1;
+        if (lineStarts[middle] <= position) {
+            low = middle + 1;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return high < 0 ? 0 : high;
+}
+function readSource(fileName) {
+    try {
+        return readFileSync(fileName, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+const flatten = (diagnostic, indent = 0) => {
+    let result = '';
+    if (indent > 0) {
+        result += `\n${'  '.repeat(indent)}`;
+    }
+    result += diagnostic.text;
+    if (diagnostic.messageChain !== undefined) {
+        for (let i = 0, n = diagnostic.messageChain.length; i < n; i++) {
+            result += flatten(diagnostic.messageChain[i], indent + 1);
+        }
+    }
+    return result;
+};
+const format = (diagnostics, root) => {
+    let parts = [];
+    for (let i = 0, n = diagnostics.length; i < n; i++) {
+        parts.push(formatOne(diagnostics[i], root));
+    }
+    return parts.join('\n\n');
+};
+export { flatten, format };

package/build/cli/tsc.d.ts

@@ -1,10 +1,18 @@
 import type { Plugin } from '../compiler/types.js';
+import { API } from 'typescript/unstable/sync';
 type PluginConfig = {
     transform: string;
 };
-declare function build(config: object, tsconfig: string, pluginConfigs: PluginConfig[]): Promise<void>;
+declare function build(tsconfig: string, pluginConfigs: PluginConfig[], instance?: API, noEmit?: boolean): Promise<void>;
+declare function classifyFlags(args: string[]): {
+    informational: boolean;
+    noEmit: boolean;
+    watch: boolean;
+};
 declare function isPlugin(value: unknown): value is Plugin;
 declare function loadPlugins(configs: PluginConfig[], root: string): Promise<Plugin[]>;
+declare function main(): void;
 declare function normalizePath(fileName: string): string;
+declare function resolvePluginConfigs(tsconfig: string): PluginConfig[];
 declare function runTscAlias(args: string[]): Promise<number>;
-export { build, isPlugin, loadPlugins, normalizePath, runTscAlias };
+export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, resolvePluginConfigs, runTscAlias };

package/build/cli/tsc.js

@@ -1,59 +1,221 @@
+import { API, DiagnosticCategory } from 'typescript/unstable/sync';
 import { createRequire } from 'module';
+import { format } from './diagnostics.js';
 import { PACKAGE_NAME } from '../constants.js';
 import { pathToFileURL } from 'url';
 import { spawn } from 'child_process';
 import coordinator from '../compiler/coordinator.js';
+import fs from 'fs';
+import languageService from '../compiler/language-service.js';
 import path from 'path';
-import ts from 'typescript';
+import sourcemap from '../compiler/sourcemap.js';
 const BACKSLASH_REGEX = /\\/g;
+const INFORMATIONAL_FLAGS = new Set(['--help', '--init', '--showConfig', '--version', '-h', '-v']);
+const NO_EMIT_FLAGS = new Set(['--noEmit', '-noEmit']);
+const WATCH_FLAGS = new Set(['--watch', '-w']);
 let require = createRequire(import.meta.url), skipFlags = new Set(['--help', '--init', '--noEmit', '--showConfig', '--version', '-h', '-noEmit', '-v']);
-async function build(config, tsconfig, pluginConfigs) {
-    let root = path.dirname(path.resolve(tsconfig)), parsed = ts.parseJsonConfigFileContent(config, ts.sys, root);
-    if (parsed.errors.length > 0) {
-        for (let i = 0, n = parsed.errors.length; i < n; i++) {
-            console.error(ts.flattenDiagnosticMessageText(parsed.errors[i].messageText, '\n'));
-        }
+async function build(tsconfig, pluginConfigs, instance, noEmit = false) {
+    let root = path.dirname(path.resolve(tsconfig)), owned = instance === undefined, api = instance ?? new API({ cwd: root }), snapshot = api.updateSnapshot({ openProjects: [tsconfig] }), project = snapshot.getProject(tsconfig);
+    if (!project) {
+        teardown(snapshot, api, root, owned);
+        throw new Error(`${PACKAGE_NAME}: project not found for ${tsconfig}`);
+    }
+    let configDiagnostics = project.program.getConfigFileParsingDiagnostics();
+    if (configDiagnostics.some((diagnostic) => diagnostic.category === DiagnosticCategory.Error)) {
+        console.error(format(configDiagnostics, root));
+        teardown(snapshot, api, root, owned);
+        process.exit(1);
+    }
+    let { fileNames, options } = api.parseConfigFile(tsconfig), plugins, shared = new Map(), transformedFiles = new Map();
+    try {
+        plugins = await loadPlugins(pluginConfigs, root);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        teardown(snapshot, api, root, owned);
         process.exit(1);
     }
-    let plugins = await loadPlugins(pluginConfigs, root);
-    let program = ts.createProgram(parsed.fileNames, parsed.options), shared = new Map(), transformedFiles = new Map();
-    for (let i = 0, n = parsed.fileNames.length; i < n; i++) {
-        let fileName = parsed.fileNames[i], sourceFile = program.getSourceFile(fileName);
+    for (let i = 0, n = fileNames.length; i < n; i++) {
+        let fileName = fileNames[i], sourceFile = project.program.getSourceFile(fileName);
         if (!sourceFile) {
             continue;
         }
-        let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, program, root, shared);
+        let result = coordinator.transform(plugins, sourceFile.getFullText(), sourceFile, { checker: project.checker, program: project.program }, root, shared);
         if (result.changed) {
-            transformedFiles.set(normalizePath(fileName), result.code);
+            transformedFiles.set(normalizePath(fileName), { code: result.code, mapping: result.map });
         }
     }
-    if (transformedFiles.size > 0) {
-        let customHost = ts.createCompilerHost(parsed.options), originalGetSourceFile = customHost.getSourceFile.bind(customHost), originalReadFile = customHost.readFile.bind(customHost);
-        customHost.getSourceFile = (fileName, languageVersion, onError, shouldCreateNewSourceFile) => {
-            let transformed = transformedFiles.get(normalizePath(fileName));
-            if (transformed) {
-                return ts.createSourceFile(fileName, transformed, languageVersion, true);
-            }
-            return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-        };
-        customHost.readFile = (fileName) => {
-            return transformedFiles.get(normalizePath(fileName)) ?? originalReadFile(fileName);
-        };
-        program = ts.createProgram(parsed.fileNames, parsed.options, customHost);
+    let program = project.program;
+    for (let [fileName, entry] of transformedFiles) {
+        program = languageService.update(root, fileName, entry.code).program;
     }
-    let { diagnostics, emitSkipped } = program.emit();
-    diagnostics = ts.getPreEmitDiagnostics(program).concat(diagnostics);
+    let diagnostics = [
+        ...program.getConfigFileParsingDiagnostics(),
+        ...program.getSyntacticDiagnostics(),
+        ...program.getBindDiagnostics(),
+        ...program.getSemanticDiagnostics(),
+        ...program.getGlobalDiagnostics(),
+        ...program.getProgramDiagnostics()
+    ];
     if (diagnostics.length > 0) {
-        console.error(ts.formatDiagnosticsWithColorAndContext(diagnostics, {
-            getCanonicalFileName: (fileName) => fileName,
-            getCurrentDirectory: () => root,
-            getNewLine: () => '\n'
-        }));
+        console.error(format(diagnostics, root));
     }
-    if (emitSkipped) {
+    if (diagnostics.some((diagnostic) => diagnostic.category === DiagnosticCategory.Error)) {
+        teardown(snapshot, api, root, owned);
         process.exit(1);
     }
-    return runTscAlias(process.argv.slice(2)).then((code) => process.exit(code));
+    if (noEmit) {
+        teardown(snapshot, api, root, owned);
+        process.exit(0);
+    }
+    let code = await emit(tsconfig, fileNames, transformedFiles, root, options);
+    teardown(snapshot, api, root, owned);
+    if (code !== 0) {
+        process.exit(code);
+    }
+    return runTscAlias(process.argv.slice(2)).then((exitCode) => process.exit(exitCode));
+}
+function classifyFlags(args) {
+    let informational = false, noEmit = false, watch = false;
+    for (let i = 0, n = args.length; i < n; i++) {
+        let arg = args[i];
+        if (INFORMATIONAL_FLAGS.has(arg)) {
+            informational = true;
+        }
+        else if (NO_EMIT_FLAGS.has(arg)) {
+            noEmit = true;
+        }
+        else if (WATCH_FLAGS.has(arg)) {
+            watch = true;
+        }
+    }
+    return { informational, noEmit, watch };
+}
+function collectMaps(dir, results) {
+    for (let entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        let full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectMaps(full, results);
+        }
+        else if (entry.name.endsWith('.js.map')) {
+            results.push(full);
+        }
+    }
+}
+function composeSourceMaps(mirrorOut, mirror, root, transformedFiles) {
+    let maps = [];
+    collectMaps(mirrorOut, maps);
+    for (let i = 0, n = maps.length; i < n; i++) {
+        let mapPath = maps[i], raw;
+        try {
+            raw = JSON.parse(fs.readFileSync(mapPath, 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        if (!raw.sources || raw.sources.length === 0 || typeof raw.sources[0] !== 'string' || typeof raw.mappings !== 'string') {
+            continue;
+        }
+        let mirrorSource = path.resolve(path.dirname(mapPath), raw.sources[0]), relative = path.relative(mirror, mirrorSource), realSource = normalizePath(path.join(root, relative)), entry = transformedFiles.get(realSource);
+        if (!entry) {
+            continue;
+        }
+        let composed = sourcemap.composeEmittedMap({ mappings: raw.mappings, names: raw.names ?? [], sources: raw.sources, version: 3 }, entry.mapping, entry.code, fs.readFileSync(path.join(root, relative), 'utf8'));
+        if (raw.file !== undefined) {
+            composed.file = raw.file;
+        }
+        if (raw.sourceRoot !== undefined) {
+            composed.sourceRoot = raw.sourceRoot;
+        }
+        fs.writeFileSync(mapPath, JSON.stringify(composed));
+    }
+}
+async function emit(tsconfig, fileNames, transformedFiles, root, options) {
+    let tscJs = path.join(path.dirname(require.resolve('typescript/package.json')), 'lib', 'tsc.js');
+    if (transformedFiles.size === 0) {
+        return spawnTsc(tscJs, ['-p', tsconfig]);
+    }
+    let mirror = fs.mkdtempSync(path.join(root, '.esportsplus-tsc-'));
+    try {
+        let declaration = options.declaration === true, files = [], mirrorDecl = path.join(mirror, '__decl'), mirrorOut = path.join(mirror, '__emit'), realOutDir = typeof options.outDir === 'string' ? path.resolve(options.outDir) : root, realDeclDir = declaration
+            ? (typeof options.declarationDir === 'string' ? path.resolve(options.declarationDir) : realOutDir)
+            : undefined, realRootDir = typeof options.rootDir === 'string' ? path.resolve(options.rootDir) : undefined, separateDecl = realDeclDir !== undefined && normalizePath(realDeclDir) !== normalizePath(realOutDir);
+        for (let i = 0, n = fileNames.length; i < n; i++) {
+            let source = path.resolve(fileNames[i]), relative = path.relative(root, source);
+            if (relative.startsWith('..')) {
+                throw new Error(`${PACKAGE_NAME}: source ${normalizePath(source)} resolves outside the project root ${normalizePath(root)}; monorepo-external sources are not supported by the transform emit path`);
+            }
+            let target = path.join(mirror, relative), transformed = transformedFiles.get(normalizePath(fileNames[i]));
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            if (transformed === undefined) {
+                fs.copyFileSync(source, target);
+            }
+            else {
+                fs.writeFileSync(target, transformed.code);
+            }
+            files.push(normalizePath(target));
+        }
+        let compilerOptions = {
+            outDir: normalizePath(mirrorOut)
+        };
+        if (declaration) {
+            compilerOptions.declarationDir = normalizePath(separateDecl ? mirrorDecl : mirrorOut);
+        }
+        if (realRootDir !== undefined) {
+            compilerOptions.rootDir = normalizePath(path.join(mirror, path.relative(root, realRootDir)));
+        }
+        fs.writeFileSync(path.join(mirror, 'tsconfig.json'), JSON.stringify({
+            compilerOptions,
+            exclude: [],
+            extends: normalizePath(tsconfig),
+            files,
+            include: []
+        }));
+        let code = await spawnTsc(tscJs, ['-p', path.join(mirror, 'tsconfig.json')]);
+        if (code === 0) {
+            if (fs.existsSync(mirrorOut)) {
+                composeSourceMaps(mirrorOut, mirror, root, transformedFiles);
+                fs.cpSync(mirrorOut, realOutDir, { force: true, recursive: true });
+            }
+            if (separateDecl && realDeclDir !== undefined && fs.existsSync(mirrorDecl)) {
+                fs.cpSync(mirrorDecl, realDeclDir, { force: true, recursive: true });
+            }
+        }
+        return code;
+    }
+    finally {
+        fs.rmSync(mirror, { force: true, recursive: true });
+    }
+}
+function extendsTarget(specifier, fromDir) {
+    if (typeof specifier !== 'string') {
+        return null;
+    }
+    if (specifier.startsWith('.')) {
+        let resolved = path.resolve(fromDir, specifier);
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+            return resolved;
+        }
+        if (fs.existsSync(resolved + '.json')) {
+            return resolved + '.json';
+        }
+        let nested = path.join(resolved, 'tsconfig.json');
+        if (fs.existsSync(nested)) {
+            return nested;
+        }
+        return null;
+    }
+    try {
+        return require.resolve(specifier, { paths: [fromDir] });
+    }
+    catch {
+        try {
+            return require.resolve(specifier + '/tsconfig.json', { paths: [fromDir] });
+        }
+        catch {
+            return null;
+        }
+    }
 }
 function isPlugin(value) {
     return typeof value === 'object' && value !== null && 'transform' in value && typeof value.transform === 'function';
@@ -75,18 +237,15 @@ async function loadPlugins(configs, root) {
             }
             if (Array.isArray(plugin)) {
                 for (let j = 0, m = plugin.length; j < m; j++) {
-                    if (isPlugin(plugin[j])) {
-                        plugins.push(plugin[j]);
-                    }
-                    else {
-                        console.error(`${PACKAGE_NAME}: plugin ${config.transform}[${j}] uses an invalid plugin format`);
+                    if (!isPlugin(plugin[j])) {
+                        throw new Error(`${PACKAGE_NAME}: plugin ${config.transform}[${j}] uses an invalid plugin format, expected { transform: Function }`);
                     }
+                    plugins.push(plugin[j]);
                 }
                 return;
             }
             if (!isPlugin(plugin)) {
-                console.error(`${PACKAGE_NAME}: plugin ${config.transform} uses an invalid plugin format, expected { transform: Function } or Plugin[]`);
-                return;
+                throw new Error(`${PACKAGE_NAME}: plugin ${config.transform} uses an invalid plugin format, expected { transform: Function } or Plugin[]`);
             }
             plugins.push(plugin);
         }));
@@ -95,20 +254,25 @@ async function loadPlugins(configs, root) {
     return plugins;
 }
 function main() {
-    let tsconfig = ts.findConfigFile(process.cwd(), ts.sys.fileExists, 'tsconfig.json');
+    let tsconfig = languageService.findConfig(process.cwd());
     if (!tsconfig) {
         return passthrough();
     }
-    let { config, error } = ts.readConfigFile(tsconfig, ts.sys.readFile);
-    if (error) {
+    let pluginConfigs = resolvePluginConfigs(tsconfig);
+    if (pluginConfigs.length === 0) {
         return passthrough();
     }
-    let pluginConfigs = config?.compilerOptions?.plugins?.filter((p) => typeof p === 'object' && p !== null && 'transform' in p) ?? [];
-    if (pluginConfigs.length === 0) {
+    let flags = classifyFlags(process.argv.slice(2));
+    if (flags.informational) {
         return passthrough();
     }
+    if (flags.watch) {
+        console.error(`${PACKAGE_NAME}: --watch is not supported on the transformer plugin path; run a one-shot build or use real tsc directly`);
+        process.exit(1);
+        return;
+    }
     console.log(`${PACKAGE_NAME}: found ${pluginConfigs.length} transformer plugin(s), using coordinated build...`);
-    build(config, tsconfig, pluginConfigs).catch((err) => {
+    build(tsconfig, pluginConfigs, undefined, flags.noEmit).catch((err) => {
         console.error(`${PACKAGE_NAME}: ${err}`);
         process.exit(1);
     });
@@ -117,8 +281,8 @@ function normalizePath(fileName) {
     return path.resolve(fileName).replace(BACKSLASH_REGEX, '/');
 }
 function passthrough() {
-    let args = process.argv.slice(2);
-    spawn(process.execPath, [require.resolve('typescript/lib/tsc.js'), ...args], { stdio: 'inherit' })
+    let args = process.argv.slice(2), tsDir = path.dirname(require.resolve('typescript/package.json'));
+    spawn(process.execPath, [path.join(tsDir, 'lib', 'tsc.js'), ...args], { stdio: 'inherit' })
         .on('exit', async (code) => {
         if (code === 0) {
             code = await runTscAlias(args);
@@ -126,6 +290,44 @@ function passthrough() {
         process.exit(code ?? 0);
     });
 }
+function readPlugins(tsconfig, seen) {
+    let id = path.resolve(tsconfig);
+    if (seen.has(id)) {
+        return undefined;
+    }
+    seen.add(id);
+    let config;
+    try {
+        config = JSON.parse(stripJsonc(fs.readFileSync(id, 'utf8')));
+    }
+    catch {
+        return undefined;
+    }
+    let plugins;
+    if (config?.extends !== undefined) {
+        let bases = Array.isArray(config.extends) ? config.extends : [config.extends];
+        for (let i = 0, n = bases.length; i < n; i++) {
+            let target = extendsTarget(bases[i], path.dirname(id));
+            if (target) {
+                let inherited = readPlugins(target, seen);
+                if (inherited !== undefined) {
+                    plugins = inherited;
+                }
+            }
+        }
+    }
+    if (Array.isArray(config?.compilerOptions?.plugins)) {
+        plugins = config.compilerOptions.plugins;
+    }
+    return plugins;
+}
+function resolvePluginConfigs(tsconfig) {
+    let plugins = readPlugins(tsconfig, new Set());
+    if (!Array.isArray(plugins)) {
+        return [];
+    }
+    return plugins.filter((p) => typeof p === 'object' && p !== null && 'transform' in p);
+}
 function runTscAlias(args) {
     for (let i = 0, n = args.length; i < n; i++) {
         if (skipFlags.has(args[i])) {
@@ -137,7 +339,106 @@ function runTscAlias(args) {
         child.on('exit', (code) => resolve(code ?? 0));
     });
 }
+function spawnTsc(tscJs, args) {
+    return new Promise((resolve) => {
+        let child = spawn(process.execPath, [tscJs, ...args], { stdio: 'inherit' });
+        child.on('exit', (code) => resolve(code ?? 0));
+    });
+}
+function stripJsonc(text) {
+    let escaped = false, inBlockComment = false, inLineComment = false, inString = false, stripped = '';
+    for (let i = 0, n = text.length; i < n; i++) {
+        let char = text[i], next = text[i + 1];
+        if (inLineComment) {
+            if (char === '\n') {
+                inLineComment = false;
+                stripped += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === '*' && next === '/') {
+                inBlockComment = false;
+                i++;
+            }
+            continue;
+        }
+        if (inString) {
+            stripped += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            stripped += char;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            inLineComment = true;
+            i++;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            inBlockComment = true;
+            i++;
+            continue;
+        }
+        stripped += char;
+    }
+    escaped = false;
+    inString = false;
+    let result = '';
+    for (let i = 0, n = stripped.length; i < n; i++) {
+        let char = stripped[i];
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (char === ',') {
+            let j = i + 1;
+            while (j < n && (stripped[j] === ' ' || stripped[j] === '\n' || stripped[j] === '\r' || stripped[j] === '\t')) {
+                j++;
+            }
+            if (stripped[j] === ']' || stripped[j] === '}') {
+                continue;
+            }
+        }
+        result += char;
+    }
+    return result;
+}
+function teardown(snapshot, api, root, owned) {
+    if (!snapshot.isDisposed()) {
+        snapshot.dispose();
+    }
+    if (owned) {
+        api.close();
+    }
+    languageService.dispose(root);
+}
 if (process.env.VITEST === undefined) {
     main();
 }
-export { build, isPlugin, loadPlugins, normalizePath, runTscAlias };
+export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, resolvePluginConfigs, runTscAlias };

package/build/compiler/ast.d.ts

@@ -1,14 +1,16 @@
 import type { Range } from './types.js';
-import { ts } from '../index.js';
+import type { Expression, Node } from 'typescript/unstable/ast';
+declare const inRange: (ranges: Range[], start: number, end: number) => boolean;
+declare const test: (node: Node, fn: (n: Node) => boolean) => boolean;
 declare const _default: {
     expression: {
-        name: (node: ts.Expression) => string | null;
+        name: (node: Expression) => string | null;
     };
-    inRange: (ranges: Range[], start: number, end: number) => boolean;
+    inRange: typeof inRange;
     property: {
-        path: (node: ts.Expression) => string | null;
+        path: (node: Expression) => string | null;
     };
-    test: (node: ts.Node, fn: (n: ts.Node) => boolean) => boolean;
+    test: typeof test;
 };
 export default _default;
 export type { Range };