name: string;

value: number;

type: StatisticType;

time,

count,

memory,

const counts = getCountsMap();

forEach(program.getSourceFiles(), file => {

const key = getCountKey(program, file);

const lineCount = getLineStarts(file).length;

counts.set(key, counts.get(key)! + lineCount);

});

return counts;

const counts = new Map<string, number>();

counts.set("Library", 0);

counts.set("Definitions", 0);

counts.set("TypeScript", 0);

counts.set("JavaScript", 0);

counts.set("JSON", 0);

counts.set("Other", 0);

return counts;

if (program.isSourceFileDefaultLibrary(file)) {

return "Library";

}

else if (file.isDeclarationFile) {

return "Definitions";

}

const path = file.path;

if (fileExtensionIsOneOf(path, supportedTSExtensionsFlat)) {

return "TypeScript";

}

else if (fileExtensionIsOneOf(path, supportedJSExtensionsFlat)) {

return "JavaScript";

}

else if (fileExtensionIs(path, Extension.Json)) {

return "JSON";

}

else {

return "Other";

}

sys: System,

existing: DiagnosticReporter,

options: CompilerOptions | BuildOptions,

): DiagnosticReporter {

return shouldBePretty(sys, options) ?

createDiagnosticReporter(sys, /*pretty*/ true) :

existing;

if (!options || typeof options.pretty === "undefined") {

return defaultIsPretty(sys);

}

return options.pretty;

// Sort our options by their names, (e.g. "--noImplicitAny" comes before "--watch")

return !!commandLine.options.all ?

toSorted(optionDeclarations.concat(tscBuildOption), (a, b) => compareStringsCaseInsensitive(a.name, b.name)) :

filter(optionDeclarations.concat(tscBuildOption), v => !!v.showInSimplifiedHelpView);

const showColors = defaultIsPretty(sys);

if (!showColors) {

return {

bold: (str: string) => str,

blue: (str: string) => str,

blueBackground: (str: string) => str,

brightWhite: (str: string) => str,

};

}

function bold(str: string) {

return `\x1b[1m${str}\x1b[22m`;

}

const isWindows = sys.getEnvironmentVariable("OS") && sys.getEnvironmentVariable("OS").toLowerCase().includes("windows");

const isWindowsTerminal = sys.getEnvironmentVariable("WT_SESSION");

const isVSCode = sys.getEnvironmentVariable("TERM_PROGRAM") && sys.getEnvironmentVariable("TERM_PROGRAM") === "vscode";

function blue(str: string) {

// Effectively Powershell and Command prompt users use cyan instead

// of blue because the default theme doesn't show blue with enough contrast.

if (isWindows && !isWindowsTerminal && !isVSCode) {

return brightWhite(str);

}

return `\x1b[94m${str}\x1b[39m`;

}

// There are ~3 types of terminal color support: 16 colors, 256 and 16m colors

// If there is richer color support, e.g. 256+ we can use extended ANSI codes which are not just generic 'blue'

// but a 'lighter blue' which is closer to the blue in the TS logo.

const supportsRicherColors = sys.getEnvironmentVariable("COLORTERM") === "truecolor" || sys.getEnvironmentVariable("TERM") === "xterm-256color";

function blueBackground(str: string) {

if (supportsRicherColors) {

return `\x1B[48;5;68m${str}\x1B[39;49m`;

}

else {

return `\x1b[44m${str}\x1B[39;49m`;

}

}

function brightWhite(str: string) {

return `\x1b[97m${str}\x1b[39m`;

}

return {

bold,

blue,

brightWhite,

blueBackground,

};

interface ValueCandidate {

// "one or more" or "any of"

valueType: string;

possibleValues: string;

}

const text: string[] = [];

const colors = createColors(sys);

// name and description

const name = getDisplayNameTextOfOption(option);

// value type and possible value

const valueCandidates = getValueCandidate(option);

const defaultValueDescription = typeof option.defaultValueDescription === "object"

? getDiagnosticText(option.defaultValueDescription)

: formatDefaultValue(

option.defaultValueDescription,

option.type === "list" || option.type === "listOrElement" ? option.element.type : option.type,

);

const terminalWidth = sys.getWidthOfTerminal?.() ?? 0;

// Note: child_process might return `terminalWidth` as undefined.

if (terminalWidth >= 80) {

let description = "";

if (option.description) {

description = getDiagnosticText(option.description);

}

text.push(...getPrettyOutput(name, description, rightAlignOfLeft, leftAlignOfRight, terminalWidth, /*colorLeft*/ true), sys.newLine);

if (showAdditionalInfoOutput(valueCandidates, option)) {

if (valueCandidates) {

text.push(...getPrettyOutput(valueCandidates.valueType, valueCandidates.possibleValues, rightAlignOfLeft, leftAlignOfRight, terminalWidth, /*colorLeft*/ false), sys.newLine);

}

if (defaultValueDescription) {

text.push(...getPrettyOutput(getDiagnosticText(Diagnostics.default_Colon), defaultValueDescription, rightAlignOfLeft, leftAlignOfRight, terminalWidth, /*colorLeft*/ false), sys.newLine);

}

}

text.push(sys.newLine);

}

else {

text.push(colors.blue(name), sys.newLine);

if (option.description) {

const description = getDiagnosticText(option.description);

text.push(description);

}

text.push(sys.newLine);

if (showAdditionalInfoOutput(valueCandidates, option)) {

if (valueCandidates) {

text.push(`${valueCandidates.valueType} ${valueCandidates.possibleValues}`);

}

if (defaultValueDescription) {

if (valueCandidates) text.push(sys.newLine);

const diagType = getDiagnosticText(Diagnostics.default_Colon);

text.push(`${diagType} ${defaultValueDescription}`);

}

text.push(sys.newLine);

}

text.push(sys.newLine);

}

return text;

function formatDefaultValue(

defaultValue: CommandLineOption["defaultValueDescription"],

type: CommandLineOption["type"],

) {

return defaultValue !== undefined && typeof type === "object"

// e.g. ScriptTarget.ES2015 -> "es6/es2015"

? arrayFrom(type.entries())

.filter(([, value]) => value === defaultValue)

.map(([name]) => name)

.join("/")

: String(defaultValue);

}

function showAdditionalInfoOutput(valueCandidates: ValueCandidate | undefined, option: CommandLineOption): boolean {

const ignoreValues = ["string"];

const ignoredDescriptions = [undefined, "false", "n/a"];

const defaultValueDescription = option.defaultValueDescription;

if (option.category === Diagnostics.Command_line_Options) return false;

if (contains(ignoreValues, valueCandidates?.possibleValues) && contains(ignoredDescriptions, defaultValueDescription)) {

return false;

}

return true;

}

function getPrettyOutput(left: string, right: string, rightAlignOfLeft: number, leftAlignOfRight: number, terminalWidth: number, colorLeft: boolean) {

const res = [];

let isFirstLine = true;

let remainRight = right;

const rightCharacterNumber = terminalWidth - leftAlignOfRight;

while (remainRight.length > 0) {

let curLeft = "";

if (isFirstLine) {

curLeft = left.padStart(rightAlignOfLeft);

curLeft = curLeft.padEnd(leftAlignOfRight);

curLeft = colorLeft ? colors.blue(curLeft) : curLeft;

}

else {

curLeft = "".padStart(leftAlignOfRight);

}

const curRight = remainRight.substr(0, rightCharacterNumber);

remainRight = remainRight.slice(rightCharacterNumber);

res.push(`${curLeft}${curRight}`);

isFirstLine = false;

}

return res;

}

function getValueCandidate(option: CommandLineOption): ValueCandidate | undefined {

// option.type might be "string" | "number" | "boolean" | "object" | "list" | Map<string, number | string>

// string -- any of: string

// number -- any of: number

// boolean -- any of: boolean

// object -- null

// list -- one or more: , content depends on `option.element.type`, the same as others

// Map<string, number | string> -- any of: key1, key2, ....

if (option.type === "object") {

return undefined;

}

return {

valueType: getValueType(option),

possibleValues: getPossibleValues(option),

};

function getValueType(option: CommandLineOption) {

Debug.assert(option.type !== "listOrElement");

switch (option.type) {

case "string":

case "number":

case "boolean":

return getDiagnosticText(Diagnostics.type_Colon);

case "list":

return getDiagnosticText(Diagnostics.one_or_more_Colon);

default:

return getDiagnosticText(Diagnostics.one_of_Colon);

}

}

function getPossibleValues(option: CommandLineOption) {

let possibleValues: string;

switch (option.type) {

case "string":

case "number":

case "boolean":

possibleValues = option.type;

break;

case "list":

case "listOrElement":

possibleValues = getPossibleValues(option.element);

break;

case "object":

possibleValues = "";

break;

default:

// Map<string, number | string>

// Group synonyms: es6/es2015

const inverted: { [value: string]: string[]; } = {};

option.type.forEach((value, name) => {

if (!option.deprecatedKeys?.has(name)) {

(inverted[value] ||= []).push(name);

}

});

return Object.entries(inverted)

.map(([, synonyms]) => synonyms.join("/"))

.join(", ");

}

return possibleValues;

}

}

let maxLength = 0;

for (const option of optionsList) {

const curLength = getDisplayNameTextOfOption(option).length;

maxLength = maxLength > curLength ? maxLength : curLength;

}

// left part should be right align, right part should be left align

// assume 2 space between left margin and left part.

const rightAlignOfLeftPart = maxLength + 2;

// assume 2 space between left and right part

const leftAlignOfRightPart = rightAlignOfLeftPart + 2;

let lines: string[] = [];

for (const option of optionsList) {

const tmp = generateOptionOutput(sys, option, rightAlignOfLeftPart, leftAlignOfRightPart);

lines = [...lines, ...tmp];

}

// make sure always a blank line in the end.

if (lines[lines.length - 2] !== sys.newLine) {

lines.push(sys.newLine);

}

return lines;

let res: string[] = [];

res.push(createColors(sys).bold(sectionName) + sys.newLine + sys.newLine);

if (beforeOptionsDescription) {

res.push(beforeOptionsDescription + sys.newLine + sys.newLine);

}

if (!subCategory) {

res = [...res, ...generateGroupOptionOutput(sys, options)];

if (afterOptionsDescription) {

res.push(afterOptionsDescription + sys.newLine + sys.newLine);

}

return res;

}

const categoryMap = new Map<string, CommandLineOption[]>();

for (const option of options) {

if (!option.category) {

continue;

}

const curCategory = getDiagnosticText(option.category);

const optionsOfCurCategory = categoryMap.get(curCategory) ?? [];

optionsOfCurCategory.push(option);

categoryMap.set(curCategory, optionsOfCurCategory);

}

categoryMap.forEach((value, key) => {

res.push(`### ${key}${sys.newLine}${sys.newLine}`);

res = [...res, ...generateGroupOptionOutput(sys, value)];

});

if (afterOptionsDescription) {

res.push(afterOptionsDescription + sys.newLine + sys.newLine);

}

return res;

const colors = createColors(sys);

let output: string[] = [...getHeader(sys, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];

output.push(colors.bold(getDiagnosticText(Diagnostics.COMMON_COMMANDS)) + sys.newLine + sys.newLine);

example("tsc", Diagnostics.Compiles_the_current_project_tsconfig_json_in_the_working_directory);

example("tsc app.ts util.ts", Diagnostics.Ignoring_tsconfig_json_compiles_the_specified_files_with_default_compiler_options);

example("tsc -b", Diagnostics.Build_a_composite_project_in_the_working_directory);

example("tsc --init", Diagnostics.Creates_a_tsconfig_json_with_the_recommended_settings_in_the_working_directory);

example("tsc -p ./path/to/tsconfig.json", Diagnostics.Compiles_the_TypeScript_project_located_at_the_specified_path);

example("tsc --help --all", Diagnostics.An_expanded_version_of_this_information_showing_all_possible_compiler_options);

example(["tsc --noEmit", "tsc --target esnext"], Diagnostics.Compiles_the_current_project_with_additional_settings);

const cliCommands = simpleOptions.filter(opt => opt.isCommandLineOnly || opt.category === Diagnostics.Command_line_Options);

const configOpts = simpleOptions.filter(opt => !contains(cliCommands, opt));

output = [

...output,

...generateSectionOptionsOutput(sys, getDiagnosticText(Diagnostics.COMMAND_LINE_FLAGS), cliCommands, /*subCategory*/ false, /*beforeOptionsDescription*/ undefined, /*afterOptionsDescription*/ undefined),

...generateSectionOptionsOutput(sys, getDiagnosticText(Diagnostics.COMMON_COMPILER_OPTIONS), configOpts, /*subCategory*/ false, /*beforeOptionsDescription*/ undefined, formatMessage(Diagnostics.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsc")),

];

for (const line of output) {

sys.write(line);

}

function example(ex: string | string[], desc: DiagnosticMessage) {

const examples = typeof ex === "string" ? [ex] : ex;

for (const example of examples) {

output.push(" " + colors.blue(example) + sys.newLine);

}

output.push(" " + getDiagnosticText(desc) + sys.newLine + sys.newLine);

}

let output: string[] = [...getHeader(sys, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];

output = [...output, ...generateSectionOptionsOutput(sys, getDiagnosticText(Diagnostics.ALL_COMPILER_OPTIONS), compilerOptions, /*subCategory*/ true, /*beforeOptionsDescription*/ undefined, formatMessage(Diagnostics.You_can_learn_about_all_of_the_compiler_options_at_0, "https://aka.ms/tsc"))];

output = [...output, ...generateSectionOptionsOutput(sys, getDiagnosticText(Diagnostics.WATCH_OPTIONS), watchOptions, /*subCategory*/ false, getDiagnosticText(Diagnostics.Including_watch_w_will_start_watching_the_current_project_for_the_file_changes_Once_set_you_can_config_watch_mode_with_Colon))];

output = [...output, ...generateSectionOptionsOutput(sys, getDiagnosticText(Diagnostics.BUILD_OPTIONS), filter(buildOptions, option => option !== tscBuildOption), /*subCategory*/ false, formatMessage(Diagnostics.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds"))];

for (const line of output) {

sys.write(line);

}

let output: string[] = [...getHeader(sys, `${getDiagnosticText(Diagnostics.tsc_Colon_The_TypeScript_Compiler)} - ${getDiagnosticText(Diagnostics.Version_0, version)}`)];

output = [...output, ...generateSectionOptionsOutput(sys, getDiagnosticText(Diagnostics.BUILD_OPTIONS), filter(buildOptions, option => option !== tscBuildOption), /*subCategory*/ false, formatMessage(Diagnostics.Using_build_b_will_make_tsc_behave_more_like_a_build_orchestrator_than_a_compiler_This_is_used_to_trigger_building_composite_projects_which_you_can_learn_more_about_at_0, "https://aka.ms/tsc-composite-builds"))];

for (const line of output) {

sys.write(line);

}

const colors = createColors(sys);

const header: string[] = [];

const terminalWidth = sys.getWidthOfTerminal?.() ?? 0;

const tsIconLength = 5;

const tsIconFirstLine = colors.blueBackground("".padStart(tsIconLength));

const tsIconSecondLine = colors.blueBackground(colors.brightWhite("TS ".padStart(tsIconLength)));

// If we have enough space, print TS icon.

if (terminalWidth >= message.length + tsIconLength) {

// right align of the icon is 120 at most.

const rightAlign = terminalWidth > 120 ? 120 : terminalWidth;

const leftAlign = rightAlign - tsIconLength;

header.push(message.padEnd(leftAlign) + tsIconFirstLine + sys.newLine);

header.push("".padStart(leftAlign) + tsIconSecondLine + sys.newLine);

}

else {

header.push(message + sys.newLine);

header.push(sys.newLine);

}

return header;

if (!commandLine.options.all) {

printEasyHelp(sys, getOptionsForHelp(commandLine));

}

else {

printAllHelp(sys, getOptionsForHelp(commandLine), optionsForBuild, optionsForWatch);

}

sys: System,

cb: ExecuteCommandLineCallbacks,

commandLine: ParsedCommandLine,

) {

let reportDiagnostic = createDiagnosticReporter(sys);

// Configuration file name (if any)

let configFileName: string | undefined;

if (commandLine.options.locale) {

validateLocaleAndSetLanguage(commandLine.options.locale, sys, commandLine.errors);

}

// If there are any errors due to command line parsing and/or

// setting up localization, report them and quit.

if (commandLine.errors.length > 0) {

commandLine.errors.forEach(reportDiagnostic);

return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);

}

if (commandLine.options.init) {

writeConfigFile(sys, reportDiagnostic, commandLine.options);

return sys.exit(ExitStatus.Success);

}

if (commandLine.options.version) {

printVersion(sys);

return sys.exit(ExitStatus.Success);

}

if (commandLine.options.help || commandLine.options.all) {

printHelp(sys, commandLine);

return sys.exit(ExitStatus.Success);

}

if (commandLine.options.watch && commandLine.options.listFilesOnly) {

reportDiagnostic(createCompilerDiagnostic(Diagnostics.Options_0_and_1_cannot_be_combined, "watch", "listFilesOnly"));

return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);

}

if (commandLine.options.project) {

if (commandLine.fileNames.length !== 0) {

reportDiagnostic(createCompilerDiagnostic(Diagnostics.Option_project_cannot_be_mixed_with_source_files_on_a_command_line));

return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);

}

const fileOrDirectory = normalizePath(commandLine.options.project);

if (!fileOrDirectory /* current directory "." */ || sys.directoryExists(fileOrDirectory)) {

configFileName = combinePaths(fileOrDirectory, "tsconfig.json");

if (!sys.fileExists(configFileName)) {

reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_specified_directory_Colon_0, commandLine.options.project));

return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);

}

}

else {

configFileName = fileOrDirectory;

if (!sys.fileExists(configFileName)) {

reportDiagnostic(createCompilerDiagnostic(Diagnostics.The_specified_path_does_not_exist_Colon_0, commandLine.options.project));

return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);

}

}

}

else if (!commandLine.options.ignoreConfig || commandLine.fileNames.length === 0) {

const searchPath = normalizePath(sys.getCurrentDirectory());

configFileName = findConfigFile(searchPath, fileName => sys.fileExists(fileName));

// if (!commandLine.options.ignoreConfig) {

if (commandLine.fileNames.length !== 0) {

if (configFileName) {

// Error to not specify config file

reportDiagnostic(createCompilerDiagnostic(Diagnostics.tsconfig_json_is_present_but_will_not_be_loaded_if_files_are_specified_on_commandline_Use_ignoreConfig_to_skip_this_error));

return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);

}

}

else if (!configFileName) {

if (commandLine.options.showConfig) {

reportDiagnostic(createCompilerDiagnostic(Diagnostics.Cannot_find_a_tsconfig_json_file_at_the_current_directory_Colon_0, normalizePath(sys.getCurrentDirectory())));

}

else {

printVersion(sys);

printHelp(sys, commandLine);

}

return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);

}

}

const currentDirectory = sys.getCurrentDirectory();

const commandLineOptions = convertToOptionsWithAbsolutePaths(

commandLine.options,

fileName => getNormalizedAbsolutePath(fileName, currentDirectory),

);

if (configFileName) {

const extendedConfigCache = new Map<string, ExtendedConfigCacheEntry>();

const configParseResult = parseConfigFileWithSystem(configFileName, commandLineOptions, extendedConfigCache, commandLine.watchOptions, sys, reportDiagnostic)!; // TODO: GH#18217

if (commandLineOptions.showConfig) {

if (configParseResult.errors.length !== 0) {

reportDiagnostic = updateReportDiagnostic(

sys,

reportDiagnostic,

configParseResult.options,

);

configParseResult.errors.forEach(reportDiagnostic);

return sys.exit(ExitStatus.DiagnosticsPresent_OutputsSkipped);

}

// eslint-disable-next-line no-restricted-syntax

sys.write(JSON.stringify(convertToTSConfig(configParseResult, configFileName, sys), null, 4) + sys.newLine);

return sys.exit(ExitStatus.Success);

}

reportDiagnostic = updateReportDiagnostic(

sys,

reportDiagnostic,

configParseResult.options,

);

if (isWatchSet(configParseResult.options)) {

if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic)) return;

return createWatchOfConfigFile(

sys,

cb,

reportDiagnostic,

configParseResult,

commandLineOptions,

commandLine.watchOptions,

extendedConfigCache,

);

}

else if (isIncrementalCompilation(configParseResult.options)) {

performIncrementalCompilation(

sys,

cb,

reportDiagnostic,

configParseResult,

);

}

else {

performCompilation(

sys,

cb,

reportDiagnostic,

configParseResult,

);

}

}

else {

if (commandLineOptions.showConfig) {

// eslint-disable-next-line no-restricted-syntax

sys.write(JSON.stringify(convertToTSConfig(commandLine, combinePaths(currentDirectory, "tsconfig.json"), sys), null, 4) + sys.newLine);

return sys.exit(ExitStatus.Success);

}

reportDiagnostic = updateReportDiagnostic(

sys,

reportDiagnostic,

commandLineOptions,

);

if (isWatchSet(commandLineOptions)) {

if (reportWatchModeWithoutSysSupport(sys, reportDiagnostic)) return;

return createWatchOfFilesAndCompilerOptions(

sys,

cb,

reportDiagnostic,

commandLine.fileNames,

commandLineOptions,

commandLine.watchOptions,

);

}

else if (isIncrementalCompilation(commandLineOptions)) {

performIncrementalCompilation(

sys,

cb,

reportDiagnostic,

{ ...commandLine, options: commandLineOptions },

);

}

else {

performCompilation(

sys,

cb,

reportDiagnostic,

{ ...commandLine, options: commandLineOptions },

);

}

}

if (commandLineArgs.length > 0 && commandLineArgs[0].charCodeAt(0) === CharacterCodes.minus) {

const firstOption = commandLineArgs[0].slice(commandLineArgs[0].charCodeAt(1) === CharacterCodes.minus ? 2 : 1).toLowerCase();

return firstOption === tscBuildOption.name || firstOption === tscBuildOption.shortName;

}

return false;

system: System,

cb: ExecuteCommandLineCallbacks,

commandLineArgs: readonly string[],

): void | SolutionBuilder<EmitAndSemanticDiagnosticsBuilderProgram> | WatchOfConfigFile<EmitAndSemanticDiagnosticsBuilderProgram> {

if (isBuildCommand(commandLineArgs)) {

const { buildOptions, watchOptions, projects, errors } = parseBuildCommand(commandLineArgs);

if (buildOptions.generateCpuProfile && system.enableCPUProfiler) {

system.enableCPUProfiler(buildOptions.generateCpuProfile, () =>

performBuild(

system,

cb,

buildOptions,

watchOptions,

projects,