tsc-ts 0.0.4 → 0.0.6

package/dist/api/library/options.js

@@ -0,0 +1,308 @@
+// Compiler options of tsc-ts's public API and `tsc-ts --api`: tsc-ts's options as tsgo's API returns them,
+// and back.
+import { getLibFileName } from '../compiler/program-utilities.js';
+/** Compiler options as `tsc-ts --api` returns them: unset strings, enums and path mappings are undefined. */
+export function compilerOptionsOf(o) {
+    return {
+        allowJs: o.allowJs,
+        allowArbitraryExtensions: o.allowArbitraryExtensions,
+        allowImportingTsExtensions: o.allowImportingTsExtensions,
+        allowNonTsExtensions: o.allowNonTsExtensions,
+        allowUmdGlobalAccess: o.allowUmdGlobalAccess,
+        allowUnreachableCode: o.allowUnreachableCode,
+        allowUnusedLabels: o.allowUnusedLabels,
+        assumeChangesOnlyAffectDirectDependencies: o.assumeChangesOnlyAffectDirectDependencies,
+        checkJs: o.checkJs,
+        customConditions: o.customConditions,
+        composite: o.composite,
+        emitDeclarationOnly: o.emitDeclarationOnly,
+        emitBOM: o.emitBOM,
+        emitDecoratorMetadata: o.emitDecoratorMetadata,
+        declaration: o.declaration,
+        declarationDir: text(o.declarationDir),
+        declarationMap: o.declarationMap,
+        deduplicatePackages: o.deduplicatePackages,
+        disableSizeLimit: o.disableSizeLimit,
+        disableSourceOfProjectReferenceRedirect: o.disableSourceOfProjectReferenceRedirect,
+        disableSolutionSearching: o.disableSolutionSearching,
+        disableReferencedProjectLoad: o.disableReferencedProjectLoad,
+        erasableSyntaxOnly: o.erasableSyntaxOnly,
+        exactOptionalPropertyTypes: o.exactOptionalPropertyTypes,
+        experimentalDecorators: o.experimentalDecorators,
+        forceConsistentCasingInFileNames: o.forceConsistentCasingInFileNames,
+        isolatedModules: o.isolatedModules,
+        isolatedDeclarations: o.isolatedDeclarations,
+        ignoreConfig: o.ignoreConfig,
+        ignoreDeprecations: text(o.ignoreDeprecations),
+        importHelpers: o.importHelpers,
+        inlineSourceMap: o.inlineSourceMap,
+        inlineSources: o.inlineSources,
+        init: o.init,
+        incremental: o.incremental,
+        jsx: enumValue(o.jsx),
+        jsxFactory: text(o.jsxFactory),
+        jsxFragmentFactory: text(o.jsxFragmentFactory),
+        jsxImportSource: text(o.jsxImportSource),
+        lib: o.lib,
+        libReplacement: o.libReplacement,
+        locale: text(o.locale),
+        mapRoot: text(o.mapRoot),
+        module: enumValue(o.module),
+        moduleResolution: enumValue(o.moduleResolution),
+        moduleSuffixes: o.moduleSuffixes,
+        moduleDetection: enumValue(o.moduleDetection),
+        newLine: enumValue(o.newLine),
+        noEmit: o.noEmit,
+        noCheck: o.noCheck,
+        noErrorTruncation: o.noErrorTruncation,
+        noFallthroughCasesInSwitch: o.noFallthroughCasesInSwitch,
+        noImplicitAny: o.noImplicitAny,
+        noImplicitThis: o.noImplicitThis,
+        noImplicitReturns: o.noImplicitReturns,
+        noEmitHelpers: o.noEmitHelpers,
+        noLib: o.noLib,
+        noPropertyAccessFromIndexSignature: o.noPropertyAccessFromIndexSignature,
+        noUncheckedIndexedAccess: o.noUncheckedIndexedAccess,
+        noEmitOnError: o.noEmitOnError,
+        noUnusedLocals: o.noUnusedLocals,
+        noUnusedParameters: o.noUnusedParameters,
+        noResolve: o.noResolve,
+        noImplicitOverride: o.noImplicitOverride,
+        noUncheckedSideEffectImports: o.noUncheckedSideEffectImports,
+        outDir: text(o.outDir),
+        paths: pathMappings(o.paths),
+        preserveConstEnums: o.preserveConstEnums,
+        preserveSymlinks: o.preserveSymlinks,
+        project: text(o.project),
+        resolveJsonModule: o.resolveJsonModule,
+        resolvePackageJsonExports: o.resolvePackageJsonExports,
+        resolvePackageJsonImports: o.resolvePackageJsonImports,
+        removeComments: o.removeComments,
+        rewriteRelativeImportExtensions: o.rewriteRelativeImportExtensions,
+        reactNamespace: text(o.reactNamespace),
+        rootDir: text(o.rootDir),
+        rootDirs: o.rootDirs,
+        skipLibCheck: o.skipLibCheck,
+        stableTypeOrdering: o.stableTypeOrdering,
+        strict: o.strict,
+        strictBindCallApply: o.strictBindCallApply,
+        strictBuiltinIteratorReturn: o.strictBuiltinIteratorReturn,
+        strictFunctionTypes: o.strictFunctionTypes,
+        strictNullChecks: o.strictNullChecks,
+        strictPropertyInitialization: o.strictPropertyInitialization,
+        stripInternal: o.stripInternal,
+        skipDefaultLibCheck: o.skipDefaultLibCheck,
+        sourceMap: o.sourceMap,
+        sourceRoot: text(o.sourceRoot),
+        suppressOutputPathCheck: o.suppressOutputPathCheck,
+        target: enumValue(o.target),
+        traceResolution: o.traceResolution,
+        tsBuildInfoFile: text(o.tsBuildInfoFile),
+        typeRoots: o.typeRoots,
+        types: o.types,
+        useDefineForClassFields: o.useDefineForClassFields,
+        useUnknownInCatchVariables: o.useUnknownInCatchVariables,
+        verbatimModuleSyntax: o.verbatimModuleSyntax,
+        maxNodeModuleJsDepth: o.maxNodeModuleJsDepth,
+        allowSyntheticDefaultImports: o.allowSyntheticDefaultImports,
+        alwaysStrict: o.alwaysStrict,
+        baseUrl: text(o.baseUrl),
+        downlevelIteration: o.downlevelIteration,
+        esModuleInterop: o.esModuleInterop,
+        outFile: text(o.outFile),
+        configFilePath: text(o.configFilePath),
+        noDtsResolution: o.noDtsResolution,
+        pathsBasePath: text(o.pathsBasePath),
+        diagnostics: o.diagnostics,
+        extendedDiagnostics: o.extendedDiagnostics,
+        generateCpuProfile: text(o.generateCpuProfile),
+        generateTrace: text(o.generateTrace),
+        listEmittedFiles: o.listEmittedFiles,
+        listFiles: o.listFiles,
+        explainFiles: o.explainFiles,
+        listFilesOnly: o.listFilesOnly,
+        noEmitForJsFiles: o.noEmitForJsFiles,
+        preserveWatchOutput: o.preserveWatchOutput,
+        pretty: o.pretty,
+        version: o.version,
+        watch: o.watch,
+        showConfig: o.showConfig,
+        build: o.build,
+        help: o.help,
+        all: o.all,
+        pprofDir: text(o.pprofDir),
+        singleThreaded: o.singleThreaded,
+        quiet: o.quiet,
+        checkers: o.checkers,
+    };
+}
+function text(value) {
+    return value === '' ? undefined : value;
+}
+function enumValue(value) {
+    return value === 0 ? undefined : value;
+}
+function pathMappings(paths) {
+    if (paths === undefined)
+        return undefined;
+    const mappings = {};
+    for (const [pattern, substitutions] of paths)
+        mappings[pattern] = substitutions ?? [];
+    return mappings;
+}
+/**
+ * tsc-ts's compiler options for options in the form tsgo's API returns them (`compilerOptionsOf`). `lib`
+ * may name libraries as in tsconfig.json (`es2025`) or by file name (`lib.es2025.d.ts`).
+ */
+export function compilerOptionsFromApi(o) {
+    return {
+        allowJs: o.allowJs,
+        allowArbitraryExtensions: o.allowArbitraryExtensions,
+        allowImportingTsExtensions: o.allowImportingTsExtensions,
+        allowNonTsExtensions: o.allowNonTsExtensions,
+        allowUmdGlobalAccess: o.allowUmdGlobalAccess,
+        allowUnreachableCode: o.allowUnreachableCode,
+        allowUnusedLabels: o.allowUnusedLabels,
+        assumeChangesOnlyAffectDirectDependencies: o.assumeChangesOnlyAffectDirectDependencies,
+        checkJs: o.checkJs,
+        customConditions: o.customConditions,
+        composite: o.composite,
+        emitDeclarationOnly: o.emitDeclarationOnly,
+        emitBOM: o.emitBOM,
+        emitDecoratorMetadata: o.emitDecoratorMetadata,
+        declaration: o.declaration,
+        declarationDir: o.declarationDir,
+        declarationMap: o.declarationMap,
+        deduplicatePackages: o.deduplicatePackages,
+        disableSizeLimit: o.disableSizeLimit,
+        disableSourceOfProjectReferenceRedirect: o.disableSourceOfProjectReferenceRedirect,
+        disableSolutionSearching: o.disableSolutionSearching,
+        disableReferencedProjectLoad: o.disableReferencedProjectLoad,
+        erasableSyntaxOnly: o.erasableSyntaxOnly,
+        exactOptionalPropertyTypes: o.exactOptionalPropertyTypes,
+        experimentalDecorators: o.experimentalDecorators,
+        forceConsistentCasingInFileNames: o.forceConsistentCasingInFileNames,
+        isolatedModules: o.isolatedModules,
+        isolatedDeclarations: o.isolatedDeclarations,
+        ignoreConfig: o.ignoreConfig,
+        ignoreDeprecations: o.ignoreDeprecations,
+        importHelpers: o.importHelpers,
+        inlineSourceMap: o.inlineSourceMap,
+        inlineSources: o.inlineSources,
+        init: o.init,
+        incremental: o.incremental,
+        jsx: o.jsx,
+        jsxFactory: o.jsxFactory,
+        jsxFragmentFactory: o.jsxFragmentFactory,
+        jsxImportSource: o.jsxImportSource,
+        lib: libFileNames(o.lib),
+        libReplacement: o.libReplacement,
+        locale: o.locale,
+        mapRoot: o.mapRoot,
+        module: o.module,
+        moduleResolution: o.moduleResolution,
+        moduleSuffixes: o.moduleSuffixes,
+        moduleDetection: o.moduleDetection,
+        newLine: o.newLine,
+        noEmit: o.noEmit,
+        noCheck: o.noCheck,
+        noErrorTruncation: o.noErrorTruncation,
+        noFallthroughCasesInSwitch: o.noFallthroughCasesInSwitch,
+        noImplicitAny: o.noImplicitAny,
+        noImplicitThis: o.noImplicitThis,
+        noImplicitReturns: o.noImplicitReturns,
+        noEmitHelpers: o.noEmitHelpers,
+        noLib: o.noLib,
+        noPropertyAccessFromIndexSignature: o.noPropertyAccessFromIndexSignature,
+        noUncheckedIndexedAccess: o.noUncheckedIndexedAccess,
+        noEmitOnError: o.noEmitOnError,
+        noUnusedLocals: o.noUnusedLocals,
+        noUnusedParameters: o.noUnusedParameters,
+        noResolve: o.noResolve,
+        noImplicitOverride: o.noImplicitOverride,
+        noUncheckedSideEffectImports: o.noUncheckedSideEffectImports,
+        outDir: o.outDir,
+        paths: pathMap(o.paths),
+        preserveConstEnums: o.preserveConstEnums,
+        preserveSymlinks: o.preserveSymlinks,
+        project: o.project,
+        resolveJsonModule: o.resolveJsonModule,
+        resolvePackageJsonExports: o.resolvePackageJsonExports,
+        resolvePackageJsonImports: o.resolvePackageJsonImports,
+        removeComments: o.removeComments,
+        rewriteRelativeImportExtensions: o.rewriteRelativeImportExtensions,
+        reactNamespace: o.reactNamespace,
+        rootDir: o.rootDir,
+        rootDirs: o.rootDirs,
+        skipLibCheck: o.skipLibCheck,
+        stableTypeOrdering: o.stableTypeOrdering,
+        strict: o.strict,
+        strictBindCallApply: o.strictBindCallApply,
+        strictBuiltinIteratorReturn: o.strictBuiltinIteratorReturn,
+        strictFunctionTypes: o.strictFunctionTypes,
+        strictNullChecks: o.strictNullChecks,
+        strictPropertyInitialization: o.strictPropertyInitialization,
+        stripInternal: o.stripInternal,
+        skipDefaultLibCheck: o.skipDefaultLibCheck,
+        sourceMap: o.sourceMap,
+        sourceRoot: o.sourceRoot,
+        suppressOutputPathCheck: o.suppressOutputPathCheck,
+        target: o.target,
+        traceResolution: o.traceResolution,
+        tsBuildInfoFile: o.tsBuildInfoFile,
+        typeRoots: o.typeRoots,
+        types: o.types,
+        useDefineForClassFields: o.useDefineForClassFields,
+        useUnknownInCatchVariables: o.useUnknownInCatchVariables,
+        verbatimModuleSyntax: o.verbatimModuleSyntax,
+        maxNodeModuleJsDepth: o.maxNodeModuleJsDepth,
+        allowSyntheticDefaultImports: o.allowSyntheticDefaultImports,
+        alwaysStrict: o.alwaysStrict,
+        baseUrl: o.baseUrl,
+        downlevelIteration: o.downlevelIteration,
+        esModuleInterop: o.esModuleInterop,
+        outFile: o.outFile,
+        configFilePath: o.configFilePath,
+        noDtsResolution: o.noDtsResolution,
+        pathsBasePath: o.pathsBasePath,
+        diagnostics: o.diagnostics,
+        extendedDiagnostics: o.extendedDiagnostics,
+        generateCpuProfile: o.generateCpuProfile,
+        generateTrace: o.generateTrace,
+        listEmittedFiles: o.listEmittedFiles,
+        listFiles: o.listFiles,
+        explainFiles: o.explainFiles,
+        listFilesOnly: o.listFilesOnly,
+        noEmitForJsFiles: o.noEmitForJsFiles,
+        preserveWatchOutput: o.preserveWatchOutput,
+        pretty: o.pretty,
+        version: o.version,
+        watch: o.watch,
+        showConfig: o.showConfig,
+        build: o.build,
+        help: o.help,
+        all: o.all,
+        pprofDir: o.pprofDir,
+        singleThreaded: o.singleThreaded,
+        quiet: o.quiet,
+        checkers: o.checkers,
+    };
+}
+function pathMap(paths) {
+    if (paths === undefined)
+        return undefined;
+    const map = new Map();
+    for (const pattern of Object.keys(paths))
+        map.set(pattern, paths[pattern].slice());
+    return map;
+}
+function libFileNames(lib) {
+    if (lib === undefined)
+        return undefined;
+    const fileNames = [];
+    for (const name of lib) {
+        const fileName = getLibFileName(name);
+        fileNames.push(fileName !== '' ? fileName : name);
+    }
+    return fileNames;
+}

package/dist/api/library/parse.d.ts

@@ -0,0 +1,19 @@
+import type { SourceFile } from './ast.js';
+import type { CompilerOptions } from './compiler-options.generated.js';
+import { ScriptKind } from './enums.generated.js';
+import type { ProgramHost } from './types.js';
+export interface ParseSourceFileOptions {
+    /** The options of the program the file would be in: they decide what makes it a module. */
+    readonly compilerOptions?: CompilerOptions;
+    /** Where the nearest package.json of the file is looked up; the disk without a host. */
+    readonly host?: ProgramHost;
+    /** The script kind; by default, the kind the file name's extension implies. */
+    readonly scriptKind?: ScriptKind;
+}
+/**
+ * `fileName` (absolute, or relative to the host's current directory) with the contents `text`, parsed
+ * as a program with `compilerOptions` parses it: the same tree `tsc-ts --api` gives for the file in a
+ * project of that file alone, with parents set. Whether the file is a module depends on its nearest
+ * package.json, as in a program. The tree is not bound.
+ */
+export declare function parseSourceFile(fileName: string, text: string, options?: ParseSourceFileOptions): SourceFile;

package/dist/api/library/parse.js

@@ -0,0 +1,41 @@
+// Parsing one file with tsc-ts's public API.
+import { ParseOptions } from '../compiler/ast.js';
+import { CompilerHost, sourceFileMetadataOf } from '../compiler/file-loader.js';
+import { CachedFileSystem } from '../compiler/file-system.js';
+import { Resolver } from '../compiler/module-resolution.js';
+import { parseSourceFile as parse } from '../compiler/parser.js';
+import { getNormalizedAbsolutePath, toPath } from '../compiler/path.js';
+import { getExternalModuleIndicatorOptions } from '../compiler/program-utilities.js';
+import { ScriptKind } from './enums.generated.js';
+import { internalError } from './errors.js';
+import { HostFileSystem } from './host.js';
+import { compilerOptionsFromApi } from './options.js';
+/**
+ * `fileName` (absolute, or relative to the host's current directory) with the contents `text`, parsed
+ * as a program with `compilerOptions` parses it: the same tree `tsc-ts --api` gives for the file in a
+ * project of that file alone, with parents set. Whether the file is a module depends on its nearest
+ * package.json, as in a program. The tree is not bound.
+ */
+export function parseSourceFile(fileName, text, options = {}) {
+    try {
+        const host = options.host ?? diskHost();
+        const currentDirectory = host.getCurrentDirectory();
+        const compilerOptions = compilerOptionsFromApi((options.compilerOptions ?? {}));
+        const normalized = getNormalizedAbsolutePath(fileName, currentDirectory);
+        const path = toPath(normalized, currentDirectory, host.useCaseSensitiveFileNames());
+        const compilerHost = new CompilerHost(new CachedFileSystem(new HostFileSystem(host)), currentDirectory, host.getDefaultLibraryDirectory());
+        const metadata = sourceFileMetadataOf(new Resolver(compilerHost, compilerOptions), compilerOptions, normalized);
+        const parseOptions = new ParseOptions(path, (options.scriptKind ?? ScriptKind.Unknown), getExternalModuleIndicatorOptions(normalized, compilerOptions, metadata));
+        return parse(normalized, text, parseOptions);
+    }
+    catch (e) {
+        throw internalError(e);
+    }
+}
+function diskHost() {
+    return {
+        getCurrentDirectory: () => process.cwd(),
+        useCaseSensitiveFileNames: () => process.platform !== 'win32' && process.platform !== 'darwin',
+        getDefaultLibraryDirectory: () => '',
+    };
+}

package/dist/api/library/program.d.ts

@@ -0,0 +1,21 @@
+import type { SourceFile } from './ast.js';
+import type { CreateProgramOptions, Diagnostic, ParsedConfigFile, Program, ProgramHost } from './types.js';
+/**
+ * A program of `rootNames` with `options`, reading files through `host`. It loads its files as `tsc-ts`
+ * loads a project's: resolving imports and references from the root files, with the default libraries of
+ * the options from the host's default library directory.
+ */
+export declare function createProgram(options: CreateProgramOptions): Program;
+/** The program of a config file (`parseConfigFile`'s options and files), reading files through `host`. */
+export declare function createProgramFromConfigFile(configFileName: string, host: ProgramHost): Program;
+/**
+ * The options and root files of a config file, with the diagnostics of reading it, as `tsc-ts --api`'s
+ * parseConfigFile returns them. A config file that can't be read gives one diagnostic and no files.
+ */
+export declare function parseConfigFile(configFileName: string, host: ProgramHost): ParsedConfigFile;
+/**
+ * TypeScript's `getPreEmitDiagnostics`: the config file parsing, program, syntactic, global and semantic
+ * diagnostics of `program` (of `sourceFile` only, for the syntactic and semantic ones), sorted and without
+ * duplicates as tsc-ts sorts them. `program` must be one tsc-ts/api created.
+ */
+export declare function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile): readonly Diagnostic[];

package/dist/api/library/program.js

@@ -0,0 +1,234 @@
+// Programs of tsc-ts's public API: createProgram, parseConfigFile and Program.
+// The emit pipeline, loaded first as tsc-ts's command line loads it: programs and checked programs refer to its
+// classes (EmitIndexes, EmitResult), which scriptc compiles only when the program imports their modules as values.
+// CheckedProgram is imported through it, not as a side effect, so that the declarations of tsc-ts/api don't import
+// the compiler's modules.
+import { CheckedProgram } from '../compiler/compile-program.js';
+import { dropLibGlobals } from '../compiler/checker-symbols.js';
+import { CachedFileSystem } from '../compiler/file-system.js';
+import { getNormalizedAbsolutePath } from '../compiler/path.js';
+import { Program as CompilerProgram, sortAndDeduplicateDiagnostics } from '../compiler/program.js';
+import { ConfigParser, ParsedCommandLine } from '../compiler/tsconfig.js';
+import { LibraryTypeChecker } from './checker.js';
+import { diagnosticOf, programDiagnostics } from './diagnostics.js';
+import { DisposedProgramError, internalError } from './errors.js';
+import { HostFileSystem, LibraryCompilerHost } from './host.js';
+import { compilerOptionsFromApi, compilerOptionsOf } from './options.js';
+/**
+ * A program of `rootNames` with `options`, reading files through `host`. It loads its files as `tsc-ts`
+ * loads a project's: resolving imports and references from the root files, with the default libraries of
+ * the options from the host's default library directory.
+ */
+export function createProgram(options) {
+    try {
+        const host = options.host;
+        const currentDirectory = host.getCurrentDirectory();
+        const rootNames = options.rootNames.map((name) => getNormalizedAbsolutePath(name, currentDirectory));
+        const config = new ParsedCommandLine(compilerOptionsFromApi(options.options), undefined, rootNames, [], undefined, [], currentDirectory, host.useCaseSensitiveFileNames(), rootNames.length);
+        return programOf(config, host);
+    }
+    catch (e) {
+        throw internalError(e);
+    }
+}
+/** The program of a config file (`parseConfigFile`'s options and files), reading files through `host`. */
+export function createProgramFromConfigFile(configFileName, host) {
+    try {
+        return programOf(parsedConfig(configFileName, host).config, host);
+    }
+    catch (e) {
+        throw internalError(e);
+    }
+}
+/**
+ * The options and root files of a config file, with the diagnostics of reading it, as `tsc-ts --api`'s
+ * parseConfigFile returns them. A config file that can't be read gives one diagnostic and no files.
+ */
+export function parseConfigFile(configFileName, host) {
+    try {
+        const { config, errors } = parsedConfig(configFileName, host);
+        return {
+            options: compilerOptionsOf(config.options),
+            fileNames: config.fileNames.slice(),
+            diagnostics: errors.map(diagnosticOf),
+        };
+    }
+    catch (e) {
+        throw internalError(e);
+    }
+}
+function parsedConfig(configFileName, host) {
+    const currentDirectory = host.getCurrentDirectory();
+    const errors = [];
+    const config = new ConfigParser(new HostFileSystem(host), currentDirectory).parseConfigFile(getNormalizedAbsolutePath(configFileName, currentDirectory), undefined, undefined, errors) ??
+        new ParsedCommandLine({}, undefined, [], [], undefined, errors, currentDirectory, host.useCaseSensitiveFileNames(), 0);
+    return { config, errors: config.errors };
+}
+function programOf(config, host) {
+    const fs = new CachedFileSystem(new HostFileSystem(host));
+    const compilerHost = new LibraryCompilerHost(fs, host.getCurrentDirectory(), host.getDefaultLibraryDirectory());
+    return new LibraryProgram(new CheckedProgram(new CompilerProgram(config, compilerHost)));
+}
+/**
+ * TypeScript's `getPreEmitDiagnostics`: the config file parsing, program, syntactic, global and semantic
+ * diagnostics of `program` (of `sourceFile` only, for the syntactic and semantic ones), sorted and without
+ * duplicates as tsc-ts sorts them. `program` must be one tsc-ts/api created.
+ */
+export function getPreEmitDiagnostics(program, sourceFile) {
+    if (!(program instanceof LibraryProgram))
+        throw new TypeError('getPreEmitDiagnostics takes a program created by tsc-ts/api');
+    return program.preEmitDiagnostics(sourceFile);
+}
+class LibraryProgram {
+    checked;
+    options = undefined;
+    typeChecker = undefined;
+    disposed = false;
+    constructor(checked) {
+        this.checked = checked;
+    }
+    get program() {
+        this.checkNotDisposed();
+        return this.checked.program;
+    }
+    checkNotDisposed() {
+        if (this.disposed)
+            throw new DisposedProgramError();
+    }
+    getCompilerOptions() {
+        try {
+            this.options ??= compilerOptionsOf(this.program.options);
+            return this.options;
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getSourceFile(fileName) {
+        try {
+            return this.program.getSourceFile(fileName);
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getSourceFiles() {
+        try {
+            return this.program.getSourceFiles();
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getSourceFileNames() {
+        try {
+            return this.program.getSourceFiles().map((file) => file.fileName);
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getSourceFileMetadata(fileName) {
+        try {
+            const program = this.program;
+            const file = program.getSourceFile(fileName);
+            if (file === undefined)
+                return undefined;
+            const metadata = program.sourceFileMetadata(file.path);
+            return {
+                isDefaultLibrary: program.isSourceFileDefaultLibrary(file.path),
+                isFromExternalLibrary: program.isSourceFileFromExternalLibrary(file),
+                packageJsonType: metadata.packageJsonType,
+                packageJsonDirectory: metadata.packageJsonDirectory,
+                impliedNodeFormat: metadata.impliedNodeFormat,
+            };
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    isSourceFileDefaultLibrary(file) {
+        try {
+            return this.program.isSourceFileDefaultLibrary(file.path);
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    isSourceFileFromExternalLibrary(file) {
+        try {
+            return this.program.isSourceFileFromExternalLibrary(file);
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getTypeChecker() {
+        try {
+            if (this.typeChecker === undefined) {
+                this.checkNotDisposed();
+                this.typeChecker = new LibraryTypeChecker(this.checked.createChecker());
+            }
+            return this.typeChecker;
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    diagnostics(kind, file) {
+        try {
+            this.checkNotDisposed();
+            return programDiagnostics(this.checked, kind, file).map(diagnosticOf);
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    preEmitDiagnostics(file) {
+        try {
+            this.checkNotDisposed();
+            const compilerFile = file;
+            const all = [];
+            for (const kind of ['config', 'program', 'syntactic', 'global', 'semantic'])
+                for (const d of programDiagnostics(this.checked, kind, kind === 'syntactic' || kind === 'semantic' ? compilerFile : undefined))
+                    all.push(d);
+            return sortAndDeduplicateDiagnostics(all).map(diagnosticOf);
+        }
+        catch (e) {
+            throw internalError(e);
+        }
+    }
+    getSyntacticDiagnostics(file) {
+        return this.diagnostics('syntactic', file);
+    }
+    getBindDiagnostics(file) {
+        return this.diagnostics('bind', file);
+    }
+    getSemanticDiagnostics(file) {
+        return this.diagnostics('semantic', file);
+    }
+    getSuggestionDiagnostics(file) {
+        return this.diagnostics('suggestion', file);
+    }
+    getDeclarationDiagnostics(file) {
+        return this.diagnostics('declaration', file);
+    }
+    getProgramDiagnostics() {
+        return this.diagnostics('program', undefined);
+    }
+    getGlobalDiagnostics() {
+        return this.diagnostics('global', undefined);
+    }
+    getConfigFileParsingDiagnostics() {
+        return this.diagnostics('config', undefined);
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.typeChecker?.dispose();
+        this.typeChecker = undefined;
+        this.checked.disposeCheckers();
+        dropLibGlobals(this.checked.program.getSourceFiles());
+        this.disposed = true;
+    }
+}

package/dist/api/library/types.d.ts

@@ -34,6 +34,11 @@ export interface Symbol {
  */
 export interface Type {
     readonly flags: TypeFlags;
+    /**
+     * The object flags of an object type (TypeFlags.Object). Other types carry flags the checker keeps for
+     * itself, such as ObjectFlags.PrimitiveUnion, where TypeScript 7's API gives 0. Flags the checker
+     * caches, such as ObjectFlags.MembersResolved, are set as queries compute them.
+     */
     readonly objectFlags: ObjectFlags;
     readonly id: number;
     getSymbol(): Symbol | undefined;
@@ -118,6 +123,9 @@ export interface TupleType extends InterfaceType {
     readonly fixedLength: number;
     readonly readonly: boolean;
 }
+/** A reference to a tuple type (`[string, number]`): `getTarget()` is the TupleType (`isTupleType()`). */
+export interface TupleTypeReference extends TypeReference {
+}
 export interface UnionOrIntersectionType extends Type {
 }
 export interface UnionType extends UnionOrIntersectionType {
@@ -266,6 +274,7 @@ export interface TypeChecker {
     /** The type of a symbol as narrowed at `location`. */
     getTypeOfSymbolAtLocation(symbol: Symbol, location: Node): Type;
     getTypeArguments(type: TypeReference): readonly Type[];
+    /** The target of an alias (SymbolFlags.Alias); throws an InternalCompilerError for any other symbol. */
     getAliasedSymbol(symbol: Symbol): Symbol;
     getPropertyOfType(type: Type, name: string): Symbol | undefined;
     getPropertiesOfType(type: Type): readonly Symbol[];
@@ -287,8 +296,12 @@ export interface TypeChecker {
     isArrayLikeType(type: Type): boolean;
     isTypeAssignableTo(source: Type, target: Type): boolean;
     resolveName(name: string, meaning: SymbolFlags, location?: Node, excludeGlobals?: boolean): Symbol | undefined;
+    /** The value `node` names where it is: `resolveName(node.text, SymbolFlags.Value | SymbolFlags.ExportValue, node)`. */
     getResolvedSymbol(node: Identifier): Symbol | undefined;
-    /** The text TypeScript 7's API gives for `type`, printed in `enclosingDeclaration` with `flags`. */
+    /**
+     * The text TypeScript 7's API gives for `type`, printed in `enclosingDeclaration` with `flags`; without
+     * flags, or with 0, with TypeFormatFlags.AllowUniqueESSymbolType and UseAliasDefinedOutsideCurrentScope.
+     */
     typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
     getAnyType(): Type;
     getUnknownType(): Type;