import {

__String,

addInternalEmitFlags,

addRange,

addRelatedInfo,

append,

arrayFrom,

arrayIsEqualTo,

AsExpression,

AssertClause,

BuilderProgram,

CancellationToken,

canHaveDecorators,

canHaveIllegalDecorators,

chainDiagnosticMessages,

changeExtension,

changesAffectingProgramStructure,

changesAffectModuleResolution,

combinePaths,

CommentDirective,

CommentDirectivesMap,

compareDataObjects,

comparePaths,

compareValues,

Comparison,

CompilerHost,

CompilerOptions,

computeLineAndCharacterOfPosition,

concatenate,

contains,

containsIgnoredPath,

containsPath,

convertToRelativePath,

createCommentDirectivesMap,

createCompilerDiagnostic,

createCompilerDiagnosticFromMessageChain,

createDiagnosticCollection,

createDiagnosticForNodeFromMessageChain,

createDiagnosticForNodeInSourceFile,

createDiagnosticForRange,

createFileDiagnostic,

createFileDiagnosticFromMessageChain,

createGetCanonicalFileName,

createInputFilesWithFilePaths,

createModeAwareCache,

createModeAwareCacheKey,

createModuleResolutionCache,

createMultiMap,

CreateProgramOptions,

createSourceFile,

CreateSourceFileOptions,

createSymlinkCache,

createTypeChecker,

createTypeReferenceDirectiveResolutionCache,

CustomTransformers,

Debug,

DeclarationWithTypeParameterChildren,

Diagnostic,

DiagnosticArguments,

DiagnosticCategory,

diagnosticCategoryName,

DiagnosticMessage,

DiagnosticMessageChain,

DiagnosticReporter,

Diagnostics,

DiagnosticWithLocation,

directorySeparator,

DirectoryStructureHost,

emitFiles,

EmitHost,

emitModuleKindIsNonNodeESM,

EmitOnly,

EmitResult,

emptyArray,

ensureTrailingDirectorySeparator,

equateStringsCaseInsensitive,

equateStringsCaseSensitive,

explainIfFileIsRedirectAndImpliedFormat,

ExportAssignment,

ExportDeclaration,

Extension,

extensionFromPath,

externalHelpersModuleNameText,

factory,

fileExtensionIs,

fileExtensionIsOneOf,

FileIncludeKind,

FileIncludeReason,

fileIncludeReasonToDiagnostics,

FilePreprocessingDiagnostics,

FilePreprocessingDiagnosticsKind,

FileReference,

filter,

find,

findIndex,

firstDefinedIterator,

flatMap,

flatten,

forEach,

forEachAncestorDirectory,

forEachChild,

forEachChildRecursively,

forEachEmittedFile,

forEachEntry,

forEachKey,

forEachPropertyAssignment,

forEachResolvedProjectReference as ts_forEachResolvedProjectReference,

forEachTsConfigPropArray,

FunctionLikeDeclaration,

getAllowJSCompilerOption,

getAutomaticTypeDirectiveNames,

getBaseFileName,

GetCanonicalFileName,

getCommonSourceDirectory as ts_getCommonSourceDirectory,

getCommonSourceDirectoryOfConfig,

getDeclarationDiagnostics as ts_getDeclarationDiagnostics,

getDefaultLibFileName,

getDirectoryPath,

getEmitDeclarations,

getEmitModuleKind,

getEmitModuleResolutionKind,

getEmitScriptTarget,

getErrorSpanForNode,

getExternalModuleName,

getIsolatedModules,

getJSXImplicitImportBase,

getJSXRuntimeImport,

getLineAndCharacterOfPosition,

getLineStarts,

getMatchedFileSpec,

getMatchedIncludeSpec,

getNewLineCharacter,

getNormalizedAbsolutePath,

getNormalizedAbsolutePathWithoutRoot,

getNormalizedPathComponents,

getOutputDeclarationFileName,

getOutputPathsForBundle,

getPackageScopeForPath,

getPathFromPathComponents,

getPositionOfLineAndCharacter,

getPropertyArrayElementValue,

getResolvedModule,

getResolveJsonModule,

getRootLength,

getSetExternalModuleIndicator,

getSpellingSuggestion,

getStrictOptionValue,

getSupportedExtensions,

getSupportedExtensionsWithJsonIfResolveJsonModule,

getTemporaryModuleResolutionState,

getTextOfIdentifierOrLiteral,

getTransformers,

getTsBuildInfoEmitOutputFilePath,

getTsConfigObjectLiteralExpression,

getTsConfigPropArrayElementValue,

getTypesPackageName,

HasChangedAutomaticTypeDirectiveNames,

hasChangesInResolutions,

hasExtension,

HasInvalidatedLibResolutions,

HasInvalidatedResolutions,

hasJSDocNodes,

hasJSFileExtension,

hasJsonModuleEmitEnabled,

hasProperty,

hasSyntacticModifier,

hasZeroOrOneAsteriskCharacter,

HeritageClause,

Identifier,

identity,

ImportClause,

ImportDeclaration,

ImportOrExportSpecifier,

InputFiles,

InternalEmitFlags,

inverseJsxOptionMap,

isAmbientModule,

isAnyImportOrReExport,

isArray,

isArrayLiteralExpression,

isBuildInfoFile,

isCheckJsEnabledForFile,

isClassDeclaration,

isDeclarationFileName,

isDecorator,

isDefaultModifier,

isExportDeclaration,

isExportModifier,

isExternalModule,

isExternalModuleNameRelative,

isIdentifierText,

isImportCall,

isImportDeclaration,

isImportEqualsDeclaration,

isImportSpecifier,

isImportTypeNode,

isIncrementalCompilation,

isInJSFile,

isLiteralImportTypeNode,

isModifier,

isModuleDeclaration,

isObjectLiteralExpression,

isParameter,

isPlainJsFile,

isRequireCall,

isRootedDiskPath,

isSourceFileJS,

isString,

isStringLiteral,

isStringLiteralLike,

isTraceEnabled,

JsonSourceFile,

JsxEmit,

length,

libMap,

LibResolution,

libs,

mapDefined,

mapDefinedIterator,

maybeBind,

memoize,

MethodDeclaration,

ModeAwareCache,

ModeAwareCacheKey,

ModifierFlags,

ModifierLike,

ModuleBlock,

ModuleDeclaration,

ModuleKind,

ModuleResolutionCache,

ModuleResolutionHost,

moduleResolutionIsEqualTo,

ModuleResolutionKind,

moduleResolutionSupportsPackageJsonExportsAndImports,

Mutable,

Node,

NodeArray,

NodeFlags,

nodeModulesPathPart,

NodeWithTypeArguments,

noop,

normalizePath,

notImplementedResolver,

noTransformers,

ObjectLiteralExpression,

OperationCanceledException,

optionsHaveChanges,

outFile,

PackageId,

packageIdToPackageName,

packageIdToString,

PackageJsonInfoCache,

padLeft,

ParameterDeclaration,

ParseConfigFileHost,

ParsedCommandLine,

parseIsolatedEntityName,

parseJsonSourceFileConfigFileContent,

parseNodeFactory,

Path,

pathIsAbsolute,

pathIsRelative,

Program,

ProgramHost,

ProjectReference,

ProjectReferenceFile,

projectReferenceIsEqualTo,

PropertyAssignment,

PropertyDeclaration,

ReferencedFile,

removeFileExtension,

removePrefix,

removeSuffix,

resolutionExtensionIsTSOrJson,

ResolutionMode,

resolveConfigFileProjectName,

ResolvedConfigFileName,

ResolvedModuleFull,

ResolvedModuleWithFailedLookupLocations,

ResolvedProjectReference,

ResolvedTypeReferenceDirectiveWithFailedLookupLocations,

resolveLibrary,

resolveModuleName,

resolveTypeReferenceDirective,

returnFalse,

returnUndefined,

SatisfiesExpression,

ScriptKind,

ScriptTarget,

setParent,

setParentRecursive,

setResolvedModule,

setResolvedTypeReferenceDirective,

shouldResolveJsRequire,

skipTrivia,

skipTypeChecking,

some,

sortAndDeduplicateDiagnostics,

SortedReadonlyArray,

SourceFile,

sourceFileAffectingCompilerOptions,

sourceFileMayBeEmitted,

SourceOfProjectReferenceRedirect,

stableSort,

startsWith,

Statement,

stringContains,

StringLiteral,

StringLiteralLike,

StructureIsReused,

supportedJSExtensionsFlat,

SymlinkCache,

SyntaxKind,

sys,

System,

targetOptionDeclaration,

toFileNameLowerCase,

tokenToString,

toPath as ts_toPath,

trace,

tracing,

trimStringEnd,

TsConfigSourceFile,

TypeChecker,

typeDirectiveIsEqualTo,

TypeReferenceDirectiveResolutionCache,

UnparsedSource,

VariableDeclaration,

VariableStatement,

Version,

versionMajorMinor,

walkUpParenthesizedExpressions,

WriteFileCallback,

WriteFileCallbackData,

writeFileEnsuringDirectories,

zipToModeAwareCache,

} from "./_namespaces/ts";

import * as performance from "./_namespaces/ts.performance";

export function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName = "tsconfig.json"): string | undefined {

return forEachAncestorDirectory(searchPath, ancestor => {

const fileName = combinePaths(ancestor, configName);

return fileExists(fileName) ? fileName : undefined;

});

}

export function resolveTripleslashReference(moduleName: string, containingFile: string): string {

const basePath = getDirectoryPath(containingFile);

const referencedFileName = isRootedDiskPath(moduleName) ? moduleName : combinePaths(basePath, moduleName);

return normalizePath(referencedFileName);

}

/** @internal */

export function computeCommonSourceDirectoryOfFilenames(fileNames: readonly string[], currentDirectory: string, getCanonicalFileName: GetCanonicalFileName): string {

let commonPathComponents: string[] | undefined;

const failed = forEach(fileNames, sourceFile => {

// Each file contributes into common source file path

const sourcePathComponents = getNormalizedPathComponents(sourceFile, currentDirectory);

sourcePathComponents.pop(); // The base file name is not part of the common directory path

if (!commonPathComponents) {

// first file

commonPathComponents = sourcePathComponents;

return;

}

const n = Math.min(commonPathComponents.length, sourcePathComponents.length);

for (let i = 0; i < n; i++) {

if (getCanonicalFileName(commonPathComponents[i]) !== getCanonicalFileName(sourcePathComponents[i])) {

if (i === 0) {

// Failed to find any common path component

return true;

}

// New common path found that is 0 -> i-1

commonPathComponents.length = i;

break;

}

}

// If the sourcePathComponents was shorter than the commonPathComponents, truncate to the sourcePathComponents

if (sourcePathComponents.length < commonPathComponents.length) {

commonPathComponents.length = sourcePathComponents.length;

}

});

// A common path can not be found when paths span multiple drives on windows, for example

if (failed) {

return "";

}

if (!commonPathComponents) { // Can happen when all input files are .d.ts files

return currentDirectory;

}

return getPathFromPathComponents(commonPathComponents);

}

export function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost {

return createCompilerHostWorker(options, setParentNodes);

}

/** @internal */

export function createGetSourceFile(

readFile: ProgramHost<any>["readFile"],

getCompilerOptions: () => CompilerOptions,

setParentNodes: boolean | undefined

): CompilerHost["getSourceFile"] {

return (fileName, languageVersionOrOptions, onError) => {

let text: string | undefined;

try {

performance.mark("beforeIORead");

text = readFile(fileName, getCompilerOptions().charset);

performance.mark("afterIORead");

performance.measure("I/O Read", "beforeIORead", "afterIORead");

}

catch (e) {

if (onError) {

onError(e.message);

}

text = "";

}

return text !== undefined ? createSourceFile(fileName, text, languageVersionOrOptions, setParentNodes) : undefined;

};

}

/** @internal */

export function createWriteFileMeasuringIO(

actualWriteFile: (path: string, data: string, writeByteOrderMark: boolean) => void,

createDirectory: (path: string) => void,

directoryExists: (path: string) => boolean

): CompilerHost["writeFile"] {

return (fileName, data, writeByteOrderMark, onError) => {

try {

performance.mark("beforeIOWrite");

// NOTE: If patchWriteFileEnsuringDirectory has been called,

// the system.writeFile will do its own directory creation and

// the ensureDirectoriesExist call will always be redundant.

writeFileEnsuringDirectories(

fileName,

data,

writeByteOrderMark,

actualWriteFile,

createDirectory,

directoryExists

);

performance.mark("afterIOWrite");

performance.measure("I/O Write", "beforeIOWrite", "afterIOWrite");

}

catch (e) {

if (onError) {

onError(e.message);

}

}

};

}

/** @internal */

export function createCompilerHostWorker(options: CompilerOptions, setParentNodes?: boolean, system: System = sys): CompilerHost {

const existingDirectories = new Map<string, boolean>();

const getCanonicalFileName = createGetCanonicalFileName(system.useCaseSensitiveFileNames);

function directoryExists(directoryPath: string): boolean {

if (existingDirectories.has(directoryPath)) {

return true;

}

if ((compilerHost.directoryExists || system.directoryExists)(directoryPath)) {

existingDirectories.set(directoryPath, true);

return true;

}

return false;

}

function getDefaultLibLocation(): string {

return getDirectoryPath(normalizePath(system.getExecutingFilePath()));

}

const newLine = getNewLineCharacter(options);

const realpath = system.realpath && ((path: string) => system.realpath!(path));

const compilerHost: CompilerHost = {

getSourceFile: createGetSourceFile(fileName => compilerHost.readFile(fileName), () => options, setParentNodes),

getDefaultLibLocation,

getDefaultLibFileName: options => combinePaths(getDefaultLibLocation(), getDefaultLibFileName(options)),

writeFile: createWriteFileMeasuringIO(

(path, data, writeByteOrderMark) => system.writeFile(path, data, writeByteOrderMark),

path => (compilerHost.createDirectory || system.createDirectory)(path),

path => directoryExists(path),

),

getCurrentDirectory: memoize(() => system.getCurrentDirectory()),

useCaseSensitiveFileNames: () => system.useCaseSensitiveFileNames,

getCanonicalFileName,

getNewLine: () => newLine,

fileExists: fileName => system.fileExists(fileName),

readFile: fileName => system.readFile(fileName),

trace: (s: string) => system.write(s + newLine),

directoryExists: directoryName => system.directoryExists(directoryName),

getEnvironmentVariable: name => system.getEnvironmentVariable ? system.getEnvironmentVariable(name) : "",

getDirectories: (path: string) => system.getDirectories(path),

realpath,

readDirectory: (path, extensions, include, exclude, depth) => system.readDirectory(path, extensions, include, exclude, depth),

createDirectory: d => system.createDirectory(d),

createHash: maybeBind(system, system.createHash)

};

return compilerHost;

}

/** @internal */

export interface CompilerHostLikeForCache {

fileExists(fileName: string): boolean;

readFile(fileName: string, encoding?: string): string | undefined;

directoryExists?(directory: string): boolean;

createDirectory?(directory: string): void;

writeFile?: WriteFileCallback;

}

/** @internal */

export function changeCompilerHostLikeToUseCache(

host: CompilerHostLikeForCache,

toPath: (fileName: string) => Path,

getSourceFile?: CompilerHost["getSourceFile"]

) {

const originalReadFile = host.readFile;

const originalFileExists = host.fileExists;

const originalDirectoryExists = host.directoryExists;

const originalCreateDirectory = host.createDirectory;

const originalWriteFile = host.writeFile;

const readFileCache = new Map<Path, string | false>();

const fileExistsCache = new Map<Path, boolean>();

const directoryExistsCache = new Map<Path, boolean>();

const sourceFileCache = new Map<ResolutionMode, Map<Path, SourceFile>>();

const readFileWithCache = (fileName: string): string | undefined => {

const key = toPath(fileName);

const value = readFileCache.get(key);

if (value !== undefined) return value !== false ? value : undefined;

return setReadFileCache(key, fileName);

};

const setReadFileCache = (key: Path, fileName: string) => {

const newValue = originalReadFile.call(host, fileName);

readFileCache.set(key, newValue !== undefined ? newValue : false);

return newValue;

};

host.readFile = fileName => {

const key = toPath(fileName);

const value = readFileCache.get(key);

if (value !== undefined) return value !== false ? value : undefined; // could be .d.ts from output

// Cache json or buildInfo

if (!fileExtensionIs(fileName, Extension.Json) && !isBuildInfoFile(fileName)) {

return originalReadFile.call(host, fileName);

}

return setReadFileCache(key, fileName);

};

const getSourceFileWithCache: CompilerHost["getSourceFile"] | undefined = getSourceFile ? (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {

const key = toPath(fileName);

const impliedNodeFormat: ResolutionMode = typeof languageVersionOrOptions === "object" ? languageVersionOrOptions.impliedNodeFormat : undefined;

const forImpliedNodeFormat = sourceFileCache.get(impliedNodeFormat);

const value = forImpliedNodeFormat?.get(key);

if (value) return value;

const sourceFile = getSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);

if (sourceFile && (isDeclarationFileName(fileName) || fileExtensionIs(fileName, Extension.Json))) {

sourceFileCache.set(impliedNodeFormat, (forImpliedNodeFormat || new Map()).set(key, sourceFile));

}

return sourceFile;

} : undefined;

// fileExists for any kind of extension

host.fileExists = fileName => {

const key = toPath(fileName);

const value = fileExistsCache.get(key);

if (value !== undefined) return value;

const newValue = originalFileExists.call(host, fileName);

fileExistsCache.set(key, !!newValue);

return newValue;

};

if (originalWriteFile) {

host.writeFile = (fileName, data, ...rest) => {

const key = toPath(fileName);

fileExistsCache.delete(key);

const value = readFileCache.get(key);

if (value !== undefined && value !== data) {

readFileCache.delete(key);

sourceFileCache.forEach(map => map.delete(key));

}

else if (getSourceFileWithCache) {

sourceFileCache.forEach(map => {

const sourceFile = map.get(key);

if (sourceFile && sourceFile.text !== data) {

map.delete(key);

}

});

}

originalWriteFile.call(host, fileName, data, ...rest);

};

}

// directoryExists

if (originalDirectoryExists) {

host.directoryExists = directory => {

const key = toPath(directory);

const value = directoryExistsCache.get(key);

if (value !== undefined) return value;

const newValue = originalDirectoryExists.call(host, directory);

directoryExistsCache.set(key, !!newValue);

return newValue;

};

if (originalCreateDirectory) {

host.createDirectory = directory => {

const key = toPath(directory);

directoryExistsCache.delete(key);

originalCreateDirectory.call(host, directory);

};

}

}

return {

originalReadFile,

originalFileExists,

originalDirectoryExists,

originalCreateDirectory,

originalWriteFile,

getSourceFileWithCache,

readFileWithCache

};

}

export function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[];

/** @internal */ export function getPreEmitDiagnostics(program: BuilderProgram, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[]; // eslint-disable-line @typescript-eslint/unified-signatures

export function getPreEmitDiagnostics(program: Program | BuilderProgram, sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[] {

let diagnostics: Diagnostic[] | undefined;

diagnostics = addRange(diagnostics, program.getConfigFileParsingDiagnostics());

diagnostics = addRange(diagnostics, program.getOptionsDiagnostics(cancellationToken));

diagnostics = addRange(diagnostics, program.getSyntacticDiagnostics(sourceFile, cancellationToken));

diagnostics = addRange(diagnostics, program.getGlobalDiagnostics(cancellationToken));

diagnostics = addRange(diagnostics, program.getSemanticDiagnostics(sourceFile, cancellationToken));

if (getEmitDeclarations(program.getCompilerOptions())) {

diagnostics = addRange(diagnostics, program.getDeclarationDiagnostics(sourceFile, cancellationToken));

}

return sortAndDeduplicateDiagnostics(diagnostics || emptyArray);

}

export interface FormatDiagnosticsHost {

getCurrentDirectory(): string;

getCanonicalFileName(fileName: string): string;

getNewLine(): string;

}

export function formatDiagnostics(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string {

let output = "";

for (const diagnostic of diagnostics) {

output += formatDiagnostic(diagnostic, host);

}

return output;

}

export function formatDiagnostic(diagnostic: Diagnostic, host: FormatDiagnosticsHost): string {

const errorMessage = `${diagnosticCategoryName(diagnostic)} TS${diagnostic.code}: ${flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine())}${host.getNewLine()}`;

if (diagnostic.file) {

const { line, character } = getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start!); // TODO: GH#18217

const fileName = diagnostic.file.fileName;

const relativeFileName = convertToRelativePath(fileName, host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName));

return `${relativeFileName}(${line + 1},${character + 1}): ` + errorMessage;

}

return errorMessage;

}

/** @internal */

export enum ForegroundColorEscapeSequences {

Grey = "\u001b[90m",

Red = "\u001b[91m",

Yellow = "\u001b[93m",

Blue = "\u001b[94m",

Cyan = "\u001b[96m"

}

const gutterStyleSequence = "\u001b[7m";

const gutterSeparator = " ";

const resetEscapeSequence = "\u001b[0m";

const ellipsis = "...";

const halfIndent = " ";

const indent = " ";

function getCategoryFormat(category: DiagnosticCategory): ForegroundColorEscapeSequences {

switch (category) {

case DiagnosticCategory.Error: return ForegroundColorEscapeSequences.Red;

case DiagnosticCategory.Warning: return ForegroundColorEscapeSequences.Yellow;

case DiagnosticCategory.Suggestion: return Debug.fail("Should never get an Info diagnostic on the command line.");

case DiagnosticCategory.Message: return ForegroundColorEscapeSequences.Blue;

}

}

/** @internal */

export function formatColorAndReset(text: string, formatStyle: string) {

return formatStyle + text + resetEscapeSequence;

}

function formatCodeSpan(file: SourceFile, start: number, length: number, indent: string, squiggleColor: ForegroundColorEscapeSequences, host: FormatDiagnosticsHost) {

const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start);

const { line: lastLine, character: lastLineChar } = getLineAndCharacterOfPosition(file, start + length);

const lastLineInFile = getLineAndCharacterOfPosition(file, file.text.length).line;

const hasMoreThanFiveLines = (lastLine - firstLine) >= 4;

let gutterWidth = (lastLine + 1 + "").length;

if (hasMoreThanFiveLines) {

gutterWidth = Math.max(ellipsis.length, gutterWidth);

}

let context = "";

for (let i = firstLine; i <= lastLine; i++) {

context += host.getNewLine();

// If the error spans over 5 lines, we'll only show the first 2 and last 2 lines,

// so we'll skip ahead to the second-to-last line.

if (hasMoreThanFiveLines && firstLine + 1 < i && i < lastLine - 1) {

context += indent + formatColorAndReset(padLeft(ellipsis, gutterWidth), gutterStyleSequence) + gutterSeparator + host.getNewLine();

i = lastLine - 1;

}

const lineStart = getPositionOfLineAndCharacter(file, i, 0);

const lineEnd = i < lastLineInFile ? getPositionOfLineAndCharacter(file, i + 1, 0) : file.text.length;

let lineContent = file.text.slice(lineStart, lineEnd);

lineContent = trimStringEnd(lineContent); // trim from end

lineContent = lineContent.replace(/\t/g, " "); // convert tabs to single spaces

// Output the gutter and the actual contents of the line.

context += indent + formatColorAndReset(padLeft(i + 1 + "", gutterWidth), gutterStyleSequence) + gutterSeparator;

context += lineContent + host.getNewLine();

// Output the gutter and the error span for the line using tildes.

context += indent + formatColorAndReset(padLeft("", gutterWidth), gutterStyleSequence) + gutterSeparator;

context += squiggleColor;

if (i === firstLine) {

// If we're on the last line, then limit it to the last character of the last line.

// Otherwise, we'll just squiggle the rest of the line, giving 'slice' no end position.

const lastCharForLine = i === lastLine ? lastLineChar : undefined;

context += lineContent.slice(0, firstLineChar).replace(/\S/g, " ");

context += lineContent.slice(firstLineChar, lastCharForLine).replace(/./g, "~");

}

else if (i === lastLine) {

context += lineContent.slice(0, lastLineChar).replace(/./g, "~");

}

else {

// Squiggle the entire line.

context += lineContent.replace(/./g, "~");

}

context += resetEscapeSequence;

}

return context;

}

/** @internal */

export function formatLocation(file: SourceFile, start: number, host: FormatDiagnosticsHost, color = formatColorAndReset) {

const { line: firstLine, character: firstLineChar } = getLineAndCharacterOfPosition(file, start); // TODO: GH#18217

const relativeFileName = host ? convertToRelativePath(file.fileName, host.getCurrentDirectory(), fileName => host.getCanonicalFileName(fileName)) : file.fileName;

let output = "";

output += color(relativeFileName, ForegroundColorEscapeSequences.Cyan);

output += ":";

output += color(`${firstLine + 1}`, ForegroundColorEscapeSequences.Yellow);

output += ":";

output += color(`${firstLineChar + 1}`, ForegroundColorEscapeSequences.Yellow);

return output;

}

export function formatDiagnosticsWithColorAndContext(diagnostics: readonly Diagnostic[], host: FormatDiagnosticsHost): string {

let output = "";

for (const diagnostic of diagnostics) {

if (diagnostic.file) {

const { file, start } = diagnostic;

output += formatLocation(file, start!, host); // TODO: GH#18217

output += " - ";

}

output += formatColorAndReset(diagnosticCategoryName(diagnostic), getCategoryFormat(diagnostic.category));

output += formatColorAndReset(` TS${diagnostic.code}: `, ForegroundColorEscapeSequences.Grey);

output += flattenDiagnosticMessageText(diagnostic.messageText, host.getNewLine());

if (diagnostic.file && diagnostic.code !== Diagnostics.File_appears_to_be_binary.code) {

output += host.getNewLine();

output += formatCodeSpan(diagnostic.file, diagnostic.start!, diagnostic.length!, "", getCategoryFormat(diagnostic.category), host); // TODO: GH#18217

}

if (diagnostic.relatedInformation) {

output += host.getNewLine();

for (const { file, start, length, messageText } of diagnostic.relatedInformation) {

if (file) {

output += host.getNewLine();

output += halfIndent + formatLocation(file, start!, host); // TODO: GH#18217

output += formatCodeSpan(file, start!, length!, indent, ForegroundColorEscapeSequences.Cyan, host); // TODO: GH#18217

}

output += host.getNewLine();

output += indent + flattenDiagnosticMessageText(messageText, host.getNewLine());

}

}

output += host.getNewLine();

}

return output;

}

export function flattenDiagnosticMessageText(diag: string | DiagnosticMessageChain | undefined, newLine: string, indent = 0): string {

if (isString(diag)) {

return diag;

}

else if (diag === undefined) {

return "";

}

let result = "";

if (indent) {

result += newLine;

for (let i = 0; i < indent; i++) {

result += " ";

}

}

result += diag.messageText;

indent++;

if (diag.next) {

for (const kid of diag.next) {

result += flattenDiagnosticMessageText(kid, newLine, indent);

}

}

return result;

}

/**

* Subset of a SourceFile used to calculate index-based resolutions

* This includes some internal fields, so unless you have very good reason,

* (and are willing to use some less stable internals) you should probably just pass a SourceFile.

*

* @internal

*/

export interface SourceFileImportsList {

/** @internal */ imports: SourceFile["imports"];

/** @internal */ moduleAugmentations: SourceFile["moduleAugmentations"];

impliedNodeFormat?: ResolutionMode;

}

/**

* Calculates the resulting resolution mode for some reference in some file - this is generally the explicitly

* provided resolution mode in the reference, unless one is not present, in which case it is the mode of the containing file.

*/

export function getModeForFileReference(ref: FileReference | string, containingFileMode: ResolutionMode) {

return (isString(ref) ? containingFileMode : ref.resolutionMode) || containingFileMode;

}

/**

* Calculates the final resolution mode for an import at some index within a file's imports list. This is generally the explicitly

* defined mode of the import if provided, or, if not, the mode of the containing file (with some exceptions: import=require is always commonjs, dynamic import is always esm).

* If you have an actual import node, prefer using getModeForUsageLocation on the reference string node.

* @param file File to fetch the resolution mode within

* @param index Index into the file's complete resolution list to get the resolution of - this is a concatenation of the file's imports and module augmentations

*/

export function getModeForResolutionAtIndex(file: SourceFile, index: number): ResolutionMode;

/** @internal */

// eslint-disable-next-line @typescript-eslint/unified-signatures

export function getModeForResolutionAtIndex(file: SourceFileImportsList, index: number): ResolutionMode;

export function getModeForResolutionAtIndex(file: SourceFileImportsList, index: number): ResolutionMode {

if (file.impliedNodeFormat === undefined) return undefined;

// we ensure all elements of file.imports and file.moduleAugmentations have the relevant parent pointers set during program setup,

// so it's safe to use them even pre-bind

return getModeForUsageLocation(file, getModuleNameStringLiteralAt(file, index));

}

/** @internal */

export function isExclusivelyTypeOnlyImportOrExport(decl: ImportDeclaration | ExportDeclaration) {

if (isExportDeclaration(decl)) {

return decl.isTypeOnly;

}

if (decl.importClause?.isTypeOnly) {

return true;

}

return false;

}

/**

* Calculates the final resolution mode for a given module reference node. This is generally the explicitly provided resolution mode, if

* one exists, or the mode of the containing source file. (Excepting import=require, which is always commonjs, and dynamic import, which is always esm).

* Notably, this function always returns `undefined` if the containing file has an `undefined` `impliedNodeFormat` - this field is only set when

* `moduleResolution` is `node16`+.

* @param file The file the import or import-like reference is contained within

* @param usage The module reference string

* @returns The final resolution mode of the import

*/

export function getModeForUsageLocation(file: { impliedNodeFormat?: ResolutionMode }, usage: StringLiteralLike) {

if (file.impliedNodeFormat === undefined) return undefined;

if ((isImportDeclaration(usage.parent) || isExportDeclaration(usage.parent))) {

const isTypeOnly = isExclusivelyTypeOnlyImportOrExport(usage.parent);

if (isTypeOnly) {

const override = getResolutionModeOverrideForClause(usage.parent.assertClause);

if (override) {

return override;

}

}

}

if (usage.parent.parent && isImportTypeNode(usage.parent.parent)) {

const override = getResolutionModeOverrideForClause(usage.parent.parent.assertions?.assertClause);

if (override) {

return override;

}

}

if (file.impliedNodeFormat !== ModuleKind.ESNext) {

// in cjs files, import call expressions are esm format, otherwise everything is cjs

return isImportCall(walkUpParenthesizedExpressions(usage.parent)) ? ModuleKind.ESNext : ModuleKind.CommonJS;

}

// in esm files, import=require statements are cjs format, otherwise everything is esm

// imports are only parent'd up to their containing declaration/expression, so access farther parents with care

const exprParentParent = walkUpParenthesizedExpressions(usage.parent)?.parent;

return exprParentParent && isImportEqualsDeclaration(exprParentParent) ? ModuleKind.CommonJS : ModuleKind.ESNext;

}

/** @internal */

export function getResolutionModeOverrideForClause(clause: AssertClause | undefined, grammarErrorOnNode?: (node: Node, diagnostic: DiagnosticMessage) => void) {

if (!clause) return undefined;

if (length(clause.elements) !== 1) {

grammarErrorOnNode?.(clause, Diagnostics.Type_import_assertions_should_have_exactly_one_key_resolution_mode_with_value_import_or_require);

return undefined;

}

const elem = clause.elements[0];

if (!isStringLiteralLike(elem.name)) return undefined;

if (elem.name.text !== "resolution-mode") {

grammarErrorOnNode?.(elem.name, Diagnostics.resolution_mode_is_the_only_valid_key_for_type_import_assertions);

return undefined;

}

if (!isStringLiteralLike(elem.value)) return undefined;

if (elem.value.text !== "import" && elem.value.text !== "require") {

grammarErrorOnNode?.(elem.value, Diagnostics.resolution_mode_should_be_either_require_or_import);

return undefined;

}

return elem.value.text === "import" ? ModuleKind.ESNext : ModuleKind.CommonJS;

}

const emptyResolution: ResolvedModuleWithFailedLookupLocations & ResolvedTypeReferenceDirectiveWithFailedLookupLocations = {

resolvedModule: undefined,

resolvedTypeReferenceDirective: undefined,

};

/** @internal */

export interface ResolutionNameAndModeGetter<Entry, SourceFile> {

getName(entry: Entry): string;

getMode(entry: Entry, file: SourceFile): ResolutionMode;

}

/** @internal */

export interface ResolutionLoader<Entry, Resolution, SourceFile> {

nameAndMode: ResolutionNameAndModeGetter<Entry, SourceFile>;

resolve(name: string, mode: ResolutionMode): Resolution;

}

function getModuleResolutionName(literal: StringLiteralLike) {

return literal.text;

}

/** @internal */

export const moduleResolutionNameAndModeGetter: ResolutionNameAndModeGetter<StringLiteralLike, SourceFile> = {

getName: getModuleResolutionName,

getMode: (entry, file) => getModeForUsageLocation(file, entry),

};

/** @internal */

export function createModuleResolutionLoader(

containingFile: string,

redirectedReference: ResolvedProjectReference | undefined,

options: CompilerOptions,

host: ModuleResolutionHost,

cache: ModuleResolutionCache | undefined,

): ResolutionLoader<StringLiteralLike, ResolvedModuleWithFailedLookupLocations, SourceFile> {

return {

nameAndMode: moduleResolutionNameAndModeGetter,

resolve: (moduleName, resolutionMode) => resolveModuleName(

moduleName,

containingFile,

options,

host,

cache,

redirectedReference,

resolutionMode,

),

};

}

function getTypeReferenceResolutionName<T extends FileReference | string>(entry: T) {

// We lower-case all type references because npm automatically lowercases all packages. See GH#9824.

return !isString(entry) ? toFileNameLowerCase(entry.fileName) : entry;

}

/** @internal */

export const typeReferenceResolutionNameAndModeGetter: ResolutionNameAndModeGetter<FileReference | string, SourceFile | undefined> = {

getName: getTypeReferenceResolutionName,

getMode: (entry, file) => getModeForFileReference(entry, file?.impliedNodeFormat),

};

/** @internal */