tsc-ts 0.0.3 → 0.0.5

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

@@ -0,0 +1,71 @@
+import { type SourceFile } from './ast.js';
+import { type Diagnostic } from './diagnostics.js';
+import { type CompilerOptions } from './options.js';
+import { type OutputPathsHost } from './output-paths.js';
+import type { EmitResolver } from './transformers/emit-resolver.js';
+import { type ModuleFormatHost } from './transformers/module.js';
+/** The program as emit sees it. */
+export declare abstract class EmitHost implements OutputPathsHost {
+    readonly options: CompilerOptions;
+    readonly currentDirectory: string;
+    readonly useCaseSensitiveFileNames: boolean;
+    private readonly commonSourceDirectoryPath;
+    readonly resolver: EmitResolver;
+    readonly formats: ModuleFormatHost;
+    constructor(options: CompilerOptions, resolver: EmitResolver, formats: ModuleFormatHost, commonSourceDirectory: string, currentDirectory: string, useCaseSensitiveFileNames: boolean);
+    /** With a trailing `/`. */
+    commonSourceDirectory(): string;
+    /**
+     * Writes an output file; returns an error message, or `''`. `declarationDiagnostics` are the
+     * declaration emit errors of a declaration file written by a forced declaration emit.
+     * Returning `skippedWrite` leaves a file unwritten without an error.
+     */
+    abstract writeFile(fileName: string, text: string, declarationDiagnostics?: readonly Diagnostic[]): string;
+    /** Whether writing a file is blocked, as when it would overwrite an input; false by default. */
+    isEmitBlocked(_fileName: string): boolean;
+    /**
+     * Whether the program found `file` through a module or type reference resolved in `node_modules`
+     * (`Program.isSourceFileFromExternalLibrary`); such files are not emitted. False by default.
+     */
+    isSourceFileFromExternalLibrary(_file: SourceFile): boolean;
+}
+/** What `EmitHost.writeFile` returns for a file it chose not to write. */
+export declare const skippedWrite = "\0";
+export declare class EmitResult {
+    readonly emittedFiles: string[];
+    readonly errors: string[];
+    /** Files not emitted because they use syntax emit doesn't support yet, with the reason. */
+    readonly unsupported: string[];
+    /** Declaration emit errors; a file with any gets no declaration file. */
+    readonly diagnostics: Diagnostic[];
+    /**
+     * For each declaration file a checker thread wrote for an incremental program, its name, its signature
+     * and the signature compared for composite projects (`DeclarationSignatureWriter`).
+     */
+    readonly declarationSignatures: string[];
+    /**
+     * Under `noEmitOnError`, the outputs a checker thread emitted without writing them, as file name and
+     * text alternately: the main thread writes them once it knows there are no errors (`writeHeldOutputs`).
+     */
+    readonly heldOutputs: string[];
+    emitSkipped: boolean;
+    /**
+     * Whether the declaration transform ran, so that `diagnostics` holds the declaration diagnostics of
+     * the files emitted (only declaration emit reports diagnostics).
+     */
+    declarationTransformed: boolean;
+    constructor();
+}
+export declare function sourceFileMayBeEmitted(file: SourceFile, options: CompilerOptions): boolean;
+/** Which outputs to emit. */
+export declare const enum EmitOnly {
+    All = 0,
+    Js = 1,
+    Dts = 2,
+    /**
+     * The declaration file alone, even without `declaration` and despite errors, for the shape
+     * signature of incremental builds; it is written with its errors and without a map.
+     */
+    ForcedDts = 3
+}
+export declare function emitFiles(host: EmitHost, files: readonly SourceFile[], emitOnly?: EmitOnly): EmitResult;

package/dist/api/compiler/emitter.js

@@ -0,0 +1,327 @@
+import { compareDiagnostics } from './diagnostics.js';
+import { JsxEmit, NewLineKind, getEmitScriptTarget, getIsolatedModules } from './options.js';
+import { getOutputPathsFor } from './output-paths.js';
+import { combinePaths, fileExtensionIs, getBaseFileName, getDirectoryPath, getRootLength, normalizePath, normalizeSlashes, ensureTrailingDirectorySeparator, containsPath, getNormalizedAbsolutePath, } from './path.js';
+import { EmitContext } from './printer/emit-context.js';
+import { Printer, PrinterOptions } from './printer/printer.js';
+import { TextWriter } from './printer/text-writer.js';
+import { SourceMapGenerator, getRelativePathToDirectoryOrUrl } from './sourcemap.js';
+import { DeclarationEmitResolver } from './transformers/declarations-resolver.js';
+import { DeclarationTransformer } from './transformers/declarations.js';
+import { ImportElision } from './transformers/import-elision.js';
+import { UseStrictTransformer, createModuleTransformer } from './transformers/module.js';
+import { TypeEraser } from './transformers/type-eraser.js';
+import { TypeScriptFacts } from './transformers/subtree-facts.js';
+import { RuntimeSyntax } from './transformers/runtime-syntax.js';
+import { ConstEnumInliner } from './transformers/const-enum-inliner.js';
+import { addDownlevelTransformers } from './transformers/downlevel.js';
+import { JsxTransformer } from './transformers/jsx.js';
+import { SyntaxFacts } from './transformers/syntax-facts.js';
+import { LegacyDecorators } from './transformers/legacy-decorators.js';
+import { DecoratorMetadata } from './transformers/decorator-metadata.js';
+/** The program as emit sees it. */
+export class EmitHost {
+    options;
+    currentDirectory;
+    useCaseSensitiveFileNames;
+    commonSourceDirectoryPath;
+    resolver;
+    formats;
+    constructor(options, resolver, formats, commonSourceDirectory, currentDirectory, useCaseSensitiveFileNames) {
+        this.options = options;
+        this.resolver = resolver;
+        this.formats = formats;
+        this.currentDirectory = currentDirectory;
+        this.useCaseSensitiveFileNames = useCaseSensitiveFileNames;
+        this.commonSourceDirectoryPath = commonSourceDirectory;
+    }
+    /** With a trailing `/`. */
+    commonSourceDirectory() {
+        return this.commonSourceDirectoryPath;
+    }
+    /** Whether writing a file is blocked, as when it would overwrite an input; false by default. */
+    isEmitBlocked(_fileName) {
+        return false;
+    }
+    /**
+     * Whether the program found `file` through a module or type reference resolved in `node_modules`
+     * (`Program.isSourceFileFromExternalLibrary`); such files are not emitted. False by default.
+     */
+    isSourceFileFromExternalLibrary(_file) {
+        return false;
+    }
+}
+/** What `EmitHost.writeFile` returns for a file it chose not to write. */
+export const skippedWrite = '\u0000';
+export class EmitResult {
+    emittedFiles;
+    errors;
+    /** Files not emitted because they use syntax emit doesn't support yet, with the reason. */
+    unsupported;
+    /** Declaration emit errors; a file with any gets no declaration file. */
+    diagnostics;
+    /**
+     * For each declaration file a checker thread wrote for an incremental program, its name, its signature
+     * and the signature compared for composite projects (`DeclarationSignatureWriter`).
+     */
+    declarationSignatures;
+    /**
+     * Under `noEmitOnError`, the outputs a checker thread emitted without writing them, as file name and
+     * text alternately: the main thread writes them once it knows there are no errors (`writeHeldOutputs`).
+     */
+    heldOutputs;
+    emitSkipped;
+    /**
+     * Whether the declaration transform ran, so that `diagnostics` holds the declaration diagnostics of
+     * the files emitted (only declaration emit reports diagnostics).
+     */
+    declarationTransformed;
+    constructor() {
+        this.emittedFiles = [];
+        this.errors = [];
+        this.unsupported = [];
+        this.diagnostics = [];
+        this.declarationSignatures = [];
+        this.heldOutputs = [];
+        this.emitSkipped = false;
+        this.declarationTransformed = false;
+    }
+}
+export function sourceFileMayBeEmitted(file, options) {
+    if (file.isDeclarationFile)
+        return false;
+    if (file.scriptKind === 6 /* ScriptKind.JSON */)
+        return options.outDir !== undefined && options.outDir !== '';
+    return true;
+}
+export function emitFiles(host, files, emitOnly = 0 /* EmitOnly.All */) {
+    const result = new EmitResult();
+    const options = host.options;
+    const forced = emitOnly === 3 /* EmitOnly.ForcedDts */;
+    if (options.noEmit === true && !forced) {
+        result.emitSkipped = true;
+        return result;
+    }
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        if (!sourceFileMayBeEmitted(file, options) || host.isSourceFileFromExternalLibrary(file))
+            continue;
+        const paths = getOutputPathsFor(file.fileName, file.scriptKind === 6 /* ScriptKind.JSON */, options, host, forced);
+        if (paths.jsFilePath !== '' && (emitOnly === 0 /* EmitOnly.All */ || emitOnly === 1 /* EmitOnly.Js */)) {
+            if (host.isEmitBlocked(paths.jsFilePath))
+                result.emitSkipped = true;
+            else
+                emitJSFile(host, file, paths.jsFilePath, paths.sourceMapFilePath, result);
+        }
+        if (paths.declarationFilePath !== '' && emitOnly !== 1 /* EmitOnly.Js */) {
+            if (!forced && host.isEmitBlocked(paths.declarationFilePath))
+                result.emitSkipped = true;
+            else
+                emitDeclarationFile(host, file, paths.declarationFilePath, paths.declarationMapPath, result, forced);
+        }
+    }
+    return result;
+}
+/** Emits a declaration file; the host's resolver must be a `DeclarationEmitResolver`. */
+function emitDeclarationFile(host, file, declarationFilePath, declarationMapPath, result, forced) {
+    const resolver = host.resolver;
+    if (!(resolver instanceof DeclarationEmitResolver)) {
+        result.errors.push(file.fileName + ': declaration emit needs a declaration resolver');
+        return false;
+    }
+    const options = host.options;
+    const context = new EmitContext();
+    const transformer = new DeclarationTransformer(context, host, options, resolver, declarationFilePath);
+    const transformed = transformer.transformSourceFile(file);
+    result.declarationTransformed = true;
+    const diagnostics = transformer.diagnostics;
+    for (let i = 0; i < diagnostics.length; i++)
+        result.diagnostics.push(diagnostics[i]);
+    if (diagnostics.length > 0 && !forced) {
+        result.emitSkipped = true;
+        return false;
+    }
+    const printerOptions = new PrinterOptions();
+    printerOptions.removeComments = options.removeComments === true;
+    printerOptions.newLine = options.newLine === NewLineKind.CRLF ? '\r\n' : '\n';
+    printerOptions.noEmitHelpers = true;
+    printerOptions.target = getEmitScriptTarget(options);
+    const declarationMap = options.declarationMap === true && !forced;
+    printerOptions.sourceMap = declarationMap;
+    printerOptions.onlyPrintJSDocStyle = true;
+    printerOptions.omitBraceSourceMapPositions = true;
+    const printer = new Printer(printerOptions, context);
+    const emitSourceMaps = declarationMap && !fileExtensionIs(file.fileName, '.json');
+    return printSourceFile(host, declarationFilePath, forced ? '' : declarationMapPath, transformed, printer, emitSourceMaps, false, result, 
+    // Sorted, as tsgo's emitter diagnostics are; the order is part of the file's signature in build info.
+    diagnostics.length > 1 ? diagnostics.toSorted(compareDiagnostics) : diagnostics);
+}
+function getScriptTransformers(host, context, file) {
+    const options = host.options;
+    const facts = new TypeScriptFacts();
+    const syntax = new SyntaxFacts();
+    const transformers = [];
+    if (options.emitDecoratorMetadata === true)
+        transformers.push(new DecoratorMetadata(context, options, host.resolver, syntax));
+    transformers.push(new TypeEraser(context, options, facts));
+    if (options.verbatimModuleSyntax !== true && !file.isJS())
+        transformers.push(new ImportElision(context, options, host.resolver));
+    transformers.push(new RuntimeSyntax(context, options, facts, host.resolver));
+    if (options.experimentalDecorators === true)
+        transformers.push(new LegacyDecorators(context, options, host.resolver, syntax));
+    if (isJsxTransformEnabled(options) && file.languageVariant === 1 /* LanguageVariant.JSX */)
+        transformers.push(new JsxTransformer(context, options, syntax, host.resolver));
+    addDownlevelTransformers(transformers, context, options, syntax, host.resolver);
+    transformers.push(new UseStrictTransformer(context, options, host.formats));
+    transformers.push(createModuleTransformer(context, options, host.resolver, host.formats));
+    if (!getIsolatedModules(options))
+        transformers.push(new ConstEnumInliner(context, options, host.resolver));
+    return transformers;
+}
+function isJsxTransformEnabled(options) {
+    const jsx = options.jsx;
+    return jsx === JsxEmit.React || jsx === JsxEmit.ReactJSX || jsx === JsxEmit.ReactJSXDev;
+}
+function emitJSFile(host, file, jsFilePath, sourceMapFilePath, result) {
+    const options = host.options;
+    const context = new EmitContext();
+    let transformed = file;
+    const transformers = getScriptTransformers(host, context, file);
+    for (let i = 0; i < transformers.length; i++) {
+        const transformer = transformers[i];
+        if (transformer.unsupported === '')
+            transformed = transformer.transformSourceFile(transformed);
+        if (transformer.unsupported !== '') {
+            result.unsupported.push(file.fileName + ': ' + transformer.unsupported);
+            return false;
+        }
+    }
+    const printerOptions = new PrinterOptions();
+    printerOptions.removeComments = options.removeComments === true;
+    printerOptions.newLine = options.newLine === NewLineKind.CRLF ? '\r\n' : '\n';
+    printerOptions.noEmitHelpers = options.noEmitHelpers === true;
+    printerOptions.sourceMap = options.sourceMap === true;
+    printerOptions.inlineSourceMap = options.inlineSourceMap === true;
+    printerOptions.inlineSources = options.inlineSources === true;
+    // The target option as given, as tsgo's JavaScript printer takes it: without one, the printer's default
+    // removes numeric separators, although the transforms target the default target.
+    if (options.target !== undefined)
+        printerOptions.target = options.target;
+    const printer = new Printer(printerOptions, context);
+    const emitSourceMaps = (options.sourceMap === true || options.inlineSourceMap === true) && !fileExtensionIs(file.fileName, '.json');
+    const inline = options.inlineSourceMap === true;
+    return printSourceFile(host, jsFilePath, sourceMapFilePath, transformed, printer, emitSourceMaps, inline, result);
+}
+function printSourceFile(host, jsFilePath, sourceMapFilePath, file, printer, emitSourceMaps, inlineSourceMap, result, declarationDiagnostics = []) {
+    const options = host.options;
+    const writer = new TextWriter(printer.options.newLine, 4);
+    const generator = emitSourceMaps
+        ? new SourceMapGenerator(getBaseFileName(normalizeSlashes(jsFilePath)), getSourceRoot(options), getSourceMapDirectory(host, jsFilePath, file), host.useCaseSensitiveFileNames, host.currentDirectory)
+        : undefined;
+    printer.write(file, file, writer, generator);
+    if (generator !== undefined) {
+        const url = getSourceMappingURL(host, generator, jsFilePath, sourceMapFilePath, file, inlineSourceMap);
+        if (url !== '') {
+            if (!writer.isAtStartOfLine())
+                writer.rawWrite(options.newLine === NewLineKind.CRLF ? '\r\n' : '\n');
+            writer.writeComment('//# sourceMappingURL=');
+            writer.writeComment(url);
+        }
+        if (sourceMapFilePath !== '') {
+            const error = host.writeFile(sourceMapFilePath, generator.toJSON());
+            if (error !== '')
+                result.errors.push(error);
+            else
+                result.emittedFiles.push(sourceMapFilePath);
+        }
+    }
+    else
+        writer.writeLine(false);
+    let text = writer.getText();
+    if (options.emitBOM === true)
+        text = '\uFEFF' + text;
+    const error = host.writeFile(jsFilePath, text, declarationDiagnostics);
+    if (error === skippedWrite)
+        return true;
+    if (error !== '')
+        result.errors.push(error);
+    else
+        result.emittedFiles.push(jsFilePath);
+    return error === '';
+}
+/** `fileName` moved from the common source directory to `newDirectory`. */
+function getSourceFilePathInNewDir(fileName, newDirectory, currentDirectory, commonSourceDirectory, useCaseSensitiveFileNames) {
+    let path = getNormalizedAbsolutePath(fileName, currentDirectory);
+    const common = ensureTrailingDirectorySeparator(commonSourceDirectory);
+    if (containsPath(common, path, useCaseSensitiveFileNames, currentDirectory))
+        path = path.slice(common.length);
+    return combinePaths(newDirectory, path);
+}
+function getSourceRoot(options) {
+    const root = normalizeSlashes(options.sourceRoot !== undefined ? options.sourceRoot : '');
+    return root !== '' ? ensureTrailingDirectorySeparator(root) : root;
+}
+function mapRootDirectory(host, mapRoot, file) {
+    let directory = normalizeSlashes(mapRoot);
+    directory = getDirectoryPath(getSourceFilePathInNewDir(file.fileName, directory, host.currentDirectory, host.commonSourceDirectory(), host.useCaseSensitiveFileNames));
+    return directory;
+}
+function getSourceMapDirectory(host, jsFilePath, file) {
+    const options = host.options;
+    if (options.sourceRoot !== undefined && options.sourceRoot !== '')
+        return host.commonSourceDirectory();
+    if (options.mapRoot !== undefined && options.mapRoot !== '') {
+        const directory = mapRootDirectory(host, options.mapRoot, file);
+        return getRootLength(directory) === 0 ? combinePaths(host.commonSourceDirectory(), directory) : directory;
+    }
+    return getDirectoryPath(normalizePath(jsFilePath));
+}
+function getSourceMappingURL(host, generator, jsFilePath, sourceMapFilePath, file, inlineSourceMap) {
+    const options = host.options;
+    if (inlineSourceMap)
+        return generator.toBase64DataURL();
+    const mapFile = getBaseFileName(normalizeSlashes(sourceMapFilePath));
+    if (options.mapRoot !== undefined && options.mapRoot !== '') {
+        const directory = mapRootDirectory(host, options.mapRoot, file);
+        if (getRootLength(directory) === 0)
+            return encodeURI(getRelativePathToDirectoryOrUrl(getDirectoryPath(normalizePath(jsFilePath)), combinePaths(combinePaths(host.commonSourceDirectory(), directory), mapFile), host.useCaseSensitiveFileNames, host.currentDirectory));
+        return encodeURI(combinePaths(directory, mapFile));
+    }
+    return encodeURI(mapFile);
+}
+const hexDigits = '0123456789ABCDEF';
+/** Percent-encodes the bytes of `s` that `encodeURI` would, by UTF-8 byte as tsgo does. */
+function encodeURI(s) {
+    let out = '';
+    for (let i = 0; i < s.length; i++) {
+        const ch = s.charCodeAt(i);
+        if ((ch >= 0x41 && ch <= 0x5a) ||
+            (ch >= 0x61 && ch <= 0x7a) ||
+            (ch >= 0x30 && ch <= 0x39) ||
+            ";,/?:@&=+$-_.!~*'()#".indexOf(String.fromCharCode(ch)) >= 0) {
+            out += String.fromCharCode(ch);
+            continue;
+        }
+        const bytes = utf8Of(s, i);
+        if (ch >= 0xd800 && ch <= 0xdbff && i + 1 < s.length)
+            i++;
+        for (let b = 0; b < bytes.length; b++)
+            out += '%' + hexDigits.charAt(bytes[b] >> 4) + hexDigits.charAt(bytes[b] & 15);
+    }
+    return out;
+}
+function utf8Of(s, i) {
+    let c = s.charCodeAt(i);
+    if (c >= 0xd800 && c <= 0xdbff && i + 1 < s.length) {
+        const low = s.charCodeAt(i + 1);
+        if (low >= 0xdc00 && low <= 0xdfff)
+            c = (c - 0xd800) * 0x400 + (low - 0xdc00) + 0x10000;
+    }
+    if (c < 0x80)
+        return [c];
+    if (c < 0x800)
+        return [0xc0 | (c >> 6), 0x80 | (c & 63)];
+    if (c < 0x10000)
+        return [0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63)];
+    return [0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63)];
+}

package/dist/api/compiler/file-include.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Why each file is in a program, as `--explainFiles` prints it, and diagnostics explaining file inclusion.
+ */
+import { ObjectLiteralExpression, StringLiteral, type FileReference, type Node, type SourceFile } from './ast.js';
+import { Diagnostic, type DiagnosticMessage } from './diagnostics.js';
+import { type PackageId } from './module-resolution-types.js';
+import type { Program } from './program.js';
+export declare const enum FileIncludeKind {
+    Import = 0,
+    ReferenceFile = 1,
+    TypeReferenceDirective = 2,
+    LibReferenceDirective = 3,
+    RootFile = 4,
+    LibFile = 5,
+    AutomaticTypeDirectiveFile = 6
+}
+/** One reason a file is in the program. */
+export declare class FileIncludeReason {
+    readonly kind: FileIncludeKind;
+    /** The referencing file's path, for references from a file. */
+    readonly file: string;
+    /** The root file, `lib` entry or reference index; -1 for the default library. */
+    readonly index: number;
+    /** The synthesized specifier of an `importHelpers` or JSX runtime import. */
+    readonly synthetic: StringLiteral | undefined;
+    /** The `types` entry, for automatic type directives. */
+    readonly typeReference: string;
+    readonly packageId: PackageId | undefined;
+    private relativeDiagnostic;
+    private absoluteDiagnostic;
+    private location;
+    private relatedInfo;
+    private constructor();
+    static rootFile(index: number): FileIncludeReason;
+    /** A `lib` entry, or the default library with `index` -1. */
+    static libFile(index: number): FileIncludeReason;
+    static automaticTypeDirective(typeReference: string, packageId: PackageId | undefined): FileIncludeReason;
+    /** An import (`index` into the file's imports and module augmentations, -1 if `synthetic`) or a `///` reference. */
+    static reference(kind: FileIncludeKind, file: string, index: number, synthetic: StringLiteral | undefined): FileIncludeReason;
+    /** The same reason without what it has computed (a parse thread's reasons are immutable). */
+    copy(): FileIncludeReason;
+    isReferencedFile(): boolean;
+    getReferencedLocation(program: Program): ReferenceFileLocation;
+    /** The reason as a message, with file names relative to the current directory if `relative`. */
+    toDiagnostic(program: Program, relative: boolean): Diagnostic;
+    private computeDiagnostic;
+    private computeReferenceDiagnostic;
+    /** Where in the config or a file this reason is written, as related information; `undefined` if nowhere. */
+    toRelatedInfo(program: Program): Diagnostic | undefined;
+    private computeRelatedInfo;
+}
+/** Where a reference from a file is written. */
+export declare class ReferenceFileLocation {
+    readonly file: SourceFile;
+    /** The module specifier, for imports. */
+    readonly node: Node | undefined;
+    /** The `///` directive, for references. */
+    readonly ref: FileReference | undefined;
+    readonly packageId: PackageId | undefined;
+    readonly isSynthetic: boolean;
+    constructor(file: SourceFile, 
+    /** The module specifier, for imports. */
+    node: Node | undefined, 
+    /** The `///` directive, for references. */
+    ref: FileReference | undefined, packageId: PackageId | undefined, isSynthetic: boolean);
+    text(): string;
+    diagnosticAt(message: DiagnosticMessage, ...args: string[]): Diagnostic;
+}
+export declare const enum ProcessingDiagnosticKind {
+    /** A `/// <reference types>` or `/// <reference lib>` that could not be found. */
+    UnknownReference = 0,
+    ExplainingFileInclude = 1
+}
+/** A diagnostic found while loading files, explained with why the file is in the program once loading is done. */
+export declare class ProcessingDiagnostic {
+    readonly kind: ProcessingDiagnosticKind;
+    /** The path of the file explained; `''` if none. */
+    readonly file: string;
+    readonly reason: FileIncludeReason | undefined;
+    readonly message: DiagnosticMessage | undefined;
+    readonly args: readonly string[];
+    private constructor();
+    static unknownReference(reason: FileIncludeReason): ProcessingDiagnostic;
+    static explainingFileInclude(file: string, reason: FileIncludeReason | undefined, message: DiagnosticMessage, args: readonly string[]): ProcessingDiagnostic;
+    /** The same diagnostic with a copy of its reason (`FileIncludeReason.copy`). */
+    copy(): ProcessingDiagnostic;
+    toDiagnostic(program: Program): Diagnostic;
+    private explainFile;
+}
+/** Include reasons of every file and the diagnostics found while loading them. */
+export declare class IncludeProcessor {
+    readonly fileIncludeReasons: Map<string, FileIncludeReason[]>;
+    readonly processingDiagnostics: ProcessingDiagnostic[];
+    private computed;
+    private compilerOptionsObject;
+    private compilerOptionsComputed;
+    private readonly redirectAndFileFormat;
+    constructor(fileIncludeReasons?: Map<string, FileIncludeReason[]>, processingDiagnostics?: ProcessingDiagnostic[]);
+    /** A processor with these reasons and processing diagnostics, whose diagnostics are computed for another program. */
+    copy(): IncludeProcessor;
+    reasonsOf(path: string): readonly FileIncludeReason[];
+    addReason(path: string, reason: FileIncludeReason): void;
+    addProcessingDiagnostic(diagnostic: ProcessingDiagnostic): void;
+    /** Reports a file name that differs from an included one only in casing. */
+    addCasingDiagnostic(file: string, existingCasing: string, currentCasing: string, reason: FileIncludeReason | undefined): void;
+    getReferenceLocation(reason: FileIncludeReason, program: Program): ReferenceFileLocation;
+    /** Processing and resolution diagnostics, sorted by file. */
+    diagnostics(program: Program): readonly Diagnostic[];
+    /** The compiler options object of the config file. */
+    compilerOptionsSyntax(program: Program): ObjectLiteralExpression | undefined;
+    /**
+     * Notes on a file's origin and module format. Cached per file: the first caller's choice of relative or
+     * absolute file names sticks, as in tsgo. A shared program keeps what was cached before sharing; after that,
+     * only `--explainFiles` asks, once per file, and the result is not kept.
+     */
+    explainRedirectAndImpliedFormat(program: Program, path: string, relative: boolean): readonly Diagnostic[];
+}