if (optionNameMapCache) {

return optionNameMapCache;

}

const optionNameMap: Map<CommandLineOption> = {};

const shortOptionNames: Map<string> = {};

forEach(optionDeclarations, option => {

optionNameMap[option.name.toLowerCase()] = option;

if (option.shortName) {

shortOptionNames[option.shortName] = option.name;

}

});

optionNameMapCache = { optionNameMap, shortOptionNames };

return optionNameMapCache;

const namesOfType: string[] = [];

forEachKey(opt.type, key => {

namesOfType.push(` '${key}'`);

});

return createCompilerDiagnostic(Diagnostics.Argument_for_0_option_must_be_Colon_1, `--${opt.name}`, namesOfType);

const key = (value || "").trim().toLowerCase();

const map = opt.type;

if (hasProperty(map, key)) {

return map[key];

}

else {

errors.push(createCompilerDiagnosticForInvalidCustomType(opt));

}

const values = (value || "").trim().split(",");

switch (opt.element.type) {

case "number":

return ts.map(values, parseInt);

case "string":

return ts.map(values, v => v || "");

default:

return filter(map(values, v => parseCustomTypeOption(<CommandLineOptionOfCustomType>opt.element, v, errors)), v => !!v);

}

const options: CompilerOptions = {};

const fileNames: string[] = [];

const errors: Diagnostic[] = [];

const { optionNameMap, shortOptionNames } = getOptionNameMap();

parseStrings(commandLine);

return {

options,

fileNames,

errors

};

function parseStrings(args: string[]) {

let i = 0;

while (i < args.length) {

let s = args[i];

i++;

if (s.charCodeAt(0) === CharacterCodes.at) {

parseResponseFile(s.slice(1));

}

else if (s.charCodeAt(0) === CharacterCodes.minus) {

s = s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1).toLowerCase();

// Try to translate short option names to their full equivalents.

if (hasProperty(shortOptionNames, s)) {

s = shortOptionNames[s];

}

if (hasProperty(optionNameMap, s)) {

const opt = optionNameMap[s];

if (opt.isTSConfigOnly) {

errors.push(createCompilerDiagnostic(Diagnostics.Option_0_can_only_be_specified_in_tsconfig_json_file, opt.name));

}

else {

// Check to see if no argument was provided (e.g. "--locale" is the last command-line argument).

if (!args[i] && opt.type !== "boolean") {

errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_expects_an_argument, opt.name));

}

switch (opt.type) {

case "number":

options[opt.name] = parseInt(args[i]);

i++;

break;

case "boolean":

options[opt.name] = true;

break;

case "string":

options[opt.name] = args[i] || "";

i++;

break;

case "list":

options[opt.name] = parseListTypeOption(<CommandLineOptionOfListType>opt, args[i], errors);

i++;

break;

// If not a primitive, the possible types are specified in what is effectively a map of options.

default:

options[opt.name] = parseCustomTypeOption(<CommandLineOptionOfCustomType>opt, args[i], errors);

i++;

break;

}

}

}

else {

errors.push(createCompilerDiagnostic(Diagnostics.Unknown_compiler_option_0, s));

}

}

else {

fileNames.push(s);

}

}

}

function parseResponseFile(fileName: string) {

const text = readFile ? readFile(fileName) : sys.readFile(fileName);

if (!text) {

errors.push(createCompilerDiagnostic(Diagnostics.File_0_not_found, fileName));

return;

}

const args: string[] = [];

let pos = 0;

while (true) {

while (pos < text.length && text.charCodeAt(pos) <= CharacterCodes.space) pos++;

if (pos >= text.length) break;

const start = pos;

if (text.charCodeAt(start) === CharacterCodes.doubleQuote) {

pos++;

while (pos < text.length && text.charCodeAt(pos) !== CharacterCodes.doubleQuote) pos++;

if (pos < text.length) {

args.push(text.substring(start + 1, pos));

pos++;

}

else {

errors.push(createCompilerDiagnostic(Diagnostics.Unterminated_quoted_string_in_response_file_0, fileName));

}

}

else {

while (text.charCodeAt(pos) > CharacterCodes.space) pos++;

args.push(text.substring(start, pos));

}

}

parseStrings(args);

}

let text = "";

try {

text = readFile(fileName);

}

catch (e) {

return { error: createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message) };

}

return parseConfigFileTextToJson(fileName, text);

try {

const jsonTextWithoutComments = removeComments(jsonText);

return { config: /\S/.test(jsonTextWithoutComments) ? JSON.parse(jsonTextWithoutComments) : {} };

}

catch (e) {

return { error: createCompilerDiagnostic(Diagnostics.Failed_to_parse_file_0_Colon_1, fileName, e.message) };

}

let output = "";

const scanner = createScanner(ScriptTarget.ES5, /* skipTrivia */ false, LanguageVariant.Standard, jsonText);

let token: SyntaxKind;

while ((token = scanner.scan()) !== SyntaxKind.EndOfFileToken) {

switch (token) {

case SyntaxKind.SingleLineCommentTrivia:

case SyntaxKind.MultiLineCommentTrivia:

// replace comments with whitespace to preserve original character positions

output += scanner.getTokenText().replace(/\S/g, " ");

break;

default:

output += scanner.getTokenText();

break;

}

}

return output;

const errors: Diagnostic[] = [];

const compilerOptions: CompilerOptions = convertCompilerOptionsFromJsonWorker(json["compilerOptions"], basePath, errors, configFileName);

const options = extend(existingOptions, compilerOptions);

const typingOptions: TypingOptions = convertTypingOptionsFromJsonWorker(json["typingOptions"], basePath, errors, configFileName);

options.configFilePath = configFileName;

const fileNames = getFileNames(errors);

return {

options,

fileNames,

typingOptions,

errors

};

function getFileNames(errors: Diagnostic[]): string[] {

let fileNames: string[] = [];

if (hasProperty(json, "files")) {

if (isArray(json["files"])) {

fileNames = map(<string[]>json["files"], s => combinePaths(basePath, s));

}

else {

errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "files", "Array"));

}

}

else {

const filesSeen: Map<boolean> = {};

let exclude: string[] = [];

if (isArray(json["exclude"])) {

exclude = json["exclude"];

}

else {

// by default exclude node_modules, and any specificied output directory

exclude = ["node_modules"];

const outDir = json["compilerOptions"] && json["compilerOptions"]["outDir"];

if (outDir) {

exclude.push(outDir);

}

}

exclude = map(exclude, normalizeSlashes);

const supportedExtensions = getSupportedExtensions(options);

Debug.assert(indexOf(supportedExtensions, ".ts") < indexOf(supportedExtensions, ".d.ts"), "Changed priority of extensions to pick");

// Get files of supported extensions in their order of resolution

for (const extension of supportedExtensions) {

const filesInDirWithExtension = host.readDirectory(basePath, extension, exclude);

for (const fileName of filesInDirWithExtension) {

// .ts extension would read the .d.ts extension files too but since .d.ts is lower priority extension,

// lets pick them when its turn comes up

if (extension === ".ts" && fileExtensionIs(fileName, ".d.ts")) {

continue;

}

// Skip over any minified JavaScript files (ending in ".min.js")

if (/\.min\.js$/.test(fileName)) {

continue;

}

// If this is one of the output extension (which would be .d.ts and .js if we are allowing compilation of js files)

// do not include this file if we included .ts or .tsx file with same base name as it could be output of the earlier compilation

if (extension === ".d.ts" || (options.allowJs && contains(supportedJavascriptExtensions, extension))) {

const baseName = fileName.substr(0, fileName.length - extension.length);

if (hasProperty(filesSeen, baseName + ".ts") || hasProperty(filesSeen, baseName + ".tsx")) {

continue;

}

}

filesSeen[fileName] = true;

fileNames.push(fileName);

}

}

}

if (hasProperty(json, "excludes") && !hasProperty(json, "exclude")) {

errors.push(createCompilerDiagnostic(Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));

}

return fileNames;

}

const errors: Diagnostic[] = [];

const options = convertCompilerOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);

return { options, errors };

const errors: Diagnostic[] = [];

const options = convertTypingOptionsFromJsonWorker(jsonOptions, basePath, errors, configFileName);

return { options, errors };

basePath: string, errors: Diagnostic[], configFileName?: string): CompilerOptions {

const options: CompilerOptions = getBaseFileName(configFileName) === "jsconfig.json" ? { allowJs: true } : {};

convertOptionsFromJson(optionDeclarations, jsonOptions, basePath, options, Diagnostics.Unknown_compiler_option_0, errors);

return options;

basePath: string, errors: Diagnostic[], configFileName?: string): TypingOptions {

const options: TypingOptions = getBaseFileName(configFileName) === "jsconfig.json"

? { enableAutoDiscovery: true, include: [], exclude: [] }

: { enableAutoDiscovery: false, include: [], exclude: [] };

convertOptionsFromJson(typingOptionDeclarations, jsonOptions, basePath, options, Diagnostics.Unknown_typing_option_0, errors);

return options;

defaultOptions: CompilerOptions | TypingOptions, diagnosticMessage: DiagnosticMessage, errors: Diagnostic[]) {

if (!jsonOptions) {

return ;

}

const optionNameMap = arrayToMap(optionDeclarations, opt => opt.name);

for (const id in jsonOptions) {

if (hasProperty(optionNameMap, id)) {

const opt = optionNameMap[id];

defaultOptions[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);

}

else {

errors.push(createCompilerDiagnostic(diagnosticMessage, id));

}

}

const optType = opt.type;

const expectedType = typeof optType === "string" ? optType : "string";

if (optType === "list" && isArray(value)) {

return convertJsonOptionOfListType(<CommandLineOptionOfListType>opt, value, basePath, errors);

}

else if (typeof value === expectedType) {

if (typeof optType !== "string") {

return convertJsonOptionOfCustomType(<CommandLineOptionOfCustomType>opt, value, errors);

}

else {

if (opt.isFilePath) {

value = normalizePath(combinePaths(basePath, value));

if (value === "") {

value = ".";

}

}

}

return value;

}

else {

errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, expectedType));

}

const key = value.toLowerCase();

if (hasProperty(opt.type, key)) {

return opt.type[key];

}

else {

errors.push(createCompilerDiagnosticForInvalidCustomType(opt));

}