tsc-ts 0.0.4 → 0.0.5

package/dist/api/compiler/program-utilities.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Option and syntax queries of program construction: libraries, module formats and resolution modes.
+ */
+import { ExternalModuleIndicatorOptions, ImportAttributes, type Node, type SourceFile } from './ast.js';
+import { JsxEmit, ModuleKind, ScriptTarget, type CompilerOptions } from './options.js';
+/** `--lib` names in declaration order. */
+export declare const libNames: readonly string[];
+/** The bundled file of a `lib` name or file name, or `''`. */
+export declare function getLibFileName(name: string): string;
+/** The library included by default for the target. */
+export declare function getDefaultLibFileName(options: CompilerOptions): string;
+export declare function scriptTargetName(target: ScriptTarget): string;
+export declare function moduleKindName(kind: ModuleKind): string;
+export declare function jsxEmitName(jsx: JsxEmit): string;
+/** What a file's nearest `package.json` says about its module format. */
+export declare class SourceFileMetadata {
+    /** `type` of the nearest `package.json`, where it applies; `''` otherwise. */
+    readonly packageJsonType: string;
+    /** Directory of the nearest `package.json`, or `''`. */
+    readonly packageJsonDirectory: string;
+    /** `ESNext`, `CommonJS` or `None` (formats other than JavaScript and TypeScript). */
+    readonly impliedNodeFormat: ModuleKind;
+    constructor(
+    /** `type` of the nearest `package.json`, where it applies; `''` otherwise. */
+    packageJsonType: string, 
+    /** Directory of the nearest `package.json`, or `''`. */
+    packageJsonDirectory: string, 
+    /** `ESNext`, `CommonJS` or `None` (formats other than JavaScript and TypeScript). */
+    impliedNodeFormat: ModuleKind);
+}
+export declare const libFileMetadata: SourceFileMetadata;
+export declare function getImpliedNodeFormatForFile(path: string, packageJsonType: string): ModuleKind;
+/** The format a file is emitted in when it differs from `module`, else `None`. */
+export declare function getImpliedNodeFormatForEmit(fileName: string, emitModuleKind: ModuleKind, metadata: SourceFileMetadata): ModuleKind;
+export declare function getEmitModuleFormatOfFile(fileName: string, options: CompilerOptions, metadata: SourceFileMetadata): ModuleKind;
+/** What makes a file a module, besides imports and exports. */
+export declare function getExternalModuleIndicatorOptions(fileName: string, options: CompilerOptions, metadata: SourceFileMetadata): ExternalModuleIndicatorOptions;
+export declare function isExternalModule(file: SourceFile): boolean;
+export declare function isExternalOrCommonJSModule(file: SourceFile): boolean;
+export declare function isSourceFileJS(file: SourceFile): boolean;
+export declare function isCheckJsEnabledForFile(file: SourceFile, options: CompilerOptions): boolean;
+/** The package providing the JSX runtime, or `''` when JSX compiles to factory calls. */
+export declare function getJSXImplicitImportBase(options: CompilerOptions, file: SourceFile): string;
+export declare function getJSXRuntimeImport(base: string, options: CompilerOptions): string;
+/** The `resolution-mode` of `import type` attributes, or `None`. */
+export declare function getResolutionModeOverride(attributes: ImportAttributes | undefined): ModuleKind;
+/** Whether `import` syntax decides how a specifier resolves: Node16-style resolution or `exports`/`imports`. */
+export declare function importSyntaxAffectsModuleResolution(options: CompilerOptions): boolean;
+/** The mode a module specifier resolves in: from attributes, the import syntax, or the file's format. */
+export declare function getModeForUsageLocation(fileName: string, metadata: SourceFileMetadata, usage: Node, options: CompilerOptions): ModuleKind;
+export declare function getEmitSyntaxForUsageLocation(fileName: string, metadata: SourceFileMetadata, usage: Node, options: CompilerOptions): ModuleKind;
+export declare function getDefaultResolutionModeForFile(fileName: string, metadata: SourceFileMetadata, options: CompilerOptions): ModuleKind;

package/dist/api/compiler/program-utilities.js

@@ -0,0 +1,365 @@
+/**
+ * Option and syntax queries of program construction: libraries, module formats and resolution modes.
+ */
+import { ExportDeclaration, ExternalModuleIndicatorOptions, ImportAttribute, ImportDeclaration, ImportEqualsDeclaration, ImportTypeNode, JSDocImportTag, LiteralTypeNode, NoSubstitutionTemplateLiteral, ParenthesizedExpression, StringLiteral, } from './ast.js';
+import { isImportCall, isRequireCall } from './ast-utilities.js';
+import { libMap } from './option-declarations.js';
+import { getEmitModuleDetectionKind, getEmitModuleKind, getEmitScriptTarget, getModuleResolutionKind, getResolvePackageJsonExports, getResolvePackageJsonImports, JsxEmit, ModuleDetectionKind, ModuleKind, ModuleResolutionKind, ScriptTarget, } from './options.js';
+import { fileExtensionIsOneOf, isDeclarationFileName, toFileNameLowerCase } from './path.js';
+// ---- Libraries
+/** `--lib` names in declaration order. */
+export const libNames = [...libMap.keys()];
+const libFileNames = new Set();
+for (const value of libMap.values())
+    if (typeof value === 'string')
+        libFileNames.add(value);
+/** The bundled file of a `lib` name or file name, or `''`. */
+export function getLibFileName(name) {
+    const lower = toFileNameLowerCase(name);
+    if (libFileNames.has(lower))
+        return lower;
+    const fileName = libMap.get(lower);
+    return typeof fileName === 'string' ? fileName : '';
+}
+/** The library included by default for the target. */
+export function getDefaultLibFileName(options) {
+    switch (getEmitScriptTarget(options)) {
+        case ScriptTarget.ESNext:
+            return 'lib.esnext.full.d.ts';
+        case ScriptTarget.ES2025:
+            return 'lib.es2025.full.d.ts';
+        case ScriptTarget.ES2024:
+            return 'lib.es2024.full.d.ts';
+        case ScriptTarget.ES2023:
+            return 'lib.es2023.full.d.ts';
+        case ScriptTarget.ES2022:
+            return 'lib.es2022.full.d.ts';
+        case ScriptTarget.ES2021:
+            return 'lib.es2021.full.d.ts';
+        case ScriptTarget.ES2020:
+            return 'lib.es2020.full.d.ts';
+        case ScriptTarget.ES2019:
+            return 'lib.es2019.full.d.ts';
+        case ScriptTarget.ES2018:
+            return 'lib.es2018.full.d.ts';
+        case ScriptTarget.ES2017:
+            return 'lib.es2017.full.d.ts';
+        case ScriptTarget.ES2016:
+            return 'lib.es2016.full.d.ts';
+        case ScriptTarget.ES2015:
+            // Not `lib.es2015.full.d.ts`, which would be a breaking change.
+            return 'lib.es6.d.ts';
+        default:
+            return 'lib.d.ts';
+    }
+}
+// ---- Enum names, as tsgo prints them
+export function scriptTargetName(target) {
+    switch (target) {
+        case ScriptTarget.ES5:
+            return 'ES5';
+        case ScriptTarget.ES2015:
+            return 'ES2015';
+        case ScriptTarget.ES2016:
+            return 'ES2016';
+        case ScriptTarget.ES2017:
+            return 'ES2017';
+        case ScriptTarget.ES2018:
+            return 'ES2018';
+        case ScriptTarget.ES2019:
+            return 'ES2019';
+        case ScriptTarget.ES2020:
+            return 'ES2020';
+        case ScriptTarget.ES2021:
+            return 'ES2021';
+        case ScriptTarget.ES2022:
+            return 'ES2022';
+        case ScriptTarget.ES2023:
+            return 'ES2023';
+        case ScriptTarget.ES2024:
+            return 'ES2024';
+        case ScriptTarget.ES2025:
+            return 'ES2025';
+        case ScriptTarget.ESNext:
+            return 'ESNext';
+        case ScriptTarget.JSON:
+            return 'JSON';
+    }
+    return '';
+}
+export function moduleKindName(kind) {
+    switch (kind) {
+        case ModuleKind.None:
+            return 'None';
+        case ModuleKind.CommonJS:
+            return 'CommonJS';
+        case ModuleKind.AMD:
+            return 'AMD';
+        case ModuleKind.UMD:
+            return 'UMD';
+        case ModuleKind.System:
+            return 'System';
+        case ModuleKind.ES2015:
+            return 'ES2015';
+        case ModuleKind.ES2020:
+            return 'ES2020';
+        case ModuleKind.ES2022:
+            return 'ES2022';
+        case ModuleKind.ESNext:
+            return 'ESNext';
+        case ModuleKind.Node16:
+            return 'Node16';
+        case ModuleKind.Node18:
+            return 'Node18';
+        case ModuleKind.Node20:
+            return 'Node20';
+        case ModuleKind.NodeNext:
+            return 'NodeNext';
+        case ModuleKind.Preserve:
+            return 'Preserve';
+    }
+    return '';
+}
+export function jsxEmitName(jsx) {
+    switch (jsx) {
+        case JsxEmit.Preserve:
+            return 'preserve';
+        case JsxEmit.ReactNative:
+            return 'react-native';
+        case JsxEmit.React:
+            return 'react';
+        case JsxEmit.ReactJSX:
+            return 'react-jsx';
+        case JsxEmit.ReactJSXDev:
+            return 'react-jsxdev';
+    }
+    return '';
+}
+// ---- Module formats
+/** What a file's nearest `package.json` says about its module format. */
+export class SourceFileMetadata {
+    packageJsonType;
+    packageJsonDirectory;
+    impliedNodeFormat;
+    constructor(
+    /** `type` of the nearest `package.json`, where it applies; `''` otherwise. */
+    packageJsonType, 
+    /** Directory of the nearest `package.json`, or `''`. */
+    packageJsonDirectory, 
+    /** `ESNext`, `CommonJS` or `None` (formats other than JavaScript and TypeScript). */
+    impliedNodeFormat) {
+        this.packageJsonType = packageJsonType;
+        this.packageJsonDirectory = packageJsonDirectory;
+        this.impliedNodeFormat = impliedNodeFormat;
+    }
+}
+export const libFileMetadata = new SourceFileMetadata('', '', ModuleKind.CommonJS);
+export function getImpliedNodeFormatForFile(path, packageJsonType) {
+    if (fileExtensionIsOneOf(path, ['.d.mts', '.mts', '.mjs']))
+        return ModuleKind.ESNext;
+    if (fileExtensionIsOneOf(path, ['.d.cts', '.cts', '.cjs']))
+        return ModuleKind.CommonJS;
+    if (fileExtensionIsOneOf(path, ['.d.ts', '.ts', '.tsx', '.js', '.jsx'])) {
+        return packageJsonType === 'module' ? ModuleKind.ESNext : ModuleKind.CommonJS;
+    }
+    return ModuleKind.None;
+}
+/** The format a file is emitted in when it differs from `module`, else `None`. */
+export function getImpliedNodeFormatForEmit(fileName, emitModuleKind, metadata) {
+    if (ModuleKind.Node16 <= emitModuleKind && emitModuleKind <= ModuleKind.NodeNext)
+        return metadata.impliedNodeFormat;
+    if (metadata.impliedNodeFormat === ModuleKind.CommonJS &&
+        (metadata.packageJsonType === 'commonjs' || fileExtensionIsOneOf(fileName, ['.cjs', '.cts']))) {
+        return ModuleKind.CommonJS;
+    }
+    if (metadata.impliedNodeFormat === ModuleKind.ESNext &&
+        (metadata.packageJsonType === 'module' || fileExtensionIsOneOf(fileName, ['.mjs', '.mts']))) {
+        return ModuleKind.ESNext;
+    }
+    return ModuleKind.None;
+}
+export function getEmitModuleFormatOfFile(fileName, options, metadata) {
+    const result = getImpliedNodeFormatForEmit(fileName, getEmitModuleKind(options), metadata);
+    return result !== ModuleKind.None ? result : getEmitModuleKind(options);
+}
+/** What makes a file a module, besides imports and exports. */
+export function getExternalModuleIndicatorOptions(fileName, options, metadata) {
+    if (isDeclarationFileName(fileName))
+        return new ExternalModuleIndicatorOptions(false, false);
+    switch (getEmitModuleDetectionKind(options)) {
+        case ModuleDetectionKind.Force:
+            return new ExternalModuleIndicatorOptions(false, true);
+        case ModuleDetectionKind.Auto: {
+            const jsx = options.jsx === JsxEmit.ReactJSX || options.jsx === JsxEmit.ReactJSXDev;
+            const forced = getImpliedNodeFormatForEmit(fileName, getEmitModuleKind(options), metadata) === ModuleKind.ESNext ||
+                fileExtensionIsOneOf(fileName, ['.cjs', '.cts', '.mjs', '.mts']);
+            return new ExternalModuleIndicatorOptions(jsx, forced);
+        }
+        default:
+            return new ExternalModuleIndicatorOptions(false, false);
+    }
+}
+export function isExternalModule(file) {
+    return file.externalModuleIndicator !== undefined;
+}
+export function isExternalOrCommonJSModule(file) {
+    return file.externalModuleIndicator !== undefined || file.commonJSModuleIndicator !== undefined;
+}
+export function isSourceFileJS(file) {
+    return file.scriptKind === 1 /* ScriptKind.JS */ || file.scriptKind === 2 /* ScriptKind.JSX */;
+}
+export function isCheckJsEnabledForFile(file, options) {
+    if (file.checkJsDirective !== undefined)
+        return file.checkJsDirective.enabled;
+    return options.checkJs === true;
+}
+// ---- JSX runtime
+function pragmaArgument(file, name, argument) {
+    let result;
+    // The last pragma wins.
+    for (const pragma of file.pragmas) {
+        if (pragma.name === name)
+            result = pragma.args.get(argument)?.value ?? '';
+    }
+    return result;
+}
+/** The package providing the JSX runtime, or `''` when JSX compiles to factory calls. */
+export function getJSXImplicitImportBase(options, file) {
+    const importSource = pragmaArgument(file, 'jsximportsource', 'factory');
+    const runtime = pragmaArgument(file, 'jsxruntime', 'factory');
+    if (runtime === 'classic')
+        return '';
+    if (options.jsx === JsxEmit.ReactJSX ||
+        options.jsx === JsxEmit.ReactJSXDev ||
+        options.jsxImportSource !== undefined ||
+        importSource !== undefined ||
+        runtime === 'automatic') {
+        if (importSource !== undefined && importSource !== '')
+            return importSource;
+        return options.jsxImportSource ?? 'react';
+    }
+    return '';
+}
+export function getJSXRuntimeImport(base, options) {
+    if (base === '')
+        return '';
+    return base + '/' + (options.jsx === JsxEmit.ReactJSXDev ? 'jsx-dev-runtime' : 'jsx-runtime');
+}
+// ---- Resolution modes
+function isStringLiteralLike(node) {
+    return node instanceof StringLiteral || node instanceof NoSubstitutionTemplateLiteral;
+}
+function literalText(node) {
+    if (node instanceof StringLiteral)
+        return node.text;
+    if (node instanceof NoSubstitutionTemplateLiteral)
+        return node.text;
+    return '';
+}
+/** The `resolution-mode` of `import type` attributes, or `None`. */
+export function getResolutionModeOverride(attributes) {
+    if (attributes === undefined)
+        return ModuleKind.None;
+    const elements = attributes.attributes.nodes;
+    if (elements.length !== 1)
+        return ModuleKind.None;
+    const attribute = elements[0];
+    if (!(attribute instanceof ImportAttribute))
+        return ModuleKind.None;
+    const name = attribute.name;
+    if (name === undefined || !isStringLiteralLike(name) || literalText(name) !== 'resolution-mode')
+        return ModuleKind.None;
+    if (!isStringLiteralLike(attribute.value))
+        return ModuleKind.None;
+    const text = literalText(attribute.value);
+    if (text === 'import')
+        return ModuleKind.ESNext;
+    if (text === 'require')
+        return ModuleKind.CommonJS;
+    return ModuleKind.None;
+}
+/** The attributes of an import or export declaration or a JSDoc `@import`, if any. */
+function importOrExportAttributes(node) {
+    if (node instanceof ImportDeclaration)
+        return node.attributes;
+    if (node instanceof ExportDeclaration)
+        return node.attributes;
+    if (node instanceof JSDocImportTag)
+        return node.attributes;
+    return undefined;
+}
+function isClauseTypeOnly(clause) {
+    return clause !== undefined && clause.phaseModifier === 156 /* SyntaxKind.TypeKeyword */;
+}
+function isExclusivelyTypeOnlyImportOrExport(node) {
+    if (node instanceof ExportDeclaration)
+        return node.isTypeOnly;
+    if (node instanceof ImportDeclaration)
+        return isClauseTypeOnly(node.importClause);
+    if (node instanceof JSDocImportTag)
+        return isClauseTypeOnly(node.importClause);
+    return false;
+}
+/** Whether `import` syntax decides how a specifier resolves: Node16-style resolution or `exports`/`imports`. */
+export function importSyntaxAffectsModuleResolution(options) {
+    const kind = getModuleResolutionKind(options);
+    return ((ModuleResolutionKind.Node16 <= kind && kind <= ModuleResolutionKind.NodeNext) ||
+        getResolvePackageJsonExports(options) ||
+        getResolvePackageJsonImports(options));
+}
+/** The mode a module specifier resolves in: from attributes, the import syntax, or the file's format. */
+export function getModeForUsageLocation(fileName, metadata, usage, options) {
+    const parent = usage.parent;
+    const attributes = importOrExportAttributes(parent);
+    if (attributes !== undefined && parent !== undefined && isExclusivelyTypeOnlyImportOrExport(parent)) {
+        const override = getResolutionModeOverride(attributes);
+        if (override !== ModuleKind.None)
+            return override;
+    }
+    if (parent instanceof LiteralTypeNode && parent.parent instanceof ImportTypeNode) {
+        const override = getResolutionModeOverride(parent.parent.attributes);
+        if (override !== ModuleKind.None)
+            return override;
+    }
+    if (importSyntaxAffectsModuleResolution(options))
+        return getEmitSyntaxForUsageLocation(fileName, metadata, usage, options);
+    return ModuleKind.None;
+}
+function walkUpParenthesizedExpressions(node) {
+    while (node instanceof ParenthesizedExpression)
+        node = node.parent;
+    return node;
+}
+export function getEmitSyntaxForUsageLocation(fileName, metadata, usage, options) {
+    const parent = usage.parent;
+    if (parent === undefined)
+        return ModuleKind.None;
+    if (isRequireCall(parent, false) ||
+        (parent.kind === 284 /* SyntaxKind.ExternalModuleReference */ && parent.parent instanceof ImportEqualsDeclaration)) {
+        return ModuleKind.CommonJS;
+    }
+    const fileEmitMode = getEmitModuleFormatOfFile(fileName, options, metadata);
+    const call = walkUpParenthesizedExpressions(parent);
+    if (call !== undefined && isImportCall(call)) {
+        return shouldTransformImportCall(options, fileEmitMode) ? ModuleKind.CommonJS : ModuleKind.ESNext;
+    }
+    if (fileEmitMode === ModuleKind.CommonJS)
+        return ModuleKind.CommonJS;
+    if ((ModuleKind.ES2015 <= fileEmitMode && fileEmitMode <= ModuleKind.ESNext) ||
+        fileEmitMode === ModuleKind.Preserve) {
+        return ModuleKind.ESNext;
+    }
+    return ModuleKind.None;
+}
+function shouldTransformImportCall(options, impliedNodeFormatForEmit) {
+    const moduleKind = getEmitModuleKind(options);
+    if ((ModuleKind.Node16 <= moduleKind && moduleKind <= ModuleKind.NodeNext) || moduleKind === ModuleKind.Preserve) {
+        return false;
+    }
+    return impliedNodeFormatForEmit < ModuleKind.ES2015;
+}
+export function getDefaultResolutionModeForFile(fileName, metadata, options) {
+    return importSyntaxAffectsModuleResolution(options)
+        ? getImpliedNodeFormatForEmit(fileName, getEmitModuleKind(options), metadata)
+        : ModuleKind.None;
+}

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

@@ -0,0 +1,180 @@
+/**
+ * A program: the files of a compilation and the diagnostics found building it, before binding and checking.
+ *
+ * ```ts
+ * const program = new Program(config, new CompilerHost(fs, cwd, libDirectory));
+ * for (const file of program.getSourceFiles()) console.log(file.fileName);
+ * ```
+ */
+import { type Node, type SourceFile } from './ast.js';
+import { Diagnostic, type Locale } from './diagnostics.js';
+import { FileLoader, type CompilerHost, type LibFile, type ProcessedFiles, type RedirectFile } from './file-loader.js';
+import { type PackageJsonInfo, PackageJsonLookup } from './package-json.js';
+import type { MergedGlobals } from './checker-symbols.js';
+import type { EmitIndexes } from './compile-program.js';
+import { type IncludeProcessor } from './file-include.js';
+import type { ResolvedModule } from './module-resolution-types.js';
+import { ModuleKind, ScriptTarget, type CompilerOptions } from './options.js';
+import { type OutputPathsHost } from './output-paths.js';
+import { SourceFileMetadata } from './program-utilities.js';
+import { type ParsedCommandLine, type SourceOutputAndProjectReference } from './tsconfig.js';
+import { KnownSymlinks } from './symlinks.js';
+export declare class Program implements OutputPathsHost {
+    readonly commandLine: ParsedCommandLine;
+    readonly host: CompilerHost;
+    readonly options: CompilerOptions;
+    readonly currentDirectory: string;
+    readonly useCaseSensitiveFileNames: boolean;
+    readonly includeProcessor: IncludeProcessor;
+    private readonly processed;
+    private readonly programDiagnosticsList;
+    private readonly emitBlockingPaths;
+    private commonSourceDirectoryValue;
+    private packagesMap;
+    private symlinks;
+    /** Set by `prepareForSharing`: the program is immutable from then on. */
+    private shared;
+    /** The globals and module augmentations as the main thread's checker merged them, for checker threads. */
+    mergedGlobals: MergedGlobals | undefined;
+    /** What emit resolvers index for all files, built by the main thread for checker threads. */
+    emitIndexes: EmitIndexes | undefined;
+    /**
+     * `loader`, if given, is a FileLoader of `host` and `commandLine` that has not loaded yet. With `previous`
+     * and `processed` (`updateFile`), the program takes `processed` as its files and the option diagnostics of
+     * `previous`.
+     */
+    constructor(commandLine: ParsedCommandLine, host: CompilerHost, loader?: FileLoader, previous?: Program, processed?: ProcessedFiles);
+    /**
+     * The program with the file at `path` read again from `host` and everything else taken from this program,
+     * as tsgo's UpdateProgram makes it: `undefined` when the file is not in the program, belongs to a package
+     * that is installed more than once, or no longer imports, references or needs the same modules
+     * (`canReplaceFile`, and the tslib and JSX runtime imports the program kept for the file), so the program
+     * must be loaded again.
+     */
+    updateFile(path: string, host: CompilerHost): Program | undefined;
+    /** Libraries first, then the other files in the order they were found. */
+    getSourceFiles(): readonly SourceFile[];
+    getSourceFileByPath(path: string): SourceFile | undefined;
+    getSourceFile(fileName: string): SourceFile | undefined;
+    /** Files that were referenced but could not be read. */
+    missingFiles(): readonly string[];
+    toPath(fileName: string): string;
+    emitScriptTarget(): ScriptTarget;
+    /** `fileName` as given, or relative to the current directory. */
+    displayFileName(fileName: string, relative: boolean): string;
+    isSourceFileFromExternalLibrary(file: SourceFile): boolean;
+    isSourceFileDefaultLibrary(path: string): boolean;
+    /** The bundled library loaded as `path`, if any. */
+    getDefaultLibFile(path: string): LibFile | undefined;
+    /** The declaration output loaded instead of a source of a referenced project, or `''`. */
+    getParseFileRedirect(fileName: string): string;
+    /** Files the type reference directives of a file resolved to. */
+    getResolvedTypeReferenceDirectiveFiles(path: string): string[];
+    /**
+     * Whether `packageJsonLookups` has every lookup of the program's module resolution: not where it
+     * took resolutions from parse threads whose lookups may miss some (`preparedPackageJsonLookups`).
+     */
+    hasAllPackageJsonLookups(): boolean;
+    /**
+     * The `package.json` lookups of module resolution: this program's, and those of the parse threads
+     * whose resolutions it took. A directory can be among both.
+     */
+    packageJsonLookups(): PackageJsonLookup[];
+    /** The typings cache of automatic type acquisition, or `''`. */
+    getGlobalTypingsCacheLocation(): string;
+    /** Files of the same package version that redirect to the file at `path`. */
+    getRedirectTargets(path: string): readonly string[];
+    /** The directory of the nearest `package.json` at or above `directory`, or `''`. */
+    getNearestAncestorDirectoryWithPackageJson(directory: string): string;
+    /** The `package.json` at `packageJsonPath`, if it exists and is the scope of its directory. */
+    getPackageJsonInfo(packageJsonPath: string): PackageJsonInfo | undefined;
+    /**
+     * Directory symlinks seen by module resolution, and those of the runtime dependencies of the
+     * packages that contain emitted files.
+     */
+    getSymlinkCache(): KnownSymlinks;
+    private computeSymlinkCache;
+    sourceFileMetadata(path: string): SourceFileMetadata;
+    redirectFile(path: string): RedirectFile | undefined;
+    /** The source of a referenced project whose declaration output was loaded as `path`, else `fileName`. */
+    getSourceOfProjectReferenceIfOutputIncluded(path: string, fileName: string): string;
+    getProjectReferenceFromSource(path: string): SourceOutputAndProjectReference | undefined;
+    /** The configs of the project's references; `undefined` for those that couldn't be read. */
+    getResolvedProjectReferences(): (ParsedCommandLine | undefined)[];
+    getCompilerOptionsForFile(file: SourceFile): CompilerOptions;
+    importHelpersImportSpecifier(path: string): Node | undefined;
+    getModeForUsageLocation(file: SourceFile, location: Node): ModuleKind;
+    getImpliedNodeFormatForEmit(file: SourceFile): ModuleKind;
+    getDefaultResolutionModeForFile(file: SourceFile): ModuleKind;
+    /** The program file for a resolved file name, or the source file a referenced project's output redirects to. */
+    getSourceFileForResolvedModule(fileName: string): SourceFile | undefined;
+    /** Packages that modules resolved into, by name: whether any resolution into them was a declaration file. */
+    getPackagesMap(): ReadonlyMap<string, boolean>;
+    getResolvedModule(file: SourceFile, moduleName: string, mode: ModuleKind): ResolvedModule | undefined;
+    /** The program files that the imports and type reference directives of `file` resolved to. */
+    /**
+     * The files `file` imports and references through type directives. `byFileName`, the program's
+     * files by file name, finds a file without computing its path when it is resolved by that name.
+     */
+    getResolvedFilesOf(file: SourceFile, byFileName?: ReadonlyMap<string, SourceFile>): SourceFile[];
+    /** The specifier of the implicit JSX runtime import of `file`, if any. */
+    jsxRuntimeImportSpecifier(path: string): Node | undefined;
+    getResolvedModuleFromModuleSpecifier(file: SourceFile, specifier: Node): ResolvedModule | undefined;
+    /** Whether emit writes outputs for `file`. */
+    sourceFileMayBeEmitted(file: SourceFile, forceDtsEmit: boolean): boolean;
+    /** The directory outputs are laid out relative to, with a trailing `/`. */
+    commonSourceDirectory(): string;
+    private emittedNonDeclarationFiles;
+    private checkSourceFilesBelongToPath;
+    /**
+     * Computes what checking, reporting and emit would otherwise compute on first use, so that they
+     * never write to the program: a program shared with other threads (parallel-check.ts) is
+     * immutable. Neither adds diagnostics. File inclusion diagnostics are fixed first, as tsgo fixes
+     * them on first use: computing the common source directory checks that files are under `rootDir`
+     * (or the config file's directory), which reports only when options compute it while the program
+     * is created (verifyCompilerOptions), not when emit or declaration diagnostics compute it later.
+     */
+    /**
+     * Whether the program was prepared for sharing (`prepareForSharing`): its objects are immutable, so what is
+     * computed on first use after that is not kept in them.
+     */
+    isShared(): boolean;
+    prepareForSharing(): void;
+    isEmitBlocked(fileName: string): boolean;
+    /** Diagnostics of reading the config file. */
+    getConfigFileParsingDiagnostics(): readonly Diagnostic[];
+    /** Parse errors of `file`, or of every file, sorted. */
+    getSyntacticDiagnostics(file?: SourceFile): Diagnostic[];
+    /** Option errors and file inclusion errors without a location in a source file. */
+    getProgramDiagnostics(): Diagnostic[];
+    /** File inclusion errors located in `file`, reported with its semantic diagnostics. */
+    getIncludeProcessorDiagnostics(file: SourceFile): Diagnostic[];
+    /** Diagnostics of module and type reference resolution. */
+    resolutionDiagnostics(): Diagnostic[];
+    /** What `--explainFiles` prints: each file and why it is in the program. */
+    explainFiles(locale: Locale): string;
+    private configSourceFile;
+    private compilerOptionsProperty;
+    private compilerOptionsObject;
+    private addProgramDiagnostic;
+    /** At `key1` (or `key2`) of `object`, on the key or the value; `undefined` if neither is there. */
+    private optionDiagnosticInObject;
+    /** At `compilerOptions` of the config, or without a location. */
+    private compilerOptionsDiagnostic;
+    private optionDiagnostic;
+    /** At the name of `option1` (or `option2`), with both names as the first arguments. */
+    private optionNameDiagnostic;
+    private optionValueDiagnostic;
+    private removedOptionDiagnostic;
+    private pathsDiagnostic;
+    private pathsValueDiagnostic;
+    private verifyCompilerOptions;
+    private verifyEmitFilePath;
+    private blockEmittingOfFile;
+    private verifyProjectReferences;
+    private verifyProjectReference;
+    /** At the reference's entry of `references` in the parent config. */
+    private referenceDiagnostic;
+}
+/** Sorts diagnostics and merges duplicates, combining their related information. */
+export declare function sortAndDeduplicateDiagnostics(diagnostics: readonly Diagnostic[]): Diagnostic[];