@esportsplus/typescript 0.29.6 → 0.31.1

package/build/cli/tsc.js

@@ -1,59 +1,196 @@
+import { 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';
+import { analyze, analyzeProgram } from '../probe/kernel/analyze.js';
+import { formatDiagnostics } from '../probe/kernel/format.js';
+import { loadConfigFromTsconfig } from '../probe/kernel/config.js';
+import { stripJsonc } from '../jsonc.js';
+import { readPlugins } from '../tsconfig.js';
 const BACKSLASH_REGEX = /\\/g;
-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'));
-        }
+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([...INFORMATIONAL_FLAGS, ...NO_EMIT_FLAGS]);
+async function build(tsconfig, pluginConfigs, instance, noEmit = false) {
+    let opened = instance === undefined ? languageService.open(tsconfig) : undefined, root = path.dirname(path.resolve(tsconfig)), owned = instance === undefined, api = opened?.api ?? instance, snapshot = opened?.snapshot ?? api.updateSnapshot({ openProjects: [tsconfig] }), project = opened?.project ?? snapshot.getProject(tsconfig);
+    if (!project) {
+        teardown(snapshot, tsconfig, 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, tsconfig, 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);
+    let { fileNames, options } = api.parseConfigFile(tsconfig), plugins, shared = new Map(), transformedFiles = new Map();
+    runAnalyze(tsconfig, project.program, project.checker);
+    try {
+        plugins = await loadPlugins(pluginConfigs, root);
+    }
+    catch (error) {
+        console.error(error instanceof Error ? error.message : String(error));
+        teardown(snapshot, tsconfig, owned);
+        process.exit(1);
+    }
+    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, configPath: tsconfig, program: project.program }, root, shared);
         if (result.changed) {
-            transformedFiles.set(normalizePath(fileName), result.code);
+            transformedFiles.set(normalizePath(fileName), { code: result.code, mapping: result.map });
+        }
+    }
+    let program = transformedFiles.size === 0
+        ? project.program
+        : languageService.updateMany(tsconfig, new Map([...transformedFiles].map(([fileName, entry]) => [fileName, entry.code]))).program;
+    let diagnostics = [
+        ...program.getConfigFileParsingDiagnostics(),
+        ...program.getSyntacticDiagnostics(),
+        ...program.getBindDiagnostics(),
+        ...program.getSemanticDiagnostics(),
+        ...program.getGlobalDiagnostics(),
+        ...program.getProgramDiagnostics()
+    ];
+    if (diagnostics.length > 0) {
+        console.error(format(diagnostics, root, transformedFiles));
+    }
+    if (diagnostics.some((diagnostic) => diagnostic.category === DiagnosticCategory.Error)) {
+        teardown(snapshot, tsconfig, owned);
+        process.exit(1);
+    }
+    if (noEmit) {
+        teardown(snapshot, tsconfig, owned);
+        process.exit(0);
+    }
+    let code = await emit(tsconfig, fileNames, transformedFiles, root, options);
+    teardown(snapshot, tsconfig, 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]);
     }
-    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);
+    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`);
             }
-            return originalGetSourceFile(fileName, languageVersion, onError, shouldCreateNewSourceFile);
-        };
-        customHost.readFile = (fileName) => {
-            return transformedFiles.get(normalizePath(fileName)) ?? originalReadFile(fileName);
+            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)
         };
-        program = ts.createProgram(parsed.fileNames, parsed.options, customHost);
-    }
-    let { diagnostics, emitSkipped } = program.emit();
-    diagnostics = ts.getPreEmitDiagnostics(program).concat(diagnostics);
-    if (diagnostics.length > 0) {
-        console.error(ts.formatDiagnosticsWithColorAndContext(diagnostics, {
-            getCanonicalFileName: (fileName) => fileName,
-            getCurrentDirectory: () => root,
-            getNewLine: () => '\n'
+        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;
     }
-    if (emitSkipped) {
-        process.exit(1);
+    finally {
+        fs.rmSync(mirror, { force: true, recursive: true });
     }
-    return runTscAlias(process.argv.slice(2)).then((code) => process.exit(code));
 }
 function isPlugin(value) {
     return typeof value === 'object' && value !== null && 'transform' in value && typeof value.transform === 'function';
@@ -75,18 +212,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 +229,27 @@ async function loadPlugins(configs, root) {
     return plugins;
 }
 function main() {
-    let tsconfig = ts.findConfigFile(process.cwd(), ts.sys.fileExists, 'tsconfig.json');
+    let args = process.argv.slice(2), tsconfig = projectPath(args) ?? languageService.findConfig(process.cwd());
     if (!tsconfig) {
         return passthrough();
     }
-    let { config, error } = ts.readConfigFile(tsconfig, ts.sys.readFile);
-    if (error) {
+    let flags = classifyFlags(args);
+    let pluginConfigs = resolvePluginConfigs(tsconfig);
+    if (pluginConfigs.length === 0) {
+        if (!flags.informational && !flags.watch) {
+            runAnalyze(tsconfig);
+        }
         return passthrough();
     }
-    let pluginConfigs = config?.compilerOptions?.plugins?.filter((p) => typeof p === 'object' && p !== null && 'transform' in p) ?? [];
-    if (pluginConfigs.length === 0) {
+    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);
+    }
     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);
     });
@@ -116,9 +257,52 @@ function main() {
 function normalizePath(fileName) {
     return path.resolve(fileName).replace(BACKSLASH_REGEX, '/');
 }
+function projectPath(args) {
+    for (let i = 0, n = args.length; i < n; i++) {
+        let arg = args[i], value;
+        if (arg === '-p' || arg === '--project') {
+            value = args[i + 1];
+        }
+        else if (arg.startsWith('--project=')) {
+            value = arg.slice('--project='.length);
+        }
+        if (value !== undefined) {
+            let resolved = path.resolve(value);
+            return fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()
+                ? path.join(resolved, 'tsconfig.json')
+                : resolved;
+        }
+    }
+    return null;
+}
+function runAnalyze(tsconfig, program, checker) {
+    let config;
+    try {
+        config = loadConfigFromTsconfig(tsconfig);
+    }
+    catch (error) {
+        console.error(`${PACKAGE_NAME}: analyze config error: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (!config) {
+        return;
+    }
+    try {
+        let result = program && checker ? analyzeProgram(program, checker, config) : analyze(config);
+        if (result.diagnostics.length > 0) {
+            console.error(formatDiagnostics(result.diagnostics, config.projectRoot));
+            if (config.failOnFindings) {
+                process.exit(1);
+            }
+        }
+    }
+    catch (error) {
+        console.error(`${PACKAGE_NAME}: analyze failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 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 +310,13 @@ function passthrough() {
         process.exit(code ?? 0);
     });
 }
+function resolvePluginConfigs(tsconfig) {
+    let plugins = readPlugins(tsconfig);
+    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 +328,107 @@ 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 legacyStripJsonc(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;
+}
+void legacyStripJsonc;
+function teardown(snapshot, configPath, owned) {
+    if (owned) {
+        languageService.dispose(configPath);
+        return;
+    }
+    if (!snapshot.isDisposed()) {
+        snapshot.dispose();
+    }
+}
 if (process.env.VITEST === undefined) {
     main();
 }
-export { build, isPlugin, loadPlugins, normalizePath, runTscAlias };
+export { build, classifyFlags, isPlugin, loadPlugins, main, normalizePath, projectPath, resolvePluginConfigs, runTscAlias, stripJsonc };

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 };

package/build/compiler/ast.js

@@ -1,10 +1,10 @@
-import { ts } from '../index.js';
+import { isIdentifier, isPropertyAccessExpression } from 'typescript/unstable/ast/is';
 const expression = {
     name: (node) => {
-        if (ts.isIdentifier(node)) {
+        if (isIdentifier(node)) {
             return node.text;
         }
-        if (ts.isPropertyAccessExpression(node)) {
+        if (isPropertyAccessExpression(node)) {
             return property.path(node);
         }
         return null;
@@ -22,11 +22,11 @@ const inRange = (ranges, start, end) => {
 const property = {
     path: (node) => {
         let current = node, parts = [];
-        while (ts.isPropertyAccessExpression(current)) {
+        while (isPropertyAccessExpression(current)) {
             parts.push(current.name.text);
             current = current.expression;
         }
-        if (ts.isIdentifier(current)) {
+        if (isIdentifier(current)) {
             parts.push(current.text);
             return parts.reverse().join('.');
         }
@@ -37,6 +37,6 @@ const test = (node, fn) => {
     if (fn(node)) {
         return true;
     }
-    return !!ts.forEachChild(node, child => test(child, fn) || undefined);
+    return !!node.forEachChild(child => test(child, fn) || undefined);
 };
 export default { expression, inRange, property, test };

package/build/compiler/code.d.ts

@@ -1,5 +1,6 @@
-declare const code: {
-    (literals: TemplateStringsArray, ...values: unknown[]): string;
-    escape(str: string): string;
-};
+declare function code(literals: TemplateStringsArray, ...values: unknown[]): string;
+declare namespace code {
+    var _a: (str: string) => string;
+    export { _a as escape };
+}
 export default code;

package/build/compiler/code.js

@@ -1,3 +1,8 @@
+const BACKSLASH_REGEX = /\\/g;
+const CR_REGEX = /\r/g;
+const LINE_SEPARATOR_REGEX = /\u2028/g;
+const NEWLINE_REGEX = /\n/g;
+const PARAGRAPH_SEPARATOR_REGEX = /\u2029/g;
 const SINGLE_QUOTE_REGEX = /'/g;
 const code = (literals, ...values) => {
     let buffer = '';
@@ -12,6 +17,12 @@ const code = (literals, ...values) => {
     return buffer;
 };
 code.escape = (str) => {
-    return str.replace(SINGLE_QUOTE_REGEX, "\\'");
+    return str
+        .replace(BACKSLASH_REGEX, '\\\\')
+        .replace(SINGLE_QUOTE_REGEX, "\\'")
+        .replace(NEWLINE_REGEX, '\\n')
+        .replace(CR_REGEX, '\\r')
+        .replace(LINE_SEPARATOR_REGEX, '\\u2028')
+        .replace(PARAGRAPH_SEPARATOR_REGEX, '\\u2029');
 };
 export default code;

package/build/compiler/coordinator.d.ts

@@ -1,16 +1,25 @@
+import type { SourceFile } from 'typescript/unstable/ast';
+import type { Checker, Program } from 'typescript/unstable/sync';
 import type { Plugin, SharedContext } from './types.js';
-import { ts } from '../index.js';
+import type { OffsetAnchor, PositionMapping } from './sourcemap.js';
 type CoordinatorResult = {
     changed: boolean;
     code: string;
-    sourceFile: ts.SourceFile;
+    map: PositionMapping;
 };
-declare const _default: {
-    transform: (plugins: Plugin[], code: string, file: ts.SourceFile, program: ts.Program, root: string, shared: SharedContext) => {
-        changed: boolean;
-        code: string;
-        sourceFile: ts.SourceFile;
+declare const transform: (plugins: Plugin[], code: string, file: SourceFile, project: {
+    checker: Checker;
+    configPath?: string;
+    program: Program;
+}, root: string, shared: SharedContext) => {
+    changed: boolean;
+    code: string;
+    map: {
+        generations: OffsetAnchor[][];
     };
 };
+declare const _default: {
+    transform: typeof transform;
+};
 export default _default;
 export type { CoordinatorResult };