// Convert deprecated typingOptions.enableAutoDiscovery to typeAcquisition.enable

if (typeAcquisition && typeAcquisition.enableAutoDiscovery !== undefined && typeAcquisition.enable === undefined) {

const result: TypeAcquisition = {

enable: typeAcquisition.enableAutoDiscovery,

include: typeAcquisition.include || [],

exclude: typeAcquisition.exclude || []

};

return result;

}

return typeAcquisition;

if (optionNameMapCache) {

return optionNameMapCache;

}

const optionNameMap = createMap<CommandLineOption>();

const shortOptionNames = createMap<string>();

forEach(optionDeclarations, option => {

optionNameMap.set(option.name.toLowerCase(), option);

if (option.shortName) {

shortOptionNames.set(option.shortName, option.name);

}

});

optionNameMapCache = { optionNameMap, shortOptionNames };

return optionNameMapCache;

value = trimString(value);

if (startsWith(value, "-")) {

return undefined;

}

if (value === "") {

return [];

}

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

switch (opt.element.type) {

case "number":

return map(values, parseInt);

case "string":

return 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[] = [];

parseStrings(commandLine);

return {

options,

fileNames,

errors

};

function parseStrings(args: ReadonlyArray<string>) {

let i = 0;

while (i < args.length) {

const s = args[i];

i++;

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

parseResponseFile(s.slice(1));

}

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

const opt = getOptionFromName(s.slice(s.charCodeAt(1) === CharacterCodes.minus ? 2 : 1), /*allowShort*/ true);

if (opt) {

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":

// boolean flag has optional value true, false, others

const optValue = args[i];

options[opt.name] = optValue !== "false";

// consume next argument as boolean flag value

if (optValue === "false" || optValue === "true") {

i++;

}

break;

case "string":

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

i++;

break;

case "list":

const result = parseListTypeOption(<CommandLineOptionOfListType>opt, args[i], errors);

options[opt.name] = result || [];

if (result) {

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

}

optionName = optionName.toLowerCase();

const { optionNameMap, shortOptionNames } = getOptionNameMap();

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

if (allowShort) {

const short = shortOptionNames.get(optionName);

if (short !== undefined) {

optionName = short;

}

}

return optionNameMap.get(optionName);

const jsonSourceFile = parseJsonText(fileName, jsonText);

return {

config: convertToObject(jsonSourceFile, jsonSourceFile.parseDiagnostics),

error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : undefined

};

let text: string | undefined;

try {

text = readFile(fileName);

}

catch (e) {

return createCompilerDiagnostic(Diagnostics.Cannot_read_file_0_Colon_1, fileName, e.message);

}

return text === undefined ? createCompilerDiagnostic(Diagnostics.The_specified_path_does_not_exist_Colon_0, fileName) : text;

if (_tsconfigRootOptions === undefined) {

_tsconfigRootOptions = commandLineOptionsToMap([

{

name: "compilerOptions",

type: "object",

elementOptions: commandLineOptionsToMap(optionDeclarations),

extraKeyDiagnosticMessage: Diagnostics.Unknown_compiler_option_0

},

{

name: "typingOptions",

type: "object",

elementOptions: commandLineOptionsToMap(typeAcquisitionDeclarations),

extraKeyDiagnosticMessage: Diagnostics.Unknown_type_acquisition_option_0

},

{

name: "typeAcquisition",

type: "object",

elementOptions: commandLineOptionsToMap(typeAcquisitionDeclarations),

extraKeyDiagnosticMessage: Diagnostics.Unknown_type_acquisition_option_0

},

{

name: "extends",

type: "string"

},

{

name: "files",

type: "list",

element: {

name: "files",

type: "string"

}

},

{

name: "include",

type: "list",

element: {

name: "include",

type: "string"

}

},

{

name: "exclude",

type: "list",

element: {

name: "exclude",

type: "string"

}

},

compileOnSaveCommandLineOption

]);

}

return _tsconfigRootOptions;

/**

onSetValidOptionKeyValueInParent(parentOption: string, option: CommandLineOption, value: CompilerOptionsValue): void;

/**

onSetValidOptionKeyValueInRoot(key: string, keyNode: PropertyName, value: CompilerOptionsValue, valueNode: Expression): void;

/**