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 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;

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

default:

let map = <Map<number>>opt.type;

let key = (args[i] || "").toLowerCase();

i++;

if (hasProperty(map, key)) {

options[opt.name] = map[key];

}

else {

errors.push(createCompilerDiagnostic((<CommandLineOptionOfCustomType>opt).error));

}

}

}

}

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 { options: optionsFromJsonConfigFile, errors } = convertCompilerOptionsFromJson(json["compilerOptions"], basePath, configFileName);

const options = extend(existingOptions, optionsFromJsonConfigFile);

return {

options,

fileNames: getFileNames(),

errors

};

function getFileNames(): string[] {

let fileNames: string[] = [];

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

if (json["files"] instanceof Array) {

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 (json["exclude"] instanceof Array) {

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);

}

}

}

return fileNames;

}

const options: CompilerOptions = {};

const errors: Diagnostic[] = [];

if (configFileName && getBaseFileName(configFileName) === "jsconfig.json") {

options.allowJs = true;

}

if (!jsonOptions) {

return { options, errors };

}

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

for (const id in jsonOptions) {

if (hasProperty(optionNameMap, id)) {

const opt = optionNameMap[id];

const optType = opt.type;

let value = jsonOptions[id];

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

if (typeof value === expectedType) {

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

const key = value.toLowerCase();

if (hasProperty(optType, key)) {

value = optType[key];

}

else {

errors.push(createCompilerDiagnostic((<CommandLineOptionOfCustomType>opt).error));

value = 0;

}

}

if (opt.isFilePath) {

switch (typeof value) {

case "string":

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

break;

case "object":

// "object" options with 'isFilePath' = true expected to be string arrays

let paths: string[] = [];

let invalidOptionType = false;

if (!isArray(value)) {

invalidOptionType = true;

}

else {

for (const element of <any[]>value) {

if (typeof element === "string") {

paths.push(normalizePath(combinePaths(basePath, element)));

}

else {

invalidOptionType = true;

break;

}

}

}

if (invalidOptionType) {

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

}

else {

value = paths;

}

break;

}

if (value === "") {

value = ".";

}

}

options[opt.name] = value;

}

else {

errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, id, expectedType));

}

}

else {

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

}

}

return { options, errors };