typescript 5.1.0-dev.20230320 → 5.1.0-dev.20230322

package/lib/tsc.js

@@ -15,15 +15,10 @@ and limitations under the License.
 
 
 "use strict";
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230320`;
+var version = `${versionMajorMinor}.0-dev.20230322`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -2655,25 +2650,6 @@ try {
 }
 var perfLogger = (etwModule == null ? void 0 : etwModule.logEvent) ? etwModule : void 0;
 
-// src/compiler/_namespaces/ts.performance.ts
-var ts_performance_exports = {};
-__export(ts_performance_exports, {
-  clearMarks: () => clearMarks,
-  clearMeasures: () => clearMeasures,
-  createTimer: () => createTimer,
-  createTimerIf: () => createTimerIf,
-  disable: () => disable,
-  enable: () => enable,
-  forEachMark: () => forEachMark,
-  forEachMeasure: () => forEachMeasure,
-  getCount: () => getCount,
-  getDuration: () => getDuration,
-  isEnabled: () => isEnabled,
-  mark: () => mark,
-  measure: () => measure,
-  nullTimer: () => nullTimer
-});
-
 // src/compiler/performance.ts
 var perfHooks;
 var performanceImpl;
@@ -4869,7 +4845,7 @@ var sys = (() => {
     }
     let activeSession;
     let profilePath = "./profile.cpuprofile";
-    const Buffer2 = require("buffer").Buffer;
+    const Buffer = require("buffer").Buffer;
     const isLinuxOrMacOs = process.platform === "linux" || process.platform === "darwin";
     const platform = _os.platform();
     const useCaseSensitiveFileNames = isFileSystemCaseSensitive();
@@ -5076,7 +5052,7 @@ var sys = (() => {
       }
     }
     function bufferFrom(input, encoding) {
-      return Buffer2.from && Buffer2.from !== Int8Array.from ? Buffer2.from(input, encoding) : new Buffer2(input, encoding);
+      return Buffer.from && Buffer.from !== Int8Array.from ? Buffer.from(input, encoding) : new Buffer(input, encoding);
     }
     function isFileSystemCaseSensitive() {
       if (platform === "win32" || platform === "win64") {
@@ -6658,6 +6634,7 @@ var Diagnostics = {
   A_declaration_file_cannot_be_imported_without_import_type_Did_you_mean_to_import_an_implementation_file_0_instead: diag(2846, 1 /* Error */, "A_declaration_file_cannot_be_imported_without_import_type_Did_you_mean_to_import_an_implementation_f_2846", "A declaration file cannot be imported without 'import type'. Did you mean to import an implementation file '{0}' instead?"),
   A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value: diag(2847, 1 /* Error */, "A_function_whose_declared_type_is_neither_undefined_void_nor_any_must_return_a_value_2847", "A function whose declared type is neither 'undefined', 'void', nor 'any' must return a value."),
   The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression: diag(2848, 1 /* Error */, "The_right_hand_side_of_an_instanceof_expression_must_not_be_an_instantiation_expression_2848", "The right-hand side of an 'instanceof' expression must not be an instantiation expression."),
+  Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1: diag(2849, 1 /* Error */, "Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1_2849", "Target signature provides too few arguments. Expected {0} or more, but got {1}."),
   Import_declaration_0_is_using_private_name_1: diag(4e3, 1 /* Error */, "Import_declaration_0_is_using_private_name_1_4000", "Import declaration '{0}' is using private name '{1}'."),
   Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: diag(4002, 1 /* Error */, "Type_parameter_0_of_exported_class_has_or_is_using_private_name_1_4002", "Type parameter '{0}' of exported class has or is using private name '{1}'."),
   Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: diag(4004, 1 /* Error */, "Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1_4004", "Type parameter '{0}' of exported interface has or is using private name '{1}'."),
@@ -7103,13 +7080,14 @@ var Diagnostics = {
   Output_Formatting: diag(6256, 3 /* Message */, "Output_Formatting_6256", "Output Formatting"),
   Completeness: diag(6257, 3 /* Message */, "Completeness_6257", "Completeness"),
   _0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file: diag(6258, 1 /* Error */, "_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file_6258", "'{0}' should be set inside the 'compilerOptions' object of the config json file"),
-  Found_1_error_in_1: diag(6259, 3 /* Message */, "Found_1_error_in_1_6259", "Found 1 error in {1}"),
+  Found_1_error_in_0: diag(6259, 3 /* Message */, "Found_1_error_in_0_6259", "Found 1 error in {0}"),
   Found_0_errors_in_the_same_file_starting_at_Colon_1: diag(6260, 3 /* Message */, "Found_0_errors_in_the_same_file_starting_at_Colon_1_6260", "Found {0} errors in the same file, starting at: {1}"),
   Found_0_errors_in_1_files: diag(6261, 3 /* Message */, "Found_0_errors_in_1_files_6261", "Found {0} errors in {1} files."),
   File_name_0_has_a_1_extension_looking_up_2_instead: diag(6262, 3 /* Message */, "File_name_0_has_a_1_extension_looking_up_2_instead_6262", "File name '{0}' has a '{1}' extension - looking up '{2}' instead."),
   Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set: diag(6263, 1 /* Error */, "Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set_6263", "Module '{0}' was resolved to '{1}', but '--allowArbitraryExtensions' is not set."),
   Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present: diag(6264, 3 /* Message */, "Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present_6264", "Enable importing files with any extension, provided a declaration file is present."),
   Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder: diag(6265, 3 /* Message */, "Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_no_6265", "Resolving type reference directive for program that specifies custom typeRoots, skipping lookup in 'node_modules' folder."),
+  Option_0_can_only_be_specified_on_command_line: diag(6266, 1 /* Error */, "Option_0_can_only_be_specified_on_command_line_6266", "Option '{0}' can only be specified on command line."),
   Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, 3 /* Message */, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
   Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, 3 /* Message */, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
   Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, 3 /* Message */, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
@@ -12270,17 +12248,17 @@ function entityNameToString(name) {
       return Debug.assertNever(name);
   }
 }
-function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) {
+function createDiagnosticForNode(node, message, ...args) {
   const sourceFile = getSourceFileOfNode(node);
-  return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3);
+  return createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args);
 }
-function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) {
+function createDiagnosticForNodeArray(sourceFile, nodes, message, ...args) {
   const start = skipTrivia(sourceFile.text, nodes.pos);
-  return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2, arg3);
+  return createFileDiagnostic(sourceFile, start, nodes.end - start, message, ...args);
 }
-function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) {
+function createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args) {
   const span = getErrorSpanForNode(sourceFile, node);
-  return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3);
+  return createFileDiagnostic(sourceFile, span.start, span.length, message, ...args);
 }
 function createDiagnosticForNodeFromMessageChain(sourceFile, node, messageChain, relatedInformation) {
   const span = getErrorSpanForNode(sourceFile, node);
@@ -12734,17 +12712,20 @@ function isObjectLiteralOrClassExpressionMethodOrAccessor(node) {
 function isIdentifierTypePredicate(predicate) {
   return predicate && predicate.kind === 1 /* Identifier */;
 }
-function getPropertyAssignment(objectLiteral, key, key2) {
-  return objectLiteral.properties.filter((property) => {
-    if (property.kind === 300 /* PropertyAssignment */) {
-      const propName = tryGetTextOfPropertyName(property.name);
-      return key === propName || !!key2 && key2 === propName;
-    }
-    return false;
+function forEachPropertyAssignment(objectLiteral, key, callback, key2) {
+  return forEach(objectLiteral == null ? void 0 : objectLiteral.properties, (property) => {
+    if (!isPropertyAssignment(property))
+      return void 0;
+    const propName = tryGetTextOfPropertyName(property.name);
+    return key === propName || key2 && key2 === propName ? callback(property) : void 0;
   });
 }
 function getPropertyArrayElementValue(objectLiteral, propKey, elementValue) {
-  return firstDefined(getPropertyAssignment(objectLiteral, propKey), (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
+  return forEachPropertyAssignment(
+    objectLiteral,
+    propKey,
+    (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0
+  );
 }
 function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
   if (tsConfigSourceFile && tsConfigSourceFile.statements.length) {
@@ -12753,11 +12734,10 @@ function getTsConfigObjectLiteralExpression(tsConfigSourceFile) {
   }
 }
 function getTsConfigPropArrayElementValue(tsConfigSourceFile, propKey, elementValue) {
-  return firstDefined(getTsConfigPropArray(tsConfigSourceFile, propKey), (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
+  return forEachTsConfigPropArray(tsConfigSourceFile, propKey, (property) => isArrayLiteralExpression(property.initializer) ? find(property.initializer.elements, (element) => isStringLiteral(element) && element.text === elementValue) : void 0);
 }
-function getTsConfigPropArray(tsConfigSourceFile, propKey) {
-  const jsonObjectLiteral = getTsConfigObjectLiteralExpression(tsConfigSourceFile);
-  return jsonObjectLiteral ? getPropertyAssignment(jsonObjectLiteral, propKey) : emptyArray;
+function forEachTsConfigPropArray(tsConfigSourceFile, propKey, callback) {
+  return forEachPropertyAssignment(getTsConfigObjectLiteralExpression(tsConfigSourceFile), propKey, callback);
 }
 function getContainingFunction(node) {
   return findAncestor(node.parent, isFunctionLike);
@@ -14029,6 +14009,12 @@ function getAncestor(node, kind) {
 function isKeyword(token) {
   return 82 /* FirstKeyword */ <= token && token <= 163 /* LastKeyword */;
 }
+function isPunctuation(token) {
+  return 18 /* FirstPunctuation */ <= token && token <= 78 /* LastPunctuation */;
+}
+function isKeywordOrPunctuation(token) {
+  return isKeyword(token) || isPunctuation(token);
+}
 function isContextualKeyword(token) {
   return 127 /* FirstContextualKeyword */ <= token && token <= 163 /* LastContextualKeyword */;
 }
@@ -26085,14 +26071,12 @@ var Parser;
     scriptKind2 = ensureScriptKind(fileName2, scriptKind2);
     if (scriptKind2 === 6 /* JSON */) {
       const result2 = parseJsonText2(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes);
-      convertToObjectWorker(
+      convertToJson(
         result2,
         (_a2 = result2.statements[0]) == null ? void 0 : _a2.expression,
         result2.parseDiagnostics,
         /*returnValue*/
         false,
-        /*knownRootOptions*/
-        void 0,
         /*jsonConversionNotifier*/
         void 0
       );
@@ -26524,24 +26508,24 @@ var Parser;
   function inAwaitContext() {
     return inContext(32768 /* AwaitContext */);
   }
-  function parseErrorAtCurrentToken(message, arg0) {
-    return parseErrorAt(scanner.getTokenStart(), scanner.getTokenEnd(), message, arg0);
+  function parseErrorAtCurrentToken(message, ...args) {
+    return parseErrorAt(scanner.getTokenStart(), scanner.getTokenEnd(), message, ...args);
   }
-  function parseErrorAtPosition(start, length2, message, arg0) {
+  function parseErrorAtPosition(start, length2, message, ...args) {
     const lastError = lastOrUndefined(parseDiagnostics);
     let result;
     if (!lastError || start !== lastError.start) {
-      result = createDetachedDiagnostic(fileName, start, length2, message, arg0);
+      result = createDetachedDiagnostic(fileName, start, length2, message, ...args);
       parseDiagnostics.push(result);
     }
     parseErrorBeforeNextFinishedNode = true;
     return result;
   }
-  function parseErrorAt(start, end, message, arg0) {
-    return parseErrorAtPosition(start, end - start, message, arg0);
+  function parseErrorAt(start, end, message, ...args) {
+    return parseErrorAtPosition(start, end - start, message, ...args);
   }
-  function parseErrorAtRange(range, message, arg0) {
-    parseErrorAt(range.pos, range.end, message, arg0);
+  function parseErrorAtRange(range, message, ...args) {
+    parseErrorAt(range.pos, range.end, message, ...args);
   }
   function scanError(message, length2) {
     parseErrorAtPosition(scanner.getTokenEnd(), length2, message);
@@ -26747,6 +26731,7 @@ var Parser;
       nextTokenJSDoc();
       return true;
     }
+    Debug.assert(isKeywordOrPunctuation(kind));
     parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
     return false;
   }
@@ -26795,7 +26780,11 @@ var Parser;
     );
   }
   function parseExpectedTokenJSDoc(t) {
-    return parseOptionalTokenJSDoc(t) || createMissingNode(
+    const optional = parseOptionalTokenJSDoc(t);
+    if (optional)
+      return optional;
+    Debug.assert(isKeywordOrPunctuation(t));
+    return createMissingNode(
       t,
       /*reportAtCurrentPosition*/
       false,
@@ -26849,11 +26838,11 @@ var Parser;
     }
     return node;
   }
-  function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
+  function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, ...args) {
     if (reportAtCurrentPosition) {
-      parseErrorAtPosition(scanner.getTokenFullStart(), 0, diagnosticMessage, arg0);
+      parseErrorAtPosition(scanner.getTokenFullStart(), 0, diagnosticMessage, ...args);
     } else if (diagnosticMessage) {
-      parseErrorAtCurrentToken(diagnosticMessage, arg0);
+      parseErrorAtCurrentToken(diagnosticMessage, ...args);
     }
     const pos = getNodePos();
     const result = kind === 79 /* Identifier */ ? factoryCreateIdentifier(
@@ -29212,6 +29201,7 @@ var Parser;
       if (simpleUnaryExpression.kind === 214 /* TypeAssertionExpression */) {
         parseErrorAt(pos, end, Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
       } else {
+        Debug.assert(isKeywordOrPunctuation(unaryOperator));
         parseErrorAt(pos, end, Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, tokenToString(unaryOperator));
       }
     }
@@ -32159,14 +32149,14 @@ var Parser;
       }
       function parseReturnTag(start2, tagName, indent2, indentText) {
         if (some(tags, isJSDocReturnTag)) {
-          parseErrorAt(tagName.pos, scanner.getTokenStart(), Diagnostics._0_tag_already_specified, tagName.escapedText);
+          parseErrorAt(tagName.pos, scanner.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
         }
         const typeExpression = tryParseTypeExpression();
         return finishNode(factory2.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start2, getNodePos(), indent2, indentText)), start2);
       }
       function parseTypeTag(start2, tagName, indent2, indentText) {
         if (some(tags, isJSDocTypeTag)) {
-          parseErrorAt(tagName.pos, scanner.getTokenStart(), Diagnostics._0_tag_already_specified, tagName.escapedText);
+          parseErrorAt(tagName.pos, scanner.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
         }
         const typeExpression = parseJSDocTypeExpression(
           /*mayOmitBraces*/
@@ -34613,9 +34603,6 @@ var defaultInitCompilerOptions = {
   forceConsistentCasingInFileNames: true,
   skipLibCheck: true
 };
-function createCompilerDiagnosticForInvalidCustomType(opt) {
-  return createDiagnosticForInvalidCustomType(opt, createCompilerDiagnostic);
-}
 function createDiagnosticForInvalidCustomType(opt, createDiagnostic) {
   const namesOfType = arrayFrom(opt.type.keys());
   const stringNames = (opt.deprecatedKeys ? namesOfType.filter((k) => !opt.deprecatedKeys.has(k)) : namesOfType).map((key) => `'${key}'`).join(", ");
@@ -34651,13 +34638,13 @@ function parseListTypeOption(opt, value = "", errors) {
 function getOptionName(option) {
   return option.name;
 }
-function createUnknownOptionError(unknownOption, diagnostics, createDiagnostics, unknownOptionErrorText) {
+function createUnknownOptionError(unknownOption, diagnostics, unknownOptionErrorText, node, sourceFile) {
   var _a2;
   if ((_a2 = diagnostics.alternateMode) == null ? void 0 : _a2.getOptionsNameMap().optionsNameMap.has(unknownOption.toLowerCase())) {
-    return createDiagnostics(diagnostics.alternateMode.diagnostic, unknownOption);
+    return createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.alternateMode.diagnostic, unknownOption);
   }
   const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
-  return possibleOption ? createDiagnostics(diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnostics(diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
+  return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
 }
 function parseCommandLineWorker(diagnostics, commandLine, readFile) {
   const options = {};
@@ -34698,7 +34685,7 @@ function parseCommandLineWorker(diagnostics, commandLine, readFile) {
           if (watchOpt) {
             i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors);
           } else {
-            errors.push(createUnknownOptionError(inputOptionName, diagnostics, createCompilerDiagnostic, s));
+            errors.push(createUnknownOptionError(inputOptionName, diagnostics, s));
           }
         }
       } else {
@@ -34902,9 +34889,7 @@ function parseConfigFileTextToJson(fileName, jsonText) {
     config: convertConfigFileToObject(
       jsonSourceFile,
       jsonSourceFile.parseDiagnostics,
-      /*reportOptionsErrors*/
-      false,
-      /*optionsIterator*/
+      /*jsonConversionNotifier*/
       void 0
     ),
     error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : void 0
@@ -34961,7 +34946,26 @@ var extendsOptionDeclaration = {
     name: "extends",
     type: "string"
   },
-  category: Diagnostics.File_Management
+  category: Diagnostics.File_Management,
+  disallowNullOrUndefined: true
+};
+var compilerOptionsDeclaration = {
+  name: "compilerOptions",
+  type: "object",
+  elementOptions: getCommandLineCompilerOptionsMap(),
+  extraKeyDiagnostics: compilerOptionsDidYouMeanDiagnostics
+};
+var watchOptionsDeclaration = {
+  name: "watchOptions",
+  type: "object",
+  elementOptions: getCommandLineWatchOptionsMap(),
+  extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics
+};
+var typeAcquisitionDeclaration = {
+  name: "typeAcquisition",
+  type: "object",
+  elementOptions: getCommandLineTypeAcquisitionMap(),
+  extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
 };
 var _tsconfigRootOptions;
 function getTsconfigRootOptionsMap() {
@@ -34971,24 +34975,9 @@ function getTsconfigRootOptionsMap() {
       // should never be needed since this is root
       type: "object",
       elementOptions: commandLineOptionsToMap([
-        {
-          name: "compilerOptions",
-          type: "object",
-          elementOptions: getCommandLineCompilerOptionsMap(),
-          extraKeyDiagnostics: compilerOptionsDidYouMeanDiagnostics
-        },
-        {
-          name: "watchOptions",
-          type: "object",
-          elementOptions: getCommandLineWatchOptionsMap(),
-          extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics
-        },
-        {
-          name: "typeAcquisition",
-          type: "object",
-          elementOptions: getCommandLineTypeAcquisitionMap(),
-          extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
-        },
+        compilerOptionsDeclaration,
+        watchOptionsDeclaration,
+        typeAcquisitionDeclaration,
         extendsOptionDeclaration,
         {
           name: "references",
@@ -35034,10 +35023,9 @@ function getTsconfigRootOptionsMap() {
   }
   return _tsconfigRootOptions;
 }
-function convertConfigFileToObject(sourceFile, errors, reportOptionsErrors, optionsIterator) {
+function convertConfigFileToObject(sourceFile, errors, jsonConversionNotifier) {
   var _a2;
   const rootExpression = (_a2 = sourceFile.statements[0]) == null ? void 0 : _a2.expression;
-  const knownRootOptions = reportOptionsErrors ? getTsconfigRootOptionsMap() : void 0;
   if (rootExpression && rootExpression.kind !== 208 /* ObjectLiteralExpression */) {
     errors.push(createDiagnosticForNodeInSourceFile(
       sourceFile,
@@ -35048,52 +35036,46 @@ function convertConfigFileToObject(sourceFile, errors, reportOptionsErrors, opti
     if (isArrayLiteralExpression(rootExpression)) {
       const firstObject = find(rootExpression.elements, isObjectLiteralExpression);
       if (firstObject) {
-        return convertToObjectWorker(
+        return convertToJson(
           sourceFile,
           firstObject,
           errors,
           /*returnValue*/
           true,
-          knownRootOptions,
-          optionsIterator
+          jsonConversionNotifier
         );
       }
     }
     return {};
   }
-  return convertToObjectWorker(
+  return convertToJson(
     sourceFile,
     rootExpression,
     errors,
     /*returnValue*/
     true,
-    knownRootOptions,
-    optionsIterator
+    jsonConversionNotifier
   );
 }
 function convertToObject(sourceFile, errors) {
   var _a2;
-  return convertToObjectWorker(
+  return convertToJson(
     sourceFile,
     (_a2 = sourceFile.statements[0]) == null ? void 0 : _a2.expression,
     errors,
     /*returnValue*/
     true,
-    /*knownRootOptions*/
-    void 0,
     /*jsonConversionNotifier*/
     void 0
   );
 }
-function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue, knownRootOptions, jsonConversionNotifier) {
+function convertToJson(sourceFile, rootExpression, errors, returnValue, jsonConversionNotifier) {
   if (!rootExpression) {
     return returnValue ? {} : void 0;
   }
-  return convertPropertyValueToJson(rootExpression, knownRootOptions);
-  function isRootOptionMap(knownOptions) {
-    return knownRootOptions && knownRootOptions.elementOptions === knownOptions;
-  }
-  function convertObjectLiteralExpressionToJson(node, knownOptions, extraKeyDiagnostics, parentOption) {
+  return convertPropertyValueToJson(rootExpression, jsonConversionNotifier == null ? void 0 : jsonConversionNotifier.rootOptions);
+  function convertObjectLiteralExpressionToJson(node, objectOption) {
+    var _a2;
     const result = returnValue ? {} : void 0;
     for (const element of node.properties) {
       if (element.kind !== 300 /* PropertyAssignment */) {
@@ -35108,38 +35090,13 @@ function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue,
       }
       const textOfKey = isComputedNonLiteralName(element.name) ? void 0 : getTextOfPropertyName(element.name);
       const keyText = textOfKey && unescapeLeadingUnderscores(textOfKey);
-      const option = keyText && knownOptions ? knownOptions.get(keyText) : void 0;
-      if (keyText && extraKeyDiagnostics && !option) {
-        if (knownOptions) {
-          errors.push(createUnknownOptionError(
-            keyText,
-            extraKeyDiagnostics,
-            (message, arg0, arg1) => createDiagnosticForNodeInSourceFile(sourceFile, element.name, message, arg0, arg1)
-          ));
-        } else {
-          errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.name, extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
-        }
-      }
+      const option = keyText ? (_a2 = objectOption == null ? void 0 : objectOption.elementOptions) == null ? void 0 : _a2.get(keyText) : void 0;
       const value = convertPropertyValueToJson(element.initializer, option);
       if (typeof keyText !== "undefined") {
         if (returnValue) {
           result[keyText] = value;
         }
-        if (jsonConversionNotifier && // Current callbacks are only on known parent option or if we are setting values in the root
-        (parentOption || isRootOptionMap(knownOptions))) {
-          const isValidOptionValue = isCompilerOptionsValue(option, value);
-          if (parentOption) {
-            if (isValidOptionValue) {
-              jsonConversionNotifier.onSetValidOptionKeyValueInParent(parentOption, option, value);
-            }
-          } else if (isRootOptionMap(knownOptions)) {
-            if (isValidOptionValue) {
-              jsonConversionNotifier.onSetValidOptionKeyValueInRoot(keyText, element.name, value, element.initializer);
-            } else if (!option) {
-              jsonConversionNotifier.onSetUnknownOptionKeyValueInRoot(keyText, element.name, value, element.initializer);
-            }
-          }
-        }
+        jsonConversionNotifier == null ? void 0 : jsonConversionNotifier.onPropertySet(keyText, value, element, objectOption, option);
       }
     }
     return result;
@@ -35152,112 +35109,40 @@ function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue,
     return filter(elements.map((element) => convertPropertyValueToJson(element, elementOption)), (v) => v !== void 0);
   }
   function convertPropertyValueToJson(valueExpression, option) {
-    let invalidReported;
     switch (valueExpression.kind) {
       case 111 /* TrueKeyword */:
-        reportInvalidOptionValue(option && option.type !== "boolean" && (option.type !== "listOrElement" || option.element.type !== "boolean"));
-        return validateValue(
-          /*value*/
-          true
-        );
+        return true;
       case 96 /* FalseKeyword */:
-        reportInvalidOptionValue(option && option.type !== "boolean" && (option.type !== "listOrElement" || option.element.type !== "boolean"));
-        return validateValue(
-          /*value*/
-          false
-        );
+        return false;
       case 105 /* NullKeyword */:
-        reportInvalidOptionValue(option && option.name === "extends");
-        return validateValue(
-          /*value*/
-          null
-        );
+        return null;
       case 10 /* StringLiteral */:
         if (!isDoubleQuotedString(valueExpression)) {
           errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected));
         }
-        reportInvalidOptionValue(option && isString(option.type) && option.type !== "string" && (option.type !== "listOrElement" || isString(option.element.type) && option.element.type !== "string"));
-        const text = valueExpression.text;
-        if (option) {
-          Debug.assert(option.type !== "listOrElement" || option.element.type === "string", "Only string or array of string is handled for now");
-        }
-        if (option && !isString(option.type)) {
-          const customOption = option;
-          if (!customOption.type.has(text.toLowerCase())) {
-            errors.push(
-              createDiagnosticForInvalidCustomType(
-                customOption,
-                (message, arg0, arg1) => createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1)
-              )
-            );
-            invalidReported = true;
-          }
-        }
-        return validateValue(text);
+        return valueExpression.text;
       case 8 /* NumericLiteral */:
-        reportInvalidOptionValue(option && option.type !== "number" && (option.type !== "listOrElement" || option.element.type !== "number"));
-        return validateValue(Number(valueExpression.text));
+        return Number(valueExpression.text);
       case 222 /* PrefixUnaryExpression */:
         if (valueExpression.operator !== 40 /* MinusToken */ || valueExpression.operand.kind !== 8 /* NumericLiteral */) {
           break;
         }
-        reportInvalidOptionValue(option && option.type !== "number" && (option.type !== "listOrElement" || option.element.type !== "number"));
-        return validateValue(-Number(valueExpression.operand.text));
+        return -Number(valueExpression.operand.text);
       case 208 /* ObjectLiteralExpression */:
-        reportInvalidOptionValue(option && option.type !== "object" && (option.type !== "listOrElement" || option.element.type !== "object"));
         const objectLiteralExpression = valueExpression;
-        if (option) {
-          const { elementOptions, extraKeyDiagnostics, name: optionName } = option;
-          return validateValue(convertObjectLiteralExpressionToJson(
-            objectLiteralExpression,
-            elementOptions,
-            extraKeyDiagnostics,
-            optionName
-          ));
-        } else {
-          return validateValue(convertObjectLiteralExpressionToJson(
-            objectLiteralExpression,
-            /* knownOptions*/
-            void 0,
-            /*extraKeyDiagnosticMessage */
-            void 0,
-            /*parentOption*/
-            void 0
-          ));
-        }
+        return convertObjectLiteralExpressionToJson(objectLiteralExpression, option);
       case 207 /* ArrayLiteralExpression */:
-        reportInvalidOptionValue(option && option.type !== "list" && option.type !== "listOrElement");
-        return validateValue(convertArrayLiteralExpressionToJson(
+        return convertArrayLiteralExpressionToJson(
           valueExpression.elements,
           option && option.element
-        ));
+        );
     }
     if (option) {
-      reportInvalidOptionValue(
-        /*isError*/
-        true
-      );
+      errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
     } else {
       errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal));
     }
     return void 0;
-    function validateValue(value) {
-      var _a2;
-      if (!invalidReported) {
-        const diagnostic = (_a2 = option == null ? void 0 : option.extraValidation) == null ? void 0 : _a2.call(option, value);
-        if (diagnostic) {
-          errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ...diagnostic));
-          return void 0;
-        }
-      }
-      return value;
-    }
-    function reportInvalidOptionValue(isError) {
-      if (isError) {
-        errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
-        invalidReported = true;
-      }
-    }
   }
   function isDoubleQuotedString(node) {
     return isStringLiteral(node) && isStringDoubleQuoted(node, sourceFile);
@@ -35269,7 +35154,7 @@ function getCompilerOptionValueTypeString(option) {
 function isCompilerOptionsValue(option, value) {
   if (option) {
     if (isNullOrUndefined(value))
-      return true;
+      return !option.disallowNullOrUndefined;
     if (option.type === "list") {
       return isArray(value);
     }
@@ -35614,8 +35499,8 @@ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, exis
         if (sourceFile) {
           const fileName = configFileName || "tsconfig.json";
           const diagnosticMessage = Diagnostics.The_files_list_in_config_file_0_is_empty;
-          const nodeValue = firstDefined(getTsConfigPropArray(sourceFile, "files"), (property) => property.initializer);
-          const error = nodeValue ? createDiagnosticForNodeInSourceFile(sourceFile, nodeValue, diagnosticMessage, fileName) : createCompilerDiagnostic(diagnosticMessage, fileName);
+          const nodeValue = forEachTsConfigPropArray(sourceFile, "files", (property) => property.initializer);
+          const error = createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, nodeValue, diagnosticMessage, fileName);
           errors.push(error);
         } else {
           createCompilerDiagnosticOnlyIfJson(Diagnostics.The_files_list_in_config_file_0_is_empty, configFileName || "tsconfig.json");
@@ -35717,9 +35602,9 @@ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, exis
     }
     return "no-prop";
   }
-  function createCompilerDiagnosticOnlyIfJson(message, arg0, arg1) {
+  function createCompilerDiagnosticOnlyIfJson(message, ...args) {
     if (!sourceFile) {
-      errors.push(createCompilerDiagnostic(message, arg0, arg1));
+      errors.push(createCompilerDiagnostic(message, ...args));
     }
   }
 }
@@ -35818,27 +35703,42 @@ function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) {
   const typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition, basePath, errors, configFileName);
   const watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors);
   json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
+  const extendedConfigPath = json.extends || json.extends === "" ? getExtendsConfigPathOrArray(json.extends, host, basePath, configFileName, errors) : void 0;
+  return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
+}
+function getExtendsConfigPathOrArray(value, host, basePath, configFileName, errors, propertyAssignment, valueExpression, sourceFile) {
   let extendedConfigPath;
-  if (json.extends || json.extends === "") {
-    if (!isCompilerOptionsValue(extendsOptionDeclaration, json.extends)) {
-      errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", getCompilerOptionValueTypeString(extendsOptionDeclaration)));
-    } else {
-      const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
-      if (isString(json.extends)) {
-        extendedConfigPath = getExtendsConfigPath(json.extends, host, newBase, errors, createCompilerDiagnostic);
+  const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
+  if (isString(value)) {
+    extendedConfigPath = getExtendsConfigPath(
+      value,
+      host,
+      newBase,
+      errors,
+      valueExpression,
+      sourceFile
+    );
+  } else if (isArray(value)) {
+    extendedConfigPath = [];
+    for (let index = 0; index < value.length; index++) {
+      const fileName = value[index];
+      if (isString(fileName)) {
+        extendedConfigPath = append(extendedConfigPath, getExtendsConfigPath(
+          fileName,
+          host,
+          newBase,
+          errors,
+          valueExpression == null ? void 0 : valueExpression.elements[index],
+          sourceFile
+        ));
       } else {
-        extendedConfigPath = [];
-        for (const fileName of json.extends) {
-          if (isString(fileName)) {
-            extendedConfigPath = append(extendedConfigPath, getExtendsConfigPath(fileName, host, newBase, errors, createCompilerDiagnostic));
-          } else {
-            errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", getCompilerOptionValueTypeString(extendsOptionDeclaration.element)));
-          }
-        }
+        convertJsonOption(extendsOptionDeclaration.element, value, basePath, errors, propertyAssignment, valueExpression == null ? void 0 : valueExpression.elements[index], sourceFile);
       }
     }
+  } else {
+    convertJsonOption(extendsOptionDeclaration, value, basePath, errors, propertyAssignment, valueExpression, sourceFile);
   }
-  return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
+  return extendedConfigPath;
 }
 function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors) {
   const options = getDefaultCompilerOptions(configFileName);
@@ -35846,69 +35746,11 @@ function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileNa
   let watchOptions;
   let extendedConfigPath;
   let rootCompilerOptions;
-  const optionsIterator = {
-    onSetValidOptionKeyValueInParent(parentOption, option, value) {
-      let currentOption;
-      switch (parentOption) {
-        case "compilerOptions":
-          currentOption = options;
-          break;
-        case "watchOptions":
-          currentOption = watchOptions || (watchOptions = {});
-          break;
-        case "typeAcquisition":
-          currentOption = typeAcquisition || (typeAcquisition = getDefaultTypeAcquisition(configFileName));
-          break;
-        default:
-          Debug.fail("Unknown option");
-      }
-      currentOption[option.name] = normalizeOptionValue(option, basePath, value);
-    },
-    onSetValidOptionKeyValueInRoot(key, _keyNode, value, valueNode) {
-      switch (key) {
-        case "extends":
-          const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
-          if (isString(value)) {
-            extendedConfigPath = getExtendsConfigPath(
-              value,
-              host,
-              newBase,
-              errors,
-              (message, arg0) => createDiagnosticForNodeInSourceFile(sourceFile, valueNode, message, arg0)
-            );
-          } else {
-            extendedConfigPath = [];
-            for (let index = 0; index < value.length; index++) {
-              const fileName = value[index];
-              if (isString(fileName)) {
-                extendedConfigPath = append(extendedConfigPath, getExtendsConfigPath(
-                  fileName,
-                  host,
-                  newBase,
-                  errors,
-                  (message, arg0) => createDiagnosticForNodeInSourceFile(sourceFile, valueNode.elements[index], message, arg0)
-                ));
-              }
-            }
-          }
-          return;
-      }
-    },
-    onSetUnknownOptionKeyValueInRoot(key, keyNode, _value, _valueNode) {
-      if (key === "excludes") {
-        errors.push(createDiagnosticForNodeInSourceFile(sourceFile, keyNode, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
-      }
-      if (find(commandOptionsWithoutBuild, (opt) => opt.name === key)) {
-        rootCompilerOptions = append(rootCompilerOptions, keyNode);
-      }
-    }
-  };
+  const rootOptions = getTsconfigRootOptionsMap();
   const json = convertConfigFileToObject(
     sourceFile,
     errors,
-    /*reportOptionsErrors*/
-    true,
-    optionsIterator
+    { rootOptions, onPropertySet }
   );
   if (!typeAcquisition) {
     typeAcquisition = getDefaultTypeAcquisition(configFileName);
@@ -35917,15 +35759,57 @@ function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileNa
     errors.push(createDiagnosticForNodeInSourceFile(sourceFile, rootCompilerOptions[0], Diagnostics._0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file, getTextOfPropertyName(rootCompilerOptions[0])));
   }
   return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
+  function onPropertySet(keyText, value, propertyAssignment, parentOption, option) {
+    if (option && option !== extendsOptionDeclaration)
+      value = convertJsonOption(option, value, basePath, errors, propertyAssignment, propertyAssignment.initializer, sourceFile);
+    if (parentOption == null ? void 0 : parentOption.name) {
+      if (option) {
+        let currentOption;
+        if (parentOption === compilerOptionsDeclaration)
+          currentOption = options;
+        else if (parentOption === watchOptionsDeclaration)
+          currentOption = watchOptions != null ? watchOptions : watchOptions = {};
+        else if (parentOption === typeAcquisitionDeclaration)
+          currentOption = typeAcquisition != null ? typeAcquisition : typeAcquisition = getDefaultTypeAcquisition(configFileName);
+        else
+          Debug.fail("Unknown option");
+        currentOption[option.name] = value;
+      } else if (keyText && (parentOption == null ? void 0 : parentOption.extraKeyDiagnostics)) {
+        if (parentOption.elementOptions) {
+          errors.push(createUnknownOptionError(
+            keyText,
+            parentOption.extraKeyDiagnostics,
+            /*unknownOptionErrorText*/
+            void 0,
+            propertyAssignment.name,
+            sourceFile
+          ));
+        } else {
+          errors.push(createDiagnosticForNodeInSourceFile(sourceFile, propertyAssignment.name, parentOption.extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
+        }
+      }
+    } else if (parentOption === rootOptions) {
+      if (option === extendsOptionDeclaration) {
+        extendedConfigPath = getExtendsConfigPathOrArray(value, host, basePath, configFileName, errors, propertyAssignment, propertyAssignment.initializer, sourceFile);
+      } else if (!option) {
+        if (keyText === "excludes") {
+          errors.push(createDiagnosticForNodeInSourceFile(sourceFile, propertyAssignment.name, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
+        }
+        if (find(commandOptionsWithoutBuild, (opt) => opt.name === keyText)) {
+          rootCompilerOptions = append(rootCompilerOptions, propertyAssignment.name);
+        }
+      }
+    }
+  }
 }
-function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiagnostic) {
+function getExtendsConfigPath(extendedConfig, host, basePath, errors, valueExpression, sourceFile) {
   extendedConfig = normalizeSlashes(extendedConfig);
   if (isRootedDiskPath(extendedConfig) || startsWith(extendedConfig, "./") || startsWith(extendedConfig, "../")) {
     let extendedConfigPath = getNormalizedAbsolutePath(extendedConfig, basePath);
     if (!host.fileExists(extendedConfigPath) && !endsWith(extendedConfigPath, ".json" /* Json */)) {
       extendedConfigPath = `${extendedConfigPath}.json`;
       if (!host.fileExists(extendedConfigPath)) {
-        errors.push(createDiagnostic(Diagnostics.File_0_not_found, extendedConfig));
+        errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.File_0_not_found, extendedConfig));
         return void 0;
       }
     }
@@ -35936,9 +35820,9 @@ function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiag
     return resolved.resolvedModule.resolvedFileName;
   }
   if (extendedConfig === "") {
-    errors.push(createDiagnostic(Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string, "extends"));
+    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string, "extends"));
   } else {
-    errors.push(createDiagnostic(Diagnostics.File_0_not_found, extendedConfig));
+    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.File_0_not_found, extendedConfig));
   }
   return void 0;
 }
@@ -36030,42 +35914,33 @@ function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOp
     if (opt) {
       (defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
     } else {
-      errors.push(createUnknownOptionError(id, diagnostics, createCompilerDiagnostic));
+      errors.push(createUnknownOptionError(id, diagnostics));
     }
   }
   return defaultOptions;
 }
-function convertJsonOption(opt, value, basePath, errors) {
+function createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, message, ...args) {
+  return sourceFile && node ? createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args) : createCompilerDiagnostic(message, ...args);
+}
+function convertJsonOption(opt, value, basePath, errors, propertyAssignment, valueExpression, sourceFile) {
+  if (opt.isCommandLineOnly) {
+    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, propertyAssignment == null ? void 0 : propertyAssignment.name, Diagnostics.Option_0_can_only_be_specified_on_command_line, opt.name));
+    return void 0;
+  }
   if (isCompilerOptionsValue(opt, value)) {
     const optType = opt.type;
     if (optType === "list" && isArray(value)) {
-      return convertJsonOptionOfListType(opt, value, basePath, errors);
+      return convertJsonOptionOfListType(opt, value, basePath, errors, propertyAssignment, valueExpression, sourceFile);
     } else if (optType === "listOrElement") {
-      return isArray(value) ? convertJsonOptionOfListType(opt, value, basePath, errors) : convertJsonOption(opt.element, value, basePath, errors);
+      return isArray(value) ? convertJsonOptionOfListType(opt, value, basePath, errors, propertyAssignment, valueExpression, sourceFile) : convertJsonOption(opt.element, value, basePath, errors, propertyAssignment, valueExpression, sourceFile);
     } else if (!isString(opt.type)) {
-      return convertJsonOptionOfCustomType(opt, value, errors);
+      return convertJsonOptionOfCustomType(opt, value, errors, valueExpression, sourceFile);
     }
-    const validatedValue = validateJsonOptionValue(opt, value, errors);
+    const validatedValue = validateJsonOptionValue(opt, value, errors, valueExpression, sourceFile);
     return isNullOrUndefined(validatedValue) ? validatedValue : normalizeNonListOptionValue(opt, basePath, validatedValue);
   } else {
-    errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
-  }
-}
-function normalizeOptionValue(option, basePath, value) {
-  if (isNullOrUndefined(value))
-    return void 0;
-  if (option.type === "listOrElement" && !isArray(value))
-    return normalizeOptionValue(option.element, basePath, value);
-  else if (option.type === "list" || option.type === "listOrElement") {
-    const listOption = option;
-    if (listOption.element.isFilePath || !isString(listOption.element.type)) {
-      return filter(map(value, (v) => normalizeOptionValue(listOption.element, basePath, v)), (v) => listOption.listPreserveFalsyValues ? true : !!v);
-    }
-    return value;
-  } else if (!isString(option.type)) {
-    return option.type.get(isString(value) ? value.toLowerCase() : value);
+    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
   }
-  return normalizeNonListOptionValue(option, basePath, value);
 }
 function normalizeNonListOptionValue(option, basePath, value) {
   if (option.isFilePath) {
@@ -36076,29 +35951,29 @@ function normalizeNonListOptionValue(option, basePath, value) {
   }
   return value;
 }
-function validateJsonOptionValue(opt, value, errors) {
+function validateJsonOptionValue(opt, value, errors, valueExpression, sourceFile) {
   var _a2;
   if (isNullOrUndefined(value))
     return void 0;
   const d = (_a2 = opt.extraValidation) == null ? void 0 : _a2.call(opt, value);
   if (!d)
     return value;
-  errors.push(createCompilerDiagnostic(...d));
+  errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, ...d));
   return void 0;
 }
-function convertJsonOptionOfCustomType(opt, value, errors) {
+function convertJsonOptionOfCustomType(opt, value, errors, valueExpression, sourceFile) {
   if (isNullOrUndefined(value))
     return void 0;
   const key = value.toLowerCase();
   const val = opt.type.get(key);
   if (val !== void 0) {
-    return validateJsonOptionValue(opt, val, errors);
+    return validateJsonOptionValue(opt, val, errors, valueExpression, sourceFile);
   } else {
-    errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
+    errors.push(createDiagnosticForInvalidCustomType(opt, (message, ...args) => createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, message, ...args)));
   }
 }
-function convertJsonOptionOfListType(option, values, basePath, errors) {
-  return filter(map(values, (v) => convertJsonOption(option.element, v, basePath, errors)), (v) => option.listPreserveFalsyValues ? true : !!v);
+function convertJsonOptionOfListType(option, values, basePath, errors, propertyAssignment, valueExpression, sourceFile) {
+  return filter(map(values, (v, index) => convertJsonOption(option.element, v, basePath, errors, propertyAssignment, valueExpression == null ? void 0 : valueExpression.elements[index], sourceFile)), (v) => option.listPreserveFalsyValues ? true : !!v);
 }
 var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/;
 var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/;
@@ -36207,7 +36082,7 @@ function validateSpecs(specs, errors, disallowTrailingRecursion, jsonSourceFile,
   });
   function createDiagnostic(message, spec) {
     const element = getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec);
-    return element ? createDiagnosticForNodeInSourceFile(jsonSourceFile, element, message, spec) : createCompilerDiagnostic(message, spec);
+    return createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(jsonSourceFile, element, message, spec);
   }
 }
 function specToDiagnostic(spec, disallowTrailingRecursion) {
@@ -38904,8 +38779,8 @@ function createBinder() {
   var reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
   var bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
   return bindSourceFile2;
-  function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
-    return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
+  function createDiagnosticForNode2(node, message, ...args) {
+    return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, ...args);
   }
   function bindSourceFile2(f, opts) {
     var _a2, _b;
@@ -39099,7 +38974,7 @@ function createBinder() {
           const declarationName = getNameOfDeclaration(node) || node;
           forEach(symbol.declarations, (declaration, index) => {
             const decl = getNameOfDeclaration(declaration) || declaration;
-            const diag3 = createDiagnosticForNode2(decl, message, messageNeedsName ? getDisplayName(declaration) : void 0);
+            const diag3 = messageNeedsName ? createDiagnosticForNode2(decl, message, getDisplayName(declaration)) : createDiagnosticForNode2(decl, message);
             file.bindDiagnostics.push(
               multipleDefaultExports ? addRelatedInfo(diag3, createDiagnosticForNode2(declarationName, index === 0 ? Diagnostics.Another_export_default_is_here : Diagnostics.and_here)) : diag3
             );
@@ -39107,7 +38982,7 @@ function createBinder() {
               relatedInformation.push(createDiagnosticForNode2(decl, Diagnostics.The_first_export_default_is_here));
             }
           });
-          const diag2 = createDiagnosticForNode2(declarationName, message, messageNeedsName ? getDisplayName(node) : void 0);
+          const diag2 = messageNeedsName ? createDiagnosticForNode2(declarationName, message, getDisplayName(node)) : createDiagnosticForNode2(declarationName, message);
           file.bindDiagnostics.push(addRelatedInfo(diag2, ...relatedInformation));
           symbol = createSymbol(0 /* None */, name);
         }
@@ -40568,9 +40443,9 @@ function createBinder() {
       }
     }
   }
-  function errorOnFirstToken(node, message, arg0, arg1, arg2) {
+  function errorOnFirstToken(node, message, ...args) {
     const span = getSpanOfTokenAtPosition(file, node.pos);
-    file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
+    file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, ...args));
   }
   function errorOrSuggestionOnNode(isError, node, message) {
     errorOrSuggestionOnRange(isError, node, node, message);
@@ -42680,6 +42555,7 @@ function createTypeChecker(host) {
   var argumentsSymbol = createSymbol(4 /* Property */, "arguments");
   var requireSymbol = createSymbol(4 /* Property */, "require");
   var isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules";
+  var canCollectSymbolAliasAccessabilityData = !compilerOptions.verbatimModuleSyntax || !!compilerOptions.importsNotUsedAsValues;
   var apparentArgumentCount;
   const checker = {
     getNodeCount: () => reduceLeft(host.getSourceFiles(), (n, s) => n + s.nodeCount, 0),
@@ -43507,8 +43383,8 @@ function createTypeChecker(host) {
     getDiagnostics(sourceFile, cancellationToken2);
     return emitResolver;
   }
-  function lookupOrIssueError(location, message, arg0, arg1, arg2, arg3) {
-    const diagnostic = location ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
+  function lookupOrIssueError(location, message, ...args) {
+    const diagnostic = location ? createDiagnosticForNode(location, message, ...args) : createCompilerDiagnostic(message, ...args);
     const existing = diagnostics.lookup(diagnostic);
     if (existing) {
       return existing;
@@ -43517,16 +43393,16 @@ function createTypeChecker(host) {
       return diagnostic;
     }
   }
-  function errorSkippedOn(key, location, message, arg0, arg1, arg2, arg3) {
-    const diagnostic = error(location, message, arg0, arg1, arg2, arg3);
+  function errorSkippedOn(key, location, message, ...args) {
+    const diagnostic = error(location, message, ...args);
     diagnostic.skippedOn = key;
     return diagnostic;
   }
-  function createError(location, message, arg0, arg1, arg2, arg3) {
-    return location ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
+  function createError(location, message, ...args) {
+    return location ? createDiagnosticForNode(location, message, ...args) : createCompilerDiagnostic(message, ...args);
   }
-  function error(location, message, arg0, arg1, arg2, arg3) {
-    const diagnostic = createError(location, message, arg0, arg1, arg2, arg3);
+  function error(location, message, ...args) {
+    const diagnostic = createError(location, message, ...args);
     diagnostics.add(diagnostic);
     return diagnostic;
   }
@@ -43537,19 +43413,19 @@ function createTypeChecker(host) {
       suggestionDiagnostics.add({ ...diagnostic, category: 2 /* Suggestion */ });
     }
   }
-  function errorOrSuggestion(isError, location, message, arg0, arg1, arg2, arg3) {
+  function errorOrSuggestion(isError, location, message, ...args) {
     if (location.pos < 0 || location.end < 0) {
       if (!isError) {
         return;
       }
       const file = getSourceFileOfNode(location);
-      addErrorOrSuggestion(isError, "message" in message ? createFileDiagnostic(file, 0, 0, message, arg0, arg1, arg2, arg3) : createDiagnosticForFileFromMessageChain(file, message));
+      addErrorOrSuggestion(isError, "message" in message ? createFileDiagnostic(file, 0, 0, message, ...args) : createDiagnosticForFileFromMessageChain(file, message));
       return;
     }
-    addErrorOrSuggestion(isError, "message" in message ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(location), location, message));
+    addErrorOrSuggestion(isError, "message" in message ? createDiagnosticForNode(location, message, ...args) : createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(location), location, message));
   }
-  function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, arg0, arg1, arg2, arg3) {
-    const diagnostic = error(location, message, arg0, arg1, arg2, arg3);
+  function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, ...args) {
+    const diagnostic = error(location, message, ...args);
     if (maybeMissingAwait) {
       const related = createDiagnosticForNode(location, Diagnostics.Did_you_forget_to_use_await);
       addRelatedInfo(diagnostic, related);
@@ -45423,7 +45299,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function markExportAsReferenced(node) {
-    if (compilerOptions.verbatimModuleSyntax) {
+    if (!canCollectSymbolAliasAccessabilityData) {
       return;
     }
     const symbol = getSymbolOfDeclaration(node);
@@ -45436,7 +45312,7 @@ function createTypeChecker(host) {
     }
   }
   function markAliasSymbolAsReferenced(symbol) {
-    Debug.assert(!compilerOptions.verbatimModuleSyntax);
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
     const links = getSymbolLinks(symbol);
     if (!links.referenced) {
       links.referenced = true;
@@ -45567,6 +45443,9 @@ function createTypeChecker(host) {
         }
       }
       symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(namespace), right.escapedText, meaning));
+      if (!symbol && namespace.flags & 2097152 /* Alias */) {
+        symbol = getMergedSymbol(getSymbol(getExportsOfSymbol(resolveAlias(namespace)), right.escapedText, meaning));
+      }
       if (!symbol) {
         if (!ignoreErrors) {
           const namespaceName = getFullyQualifiedName(namespace);
@@ -45603,7 +45482,7 @@ function createTypeChecker(host) {
         return void 0;
       }
     } else {
-      throw Debug.assertNever(name, "Unknown entity name kind.");
+      Debug.assertNever(name, "Unknown entity name kind.");
     }
     Debug.assert((getCheckFlags(symbol) & 1 /* Instantiated */) === 0, "Should never get an instantiated symbol here.");
     if (!nodeIsSynthesized(name) && isEntityName(name) && (symbol.flags & 2097152 /* Alias */ || name.parent.kind === 275 /* ExportAssignment */)) {
@@ -47316,8 +47195,11 @@ function createTypeChecker(host) {
         }
         return typeToTypeNodeHelper(type2, context);
       }
+      function isMappedTypeHomomorphic(type2) {
+        return !!getHomomorphicTypeVariable(type2);
+      }
       function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) {
-        return isMappedTypeWithKeyofConstraintDeclaration(type2) && !(getModifiersTypeFromMappedType(type2).flags & 262144 /* TypeParameter */);
+        return !!type2.target && isMappedTypeHomomorphic(type2.target) && !isMappedTypeHomomorphic(type2);
       }
       function createMappedTypeNodeFromType(type2) {
         Debug.assert(!!(type2.flags & 524288 /* Object */));
@@ -53485,7 +53367,7 @@ function createTypeChecker(host) {
     return simplified !== type ? simplified : getConstraintOfType(type);
   }
   function getConstraintFromIndexedAccess(type) {
-    if (isMappedTypeGenericIndexedAccess(type)) {
+    if (isMappedTypeGenericIndexedAccess(type) || isGenericMappedType(type.objectType)) {
       return substituteIndexedMappedType(type.objectType, type.indexType);
     }
     const indexConstraint = getSimplifiedTypeOrConstraint(type.indexType);
@@ -53721,7 +53603,7 @@ function createTypeChecker(host) {
     const typeVariable = getHomomorphicTypeVariable(type);
     if (typeVariable && !type.declaration.nameType) {
       const constraint = getConstraintOfTypeParameter(typeVariable);
-      if (constraint && isArrayType(constraint)) {
+      if (constraint && everyType(constraint, isArrayOrTupleType)) {
         return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
       }
     }
@@ -55873,6 +55755,12 @@ function createTypeChecker(host) {
       i--;
       const source = types[i];
       if (hasEmptyObject || source.flags & 469499904 /* StructuredOrInstantiable */) {
+        if (source.flags & 262144 /* TypeParameter */ && getBaseConstraintOrType(source).flags & 1048576 /* Union */) {
+          if (isTypeRelatedTo(source, getUnionType(map(types, (t) => t === source ? neverType : t)), strictSubtypeRelation)) {
+            orderedRemoveItemAt(types, i);
+          }
+          continue;
+        }
         const keyProperty = source.flags & (524288 /* Object */ | 2097152 /* Intersection */ | 58982400 /* InstantiableNonPrimitive */) ? find(getPropertiesOfType(source), (p) => isUnitType(getTypeOfSymbol(p))) : void 0;
         const keyPropertyType = keyProperty && getRegularTypeOfLiteralType(getTypeOfSymbol(keyProperty));
         for (const target of types) {
@@ -56440,7 +56328,7 @@ function createTypeChecker(host) {
           links.resolvedType = getTypeFromTypeNode(node.type);
           break;
         default:
-          throw Debug.assertNever(node.operator);
+          Debug.assertNever(node.operator);
       }
     }
     return links.resolvedType;
@@ -56524,7 +56412,7 @@ function createTypeChecker(host) {
     return type;
   }
   function getStringMappingType(symbol, type) {
-    return type.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapType(type, (t) => getStringMappingType(symbol, t)) : type.flags & 2097152 /* Intersection */ ? getIntersectionType(map(type.types, (t) => getStringMappingType(symbol, t))) : type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) : type.flags & 134217728 /* TemplateLiteral */ ? getTemplateLiteralType(...applyTemplateStringMapping(symbol, type.texts, type.types)) : (
+    return type.flags & (1048576 /* Union */ | 131072 /* Never */) ? mapType(type, (t) => getStringMappingType(symbol, t)) : type.flags & 128 /* StringLiteral */ ? getStringLiteralType(applyStringMapping(symbol, type.value)) : type.flags & 134217728 /* TemplateLiteral */ ? getTemplateLiteralType(...applyTemplateStringMapping(symbol, type.texts, type.types)) : (
       // Mapping<Mapping<T>> === Mapping<T>
       type.flags & 268435456 /* StringMapping */ && symbol === type.symbol ? type : type.flags & (1 /* Any */ | 4 /* String */ | 268435456 /* StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) : (
         // This handles Mapping<`${number}`> and Mapping<`${bigint}`>
@@ -57407,7 +57295,10 @@ function createTypeChecker(host) {
           const declarations = concatenate(leftProp.declarations, rightProp.declarations);
           const flags = 4 /* Property */ | leftProp.flags & 16777216 /* Optional */;
           const result = createSymbol(flags, leftProp.escapedName);
-          result.links.type = getUnionType([getTypeOfSymbol(leftProp), removeMissingOrUndefinedType(rightType)], 2 /* Subtype */);
+          const leftType = getTypeOfSymbol(leftProp);
+          const leftTypeWithoutUndefined = removeMissingOrUndefinedType(leftType);
+          const rightTypeWithoutUndefined = removeMissingOrUndefinedType(rightType);
+          result.links.type = leftTypeWithoutUndefined === rightTypeWithoutUndefined ? leftType : getUnionType([leftType, rightTypeWithoutUndefined], 2 /* Subtype */);
           result.links.leftSpread = leftProp;
           result.links.rightSpread = rightProp;
           result.declarations = declarations;
@@ -58198,7 +58089,13 @@ function createTypeChecker(host) {
     return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node);
   }
   function hasContextSensitiveReturnExpression(node) {
-    return !node.typeParameters && !getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 239 /* Block */ && isContextSensitive(node.body);
+    if (node.typeParameters || getEffectiveReturnTypeNode(node) || !node.body) {
+      return false;
+    }
+    if (node.body.kind !== 239 /* Block */) {
+      return isContextSensitive(node.body);
+    }
+    return !!forEachReturnStatement(node.body, (statement) => !!statement.expression && isContextSensitive(statement.expression));
   }
   function isContextSensitiveFunctionOrObjectLiteralMethod(func) {
     return (isFunctionExpressionOrArrowFunction(func) || isObjectLiteralMethod(func)) && isContextSensitiveFunctionLikeDeclaration(func);
@@ -58824,6 +58721,9 @@ function createTypeChecker(host) {
     const targetCount = getParameterCount(target);
     const sourceHasMoreParameters = !hasEffectiveRestParameter(target) && (checkMode & 8 /* StrictArity */ ? hasEffectiveRestParameter(source) || getParameterCount(source) > targetCount : getMinArgumentCount(source) > targetCount);
     if (sourceHasMoreParameters) {
+      if (reportErrors2 && !(checkMode & 8 /* StrictArity */)) {
+        errorReporter(Diagnostics.Target_signature_provides_too_few_arguments_Expected_0_or_more_but_got_1, getMinArgumentCount(source), targetCount);
+      }
       return 0 /* False */;
     }
     if (source.typeParameters && source.typeParameters !== target.typeParameters) {
@@ -58867,7 +58767,12 @@ function createTypeChecker(host) {
     const paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
-      const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
+      const sourceType = i === restIndex ? getRestTypeAtPosition(
+        source,
+        i,
+        /*readonly*/
+        true
+      ) : tryGetTypeAtPosition(source, i);
       const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
@@ -59133,7 +59038,7 @@ function createTypeChecker(host) {
   }
   function getNormalizedType(type, writing) {
     while (true) {
-      const t = isFreshLiteralType(type) ? type.regularType : getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) : type;
+      const t = isFreshLiteralType(type) ? type.regularType : isGenericTupleType(type) ? getNormalizedTupleType(type, writing) : getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) : type;
       if (t === type)
         return t;
       type = t;
@@ -59152,6 +59057,11 @@ function createTypeChecker(host) {
     }
     return type;
   }
+  function getNormalizedTupleType(type, writing) {
+    const elements = getTypeArguments(type);
+    const normalizedElements = sameMap(elements, (t) => t.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(t, writing) : t);
+    return elements !== normalizedElements ? createNormalizedTupleType(type.target, normalizedElements) : type;
+  }
   function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) {
     var _a2;
     let errorInfo;
@@ -59241,10 +59151,10 @@ function createTypeChecker(host) {
         relatedInfo: relatedInfo == null ? void 0 : relatedInfo.slice()
       };
     }
-    function reportIncompatibleError(message, arg0, arg1, arg2, arg3) {
+    function reportIncompatibleError(message, ...args) {
       overrideNextErrorInfo++;
       lastSkippedInfo = void 0;
-      (incompatibleStack || (incompatibleStack = [])).push([message, arg0, arg1, arg2, arg3]);
+      (incompatibleStack || (incompatibleStack = [])).push([message, ...args]);
     }
     function reportIncompatibleStack() {
       const stack = incompatibleStack || [];
@@ -59336,13 +59246,13 @@ function createTypeChecker(host) {
         );
       }
     }
-    function reportError(message, arg0, arg1, arg2, arg3) {
+    function reportError(message, ...args) {
       Debug.assert(!!errorNode);
       if (incompatibleStack)
         reportIncompatibleStack();
       if (message.elidedInCompatabilityPyramid)
         return;
-      errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3);
+      errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
     }
     function associateRelatedInfo(info) {
       Debug.assert(!!errorInfo);
@@ -60522,6 +60432,26 @@ function createTypeChecker(host) {
           )) {
             return result2;
           }
+          if (sourceFlags & 8388608 /* IndexedAccess */) {
+            const indexType = source2.indexType;
+            if (indexType.flags & 4194304 /* Index */) {
+              const unresolvedIndexConstraint = getBaseConstraintOfType(indexType.type);
+              const indexConstraint = unresolvedIndexConstraint && unresolvedIndexConstraint !== noConstraintType ? getIndexType(unresolvedIndexConstraint) : keyofConstraintType;
+              const constraint2 = getIndexedAccessType(source2.objectType, indexConstraint);
+              if (result2 = isRelatedTo(
+                constraint2,
+                target2,
+                1 /* Source */,
+                /*reportErrors*/
+                false,
+                /*headMessage*/
+                void 0,
+                intersectionState
+              )) {
+                return result2;
+              }
+            }
+          }
           if (isMappedTypeGenericIndexedAccess(source2)) {
             const indexConstraint = getConstraintOfType(source2.indexType);
             if (indexConstraint) {
@@ -60629,7 +60559,7 @@ function createTypeChecker(host) {
           if (varianceResult !== void 0) {
             return varianceResult;
           }
-        } else if (isReadonlyArrayType(target2) ? isArrayOrTupleType(source2) : isArrayType(target2) && isTupleType(source2) && !source2.target.readonly) {
+        } else if (isReadonlyArrayType(target2) ? everyType(source2, isArrayOrTupleType) : isArrayType(target2) && everyType(source2, (t) => isTupleType(t) && !t.target.readonly)) {
           if (relation !== identityRelation) {
             return isRelatedTo(getIndexTypeOfType(source2, numberType) || anyType, getIndexTypeOfType(target2, numberType) || anyType, 3 /* Both */, reportErrors2);
           } else {
@@ -61512,22 +61442,7 @@ function createTypeChecker(host) {
     if (match === -1) {
       return defaultValue;
     }
-    let nextMatch = discriminable.indexOf(
-      /*searchElement*/
-      true,
-      match + 1
-    );
-    while (nextMatch !== -1) {
-      if (!isTypeIdenticalTo(target.types[match], target.types[nextMatch])) {
-        return defaultValue;
-      }
-      nextMatch = discriminable.indexOf(
-        /*searchElement*/
-        true,
-        nextMatch + 1
-      );
-    }
-    return target.types[match];
+    return getUnionType(target.types.filter((_, index) => discriminable[index]));
   }
   function isWeakType(type) {
     if (type.flags & 524288 /* Object */) {
@@ -62971,21 +62886,19 @@ function createTypeChecker(host) {
       const saveInferencePriority = inferencePriority;
       inferencePriority = 2048 /* MaxValue */;
       const saveExpandingFlags = expandingFlags;
-      const sourceIdentity = getRecursionIdentity(source);
-      const targetIdentity = getRecursionIdentity(target);
-      if (contains(sourceStack, sourceIdentity))
+      (sourceStack != null ? sourceStack : sourceStack = []).push(source);
+      (targetStack != null ? targetStack : targetStack = []).push(target);
+      if (isDeeplyNestedType(source, sourceStack, sourceStack.length, 2))
         expandingFlags |= 1 /* Source */;
-      if (contains(targetStack, targetIdentity))
+      if (isDeeplyNestedType(target, targetStack, targetStack.length, 2))
         expandingFlags |= 2 /* Target */;
       if (expandingFlags !== 3 /* Both */) {
-        (sourceStack || (sourceStack = [])).push(sourceIdentity);
-        (targetStack || (targetStack = [])).push(targetIdentity);
         action(source, target);
-        targetStack.pop();
-        sourceStack.pop();
       } else {
         inferencePriority = -1 /* Circularity */;
       }
+      targetStack.pop();
+      sourceStack.pop();
       expandingFlags = saveExpandingFlags;
       visited.set(key, inferencePriority);
       inferencePriority = Math.min(inferencePriority, saveInferencePriority);
@@ -63127,7 +63040,11 @@ function createTypeChecker(host) {
         return true;
       }
       if (constraintType.flags & 262144 /* TypeParameter */) {
-        inferWithPriority(getIndexType(source), constraintType, 32 /* MappedTypeConstraint */);
+        inferWithPriority(getIndexType(
+          source,
+          /*indexFlags*/
+          !!source.pattern ? 2 /* NoIndexSignatures */ : 0 /* None */
+        ), constraintType, 32 /* MappedTypeConstraint */);
         const extendedConstraint = getConstraintOfType(constraintType);
         if (extendedConstraint && inferToMappedType(source, target, extendedConstraint)) {
           return true;
@@ -63600,36 +63517,34 @@ function createTypeChecker(host) {
     return type.flags & 8192 /* UniqueESSymbol */ ? type.escapedName : type.flags & 384 /* StringOrNumberLiteral */ ? escapeLeadingUnderscores("" + type.value) : void 0;
   }
   function tryGetElementAccessExpressionName(node) {
-    if (isStringOrNumericLiteralLike(node.argumentExpression)) {
-      return escapeLeadingUnderscores(node.argumentExpression.text);
+    return isStringOrNumericLiteralLike(node.argumentExpression) ? escapeLeadingUnderscores(node.argumentExpression.text) : isEntityNameExpression(node.argumentExpression) ? tryGetNameFromEntityNameExpression(node.argumentExpression) : void 0;
+  }
+  function tryGetNameFromEntityNameExpression(node) {
+    const symbol = resolveEntityName(
+      node,
+      111551 /* Value */,
+      /*ignoreErrors*/
+      true
+    );
+    if (!symbol || !(isConstVariable(symbol) || symbol.flags & 8 /* EnumMember */))
+      return void 0;
+    const declaration = symbol.valueDeclaration;
+    if (declaration === void 0)
+      return void 0;
+    const type = tryGetTypeFromEffectiveTypeNode(declaration);
+    if (type) {
+      const name = tryGetNameFromType(type);
+      if (name !== void 0) {
+        return name;
+      }
     }
-    if (isEntityNameExpression(node.argumentExpression)) {
-      const symbol = resolveEntityName(
-        node.argumentExpression,
-        111551 /* Value */,
-        /*ignoreErrors*/
-        true
-      );
-      if (!symbol || !(isConstVariable(symbol) || symbol.flags & 8 /* EnumMember */))
-        return void 0;
-      const declaration = symbol.valueDeclaration;
-      if (declaration === void 0)
-        return void 0;
-      const type = tryGetTypeFromEffectiveTypeNode(declaration);
-      if (type) {
-        const name = tryGetNameFromType(type);
-        if (name !== void 0) {
-          return name;
-        }
+    if (hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node)) {
+      const initializer = getEffectiveInitializer(declaration);
+      if (initializer) {
+        return tryGetNameFromType(getTypeOfExpression(initializer));
       }
-      if (hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node.argumentExpression)) {
-        const initializer = getEffectiveInitializer(declaration);
-        if (initializer) {
-          return tryGetNameFromType(getTypeOfExpression(initializer));
-        }
-        if (isEnumMember(declaration)) {
-          return getTextOfPropertyName(declaration.name);
-        }
+      if (isEnumMember(declaration)) {
+        return getTextOfPropertyName(declaration.name);
       }
     }
     return void 0;
@@ -65547,7 +65462,7 @@ function createTypeChecker(host) {
     });
   }
   function markAliasReferenced(symbol, location) {
-    if (compilerOptions.verbatimModuleSyntax) {
+    if (!canCollectSymbolAliasAccessabilityData) {
       return;
     }
     if (isNonLocalAlias(
@@ -66839,7 +66754,11 @@ function createTypeChecker(host) {
     if (instantiatedType && !(contextFlags && contextFlags & 2 /* NoConstraints */ && instantiatedType.flags & 8650752 /* TypeVariable */)) {
       const apparentType = mapType(
         instantiatedType,
-        getApparentType,
+        // When obtaining apparent type of *contextual* type we don't want to get apparent type of mapped types.
+        // That would evaluate mapped types with array or tuple type constraints too eagerly
+        // and thus it would prevent `getTypeOfPropertyOfContextualType` from obtaining per-position contextual type for elements of array literal expressions.
+        // Apparent type of other mapped types is already the mapped type itself so we can just avoid calling `getApparentType` here for all mapped types.
+        (t) => getObjectFlags(t) & 32 /* Mapped */ ? t : getApparentType(t),
         /*noReductions*/
         true
       );
@@ -68104,7 +68023,7 @@ function createTypeChecker(host) {
       }
       if (jsxFactorySym) {
         jsxFactorySym.isReferenced = 67108863 /* All */;
-        if (!compilerOptions.verbatimModuleSyntax && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
+        if (canCollectSymbolAliasAccessabilityData && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
           markAliasSymbolAsReferenced(jsxFactorySym);
         }
       }
@@ -69678,16 +69597,16 @@ function createTypeChecker(host) {
     }
     return { start, length: length2, sourceFile };
   }
-  function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
+  function getDiagnosticForCallNode(node, message, ...args) {
     if (isCallExpression(node)) {
       const { sourceFile, start, length: length2 } = getDiagnosticSpanForCallNode(node);
       if ("message" in message) {
-        return createFileDiagnostic(sourceFile, start, length2, message, arg0, arg1, arg2, arg3);
+        return createFileDiagnostic(sourceFile, start, length2, message, ...args);
       }
       return createDiagnosticForFileFromMessageChain(sourceFile, message);
     } else {
       if ("message" in message) {
-        return createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
+        return createDiagnosticForNode(node, message, ...args);
       }
       return createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, message);
     }
@@ -69775,11 +69694,8 @@ function createTypeChecker(host) {
       }
       const parameter = (_a2 = closestSignature == null ? void 0 : closestSignature.declaration) == null ? void 0 : _a2.parameters[closestSignature.thisParameter ? args.length + 1 : args.length];
       if (parameter) {
-        const parameterError = createDiagnosticForNode(
-          parameter,
-          isBindingPattern(parameter.name) ? Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided : isRestParameter(parameter) ? Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided : Diagnostics.An_argument_for_0_was_not_provided,
-          !parameter.name ? args.length : !isBindingPattern(parameter.name) ? idText(getFirstIdentifier(parameter.name)) : void 0
-        );
+        const messageAndArgs = isBindingPattern(parameter.name) ? [Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided] : isRestParameter(parameter) ? [Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided, idText(getFirstIdentifier(parameter.name))] : [Diagnostics.An_argument_for_0_was_not_provided, !parameter.name ? args.length : idText(getFirstIdentifier(parameter.name))];
+        const parameterError = createDiagnosticForNode(parameter, ...messageAndArgs);
         return addRelatedInfo(diagnostic, parameterError);
       }
       return diagnostic;
@@ -70710,7 +70626,7 @@ function createTypeChecker(host) {
       case 283 /* JsxSelfClosingElement */:
         return resolveJsxOpeningLikeElement(node, candidatesOutArray, checkMode);
     }
-    throw Debug.assertNever(node, "Branch in 'resolveSignature' should be unreachable.");
+    Debug.assertNever(node, "Branch in 'resolveSignature' should be unreachable.");
   }
   function getResolvedSignature(node, candidatesOutArray, checkMode) {
     const links = getNodeLinks(node);
@@ -71384,12 +71300,12 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function getRestTypeAtPosition(source, pos) {
+  function getRestTypeAtPosition(source, pos, readonly = false) {
     const parameterCount = getParameterCount(source);
     const minArgumentCount = getMinArgumentCount(source);
     const restType = getEffectiveRestType(source);
     if (restType && pos >= parameterCount - 1) {
-      return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType));
+      return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType), readonly);
     }
     const types = [];
     const flags = [];
@@ -71407,13 +71323,7 @@ function createTypeChecker(host) {
         names.push(name);
       }
     }
-    return createTupleType(
-      types,
-      flags,
-      /*readonly*/
-      false,
-      length(names) === length(types) ? names : void 0
-    );
+    return createTupleType(types, flags, readonly, length(names) === length(types) ? names : void 0);
   }
   function getParameterCount(signature) {
     const length2 = signature.parameters.length;
@@ -75119,9 +75029,9 @@ function createTypeChecker(host) {
       }
     }
   }
-  function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, arg0) {
+  function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, ...args) {
     const promisedType = getPromisedTypeOfPromise(type, errorNode);
-    return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
+    return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, ...args);
   }
   function getPromisedTypeOfPromise(type, errorNode, thisTypeForErrorOut) {
     if (isTypeAny(type)) {
@@ -75184,8 +75094,8 @@ function createTypeChecker(host) {
     }
     return typeAsPromise.promisedTypeOfPromise = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), 2 /* Subtype */);
   }
-  function checkAwaitedType(type, withAlias, errorNode, diagnosticMessage, arg0) {
-    const awaitedType = withAlias ? getAwaitedType(type, errorNode, diagnosticMessage, arg0) : getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0);
+  function checkAwaitedType(type, withAlias, errorNode, diagnosticMessage, ...args) {
+    const awaitedType = withAlias ? getAwaitedType(type, errorNode, diagnosticMessage, ...args) : getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, ...args);
     return awaitedType || errorType;
   }
   function isThenableType(type) {
@@ -75241,11 +75151,11 @@ function createTypeChecker(host) {
     Debug.assert(isAwaitedTypeInstantiation(type) || getPromisedTypeOfPromise(type) === void 0, "type provided should not be a non-generic 'promise'-like.");
     return type;
   }
-  function getAwaitedType(type, errorNode, diagnosticMessage, arg0) {
-    const awaitedType = getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0);
+  function getAwaitedType(type, errorNode, diagnosticMessage, ...args) {
+    const awaitedType = getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, ...args);
     return awaitedType && createAwaitedTypeIfNeeded(awaitedType);
   }
-  function getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0) {
+  function getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, ...args) {
     if (isTypeAny(type)) {
       return type;
     }
@@ -75263,7 +75173,7 @@ function createTypeChecker(host) {
         }
         return void 0;
       }
-      const mapper = errorNode ? (constituentType) => getAwaitedTypeNoAlias(constituentType, errorNode, diagnosticMessage, arg0) : getAwaitedTypeNoAlias;
+      const mapper = errorNode ? (constituentType) => getAwaitedTypeNoAlias(constituentType, errorNode, diagnosticMessage, ...args) : getAwaitedTypeNoAlias;
       awaitedTypeStack.push(type.id);
       const mapped = mapType(type, mapper);
       awaitedTypeStack.pop();
@@ -75287,7 +75197,7 @@ function createTypeChecker(host) {
         return void 0;
       }
       awaitedTypeStack.push(type.id);
-      const awaitedType = getAwaitedTypeNoAlias(promisedType, errorNode, diagnosticMessage, arg0);
+      const awaitedType = getAwaitedTypeNoAlias(promisedType, errorNode, diagnosticMessage, ...args);
       awaitedTypeStack.pop();
       if (!awaitedType) {
         return void 0;
@@ -75301,7 +75211,7 @@ function createTypeChecker(host) {
         if (thisTypeForErrorOut.value) {
           chain = chainDiagnosticMessages(chain, Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForErrorOut.value));
         }
-        chain = chainDiagnosticMessages(chain, diagnosticMessage, arg0);
+        chain = chainDiagnosticMessages(chain, diagnosticMessage, ...args);
         diagnostics.add(createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(errorNode), errorNode, chain));
       }
       return void 0;
@@ -75479,7 +75389,7 @@ function createTypeChecker(host) {
       true
     );
     if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
-      if (!compilerOptions.verbatimModuleSyntax && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
+      if (canCollectSymbolAliasAccessabilityData && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
         markAliasSymbolAsReferenced(rootSymbol);
       } else if (forDecoratorMetadata && getIsolatedModules(compilerOptions) && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
         const diag2 = error(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
@@ -75888,9 +75798,8 @@ function createTypeChecker(host) {
           const sourceFile = getSourceFileOfNode(parent);
           const range = isJSDocTemplateTag(parent) ? rangeOfNode(parent) : rangeOfTypeParameters(sourceFile, parent.typeParameters);
           const only = parent.typeParameters.length === 1;
-          const message = only ? Diagnostics._0_is_declared_but_its_value_is_never_read : Diagnostics.All_type_parameters_are_unused;
-          const arg0 = only ? name : void 0;
-          addDiagnostic(typeParameter, 1 /* Parameter */, createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, message, arg0));
+          const messageAndArg = only ? [Diagnostics._0_is_declared_but_its_value_is_never_read, name] : [Diagnostics.All_type_parameters_are_unused];
+          addDiagnostic(typeParameter, 1 /* Parameter */, createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, ...messageAndArg));
         }
       } else {
         addDiagnostic(typeParameter, 1 /* Parameter */, createDiagnosticForNode(typeParameter, Diagnostics._0_is_declared_but_its_value_is_never_read, name));
@@ -77448,7 +77357,7 @@ function createTypeChecker(host) {
             forEachKey(catchClause.locals, (caughtName) => {
               const blockLocal = blockLocals.get(caughtName);
               if ((blockLocal == null ? void 0 : blockLocal.valueDeclaration) && (blockLocal.flags & 2 /* BlockScopedVariable */) !== 0) {
-                grammarErrorOnNode(blockLocal.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName);
+                grammarErrorOnNode(blockLocal.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, unescapeLeadingUnderscores(caughtName));
               }
             });
           }
@@ -79044,6 +78953,9 @@ function createTypeChecker(host) {
     ) && !getSymbolLinks(getSymbolOfDeclaration(statement)).constEnumReferenced;
   }
   function checkImportsForTypeOnlyConversion(sourceFile) {
+    if (!canCollectSymbolAliasAccessabilityData) {
+      return;
+    }
     for (const statement of sourceFile.statements) {
       if (canConvertImportDeclarationToTypeOnly(statement) || canConvertImportEqualsDeclarationToTypeOnly(statement)) {
         error(
@@ -79129,14 +79041,14 @@ function createTypeChecker(host) {
         markAliasReferenced(sym, id);
         if (getAllSymbolFlags(sym) & 111551 /* Value */) {
           checkExpressionCached(id);
-          if (!isIllegalExportDefaultInCJS && compilerOptions.verbatimModuleSyntax && getTypeOnlyAliasDeclaration(sym, 111551 /* Value */)) {
+          if (!isIllegalExportDefaultInCJS && !(node.flags & 16777216 /* Ambient */) && compilerOptions.verbatimModuleSyntax && getTypeOnlyAliasDeclaration(sym, 111551 /* Value */)) {
             error(
               id,
               node.isExportEquals ? Diagnostics.An_export_declaration_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration : Diagnostics.An_export_default_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration,
               idText(id)
             );
           }
-        } else if (!isIllegalExportDefaultInCJS && compilerOptions.verbatimModuleSyntax) {
+        } else if (!isIllegalExportDefaultInCJS && !(node.flags & 16777216 /* Ambient */) && compilerOptions.verbatimModuleSyntax) {
           error(
             id,
             node.isExportEquals ? Diagnostics.An_export_declaration_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type : Diagnostics.An_export_default_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type,
@@ -80473,7 +80385,7 @@ function createTypeChecker(host) {
     return false;
   }
   function isValueAliasDeclaration(node) {
-    Debug.assert(!compilerOptions.verbatimModuleSyntax);
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
     switch (node.kind) {
       case 269 /* ImportEqualsDeclaration */:
         return isAliasResolvedToValue(getSymbolOfDeclaration(node));
@@ -80514,7 +80426,7 @@ function createTypeChecker(host) {
     return isConstEnumSymbol(s) || !!s.constEnumOnlyModule;
   }
   function isReferencedAliasDeclaration(node, checkChildren) {
-    Debug.assert(!compilerOptions.verbatimModuleSyntax);
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
     if (isAliasSymbolDeclaration(node)) {
       const symbol = getSymbolOfDeclaration(node);
       const links = symbol && getSymbolLinks(symbol);
@@ -80852,12 +80764,12 @@ function createTypeChecker(host) {
       isDeclarationWithCollidingName,
       isValueAliasDeclaration: (nodeIn) => {
         const node = getParseTreeNode(nodeIn);
-        return node ? isValueAliasDeclaration(node) : true;
+        return node && canCollectSymbolAliasAccessabilityData ? isValueAliasDeclaration(node) : true;
       },
       hasGlobalName,
       isReferencedAliasDeclaration: (nodeIn, checkChildren) => {
         const node = getParseTreeNode(nodeIn);
-        return node ? isReferencedAliasDeclaration(node, checkChildren) : true;
+        return node && canCollectSymbolAliasAccessabilityData ? isReferencedAliasDeclaration(node, checkChildren) : true;
       },
       getNodeCheckFlags: (nodeIn) => {
         const node = getParseTreeNode(nodeIn);
@@ -81989,10 +81901,10 @@ function createTypeChecker(host) {
           currentKind = 2 /* SetAccessor */;
           break;
         default:
-          throw Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind);
+          Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind);
       }
       if (!inDestructuring) {
-        const effectiveName = getPropertyNameForPropertyNameNode(name);
+        const effectiveName = getEffectivePropertyNameForPropertyNameNode(name);
         if (effectiveName === void 0) {
           continue;
         }
@@ -82461,12 +82373,12 @@ function createTypeChecker(host) {
     switch (node.keywordToken) {
       case 104 /* NewKeyword */:
         if (escapedText !== "target") {
-          return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, tokenToString(node.keywordToken), "target");
+          return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, unescapeLeadingUnderscores(node.name.escapedText), tokenToString(node.keywordToken), "target");
         }
         break;
       case 101 /* ImportKeyword */:
         if (escapedText !== "meta") {
-          return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, tokenToString(node.keywordToken), "meta");
+          return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, unescapeLeadingUnderscores(node.name.escapedText), tokenToString(node.keywordToken), "meta");
         }
         break;
     }
@@ -82474,35 +82386,35 @@ function createTypeChecker(host) {
   function hasParseDiagnostics(sourceFile) {
     return sourceFile.parseDiagnostics.length > 0;
   }
-  function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+  function grammarErrorOnFirstToken(node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
     if (!hasParseDiagnostics(sourceFile)) {
       const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
-      diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
+      diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, ...args));
       return true;
     }
     return false;
   }
-  function grammarErrorAtPos(nodeForSourceFile, start, length2, message, arg0, arg1, arg2) {
+  function grammarErrorAtPos(nodeForSourceFile, start, length2, message, ...args) {
     const sourceFile = getSourceFileOfNode(nodeForSourceFile);
     if (!hasParseDiagnostics(sourceFile)) {
-      diagnostics.add(createFileDiagnostic(sourceFile, start, length2, message, arg0, arg1, arg2));
+      diagnostics.add(createFileDiagnostic(sourceFile, start, length2, message, ...args));
       return true;
     }
     return false;
   }
-  function grammarErrorOnNodeSkippedOn(key, node, message, arg0, arg1, arg2) {
+  function grammarErrorOnNodeSkippedOn(key, node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
     if (!hasParseDiagnostics(sourceFile)) {
-      errorSkippedOn(key, node, message, arg0, arg1, arg2);
+      errorSkippedOn(key, node, message, ...args);
       return true;
     }
     return false;
   }
-  function grammarErrorOnNode(node, message, arg0, arg1, arg2) {
+  function grammarErrorOnNode(node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
     if (!hasParseDiagnostics(sourceFile)) {
-      diagnostics.add(createDiagnosticForNode(node, message, arg0, arg1, arg2));
+      diagnostics.add(createDiagnosticForNode(node, message, ...args));
       return true;
     }
     return false;
@@ -82647,7 +82559,7 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) {
+  function grammarErrorAfterFirstToken(node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
     if (!hasParseDiagnostics(sourceFile)) {
       const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
@@ -82657,9 +82569,7 @@ function createTypeChecker(host) {
         /*length*/
         0,
         message,
-        arg0,
-        arg1,
-        arg2
+        ...args
       ));
       return true;
     }
@@ -82805,6 +82715,10 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
+  function getEffectivePropertyNameForPropertyNameNode(node) {
+    const name = getPropertyNameForPropertyNameNode(node);
+    return name ? name : isComputedPropertyName(node) && isEntityNameExpression(node.expression) ? tryGetNameFromEntityNameExpression(node.expression) : void 0;
+  }
 }
 function isNotAccessor(declaration) {
   return !isAccessor(declaration);
@@ -94698,10 +94612,13 @@ function transformJsx(context) {
         return Debug.failBadSyntaxKind(node);
     }
   }
+  function hasProto(obj) {
+    return obj.properties.some((p) => isPropertyAssignment(p) && (isIdentifier(p.name) && idText(p.name) === "__proto__" || isStringLiteral(p.name) && p.name.text === "__proto__"));
+  }
   function hasKeyAfterPropsSpread(node) {
     let spread = false;
     for (const elem of node.attributes.properties) {
-      if (isJsxSpreadAttribute(elem)) {
+      if (isJsxSpreadAttribute(elem) && (!isObjectLiteralExpression(elem.expression) || elem.expression.properties.some(isSpreadAssignment))) {
         spread = true;
       } else if (spread && isJsxAttribute(elem) && elem.name.escapedText === "key") {
         return true;
@@ -94867,7 +94784,10 @@ function transformJsx(context) {
     }
     return element;
   }
-  function transformJsxSpreadAttributeToSpreadAssignment(node) {
+  function transformJsxSpreadAttributeToProps(node) {
+    if (isObjectLiteralExpression(node.expression) && !hasProto(node.expression)) {
+      return node.expression.properties;
+    }
     return factory2.createSpreadAssignment(Debug.checkDefined(visitNode(node.expression, visitor, isExpression)));
   }
   function transformJsxAttributesToObjectProps(attrs, children) {
@@ -94875,30 +94795,48 @@ function transformJsx(context) {
     return target && target >= 5 /* ES2018 */ ? factory2.createObjectLiteralExpression(transformJsxAttributesToProps(attrs, children)) : transformJsxAttributesToExpression(attrs, children);
   }
   function transformJsxAttributesToProps(attrs, children) {
-    const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToSpreadAssignment(attr) : transformJsxAttributeToObjectLiteralElement(attr))));
+    const props = flatten(spanMap(attrs, isJsxSpreadAttribute, (attrs2, isSpread) => flatten(map(attrs2, (attr) => isSpread ? transformJsxSpreadAttributeToProps(attr) : transformJsxAttributeToObjectLiteralElement(attr)))));
     if (children) {
       props.push(children);
     }
     return props;
   }
   function transformJsxAttributesToExpression(attrs, children) {
-    const expressions = flatten(
-      spanMap(
-        attrs,
-        isJsxSpreadAttribute,
-        (attrs2, isSpread) => isSpread ? map(attrs2, transformJsxSpreadAttributeToExpression) : factory2.createObjectLiteralExpression(map(attrs2, transformJsxAttributeToObjectLiteralElement))
-      )
-    );
-    if (isJsxSpreadAttribute(attrs[0])) {
-      expressions.unshift(factory2.createObjectLiteralExpression());
+    const expressions = [];
+    let properties = [];
+    for (const attr of attrs) {
+      if (isJsxSpreadAttribute(attr)) {
+        if (isObjectLiteralExpression(attr.expression) && !hasProto(attr.expression)) {
+          for (const prop of attr.expression.properties) {
+            if (isSpreadAssignment(prop)) {
+              finishObjectLiteralIfNeeded();
+              expressions.push(prop.expression);
+              continue;
+            }
+            properties.push(prop);
+          }
+          continue;
+        }
+        finishObjectLiteralIfNeeded();
+        expressions.push(attr.expression);
+        continue;
+      }
+      properties.push(transformJsxAttributeToObjectLiteralElement(attr));
     }
     if (children) {
-      expressions.push(factory2.createObjectLiteralExpression([children]));
+      properties.push(children);
+    }
+    finishObjectLiteralIfNeeded();
+    if (expressions.length && !isObjectLiteralExpression(expressions[0])) {
+      expressions.unshift(factory2.createObjectLiteralExpression());
     }
     return singleOrUndefined(expressions) || emitHelpers().createAssignHelper(expressions);
-  }
-  function transformJsxSpreadAttributeToExpression(node) {
-    return Debug.checkDefined(visitNode(node.expression, visitor, isExpression));
+    function finishObjectLiteralIfNeeded() {
+      if (properties.length) {
+        expressions.push(factory2.createObjectLiteralExpression(properties));
+        properties = [];
+      }
+    }
   }
   function transformJsxAttributeToObjectLiteralElement(node) {
     const name = getAttributeName(node);
@@ -106975,8 +106913,7 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
   }
 }
 function createBuildInfo(program, bundle) {
-  const version2 = version;
-  return { bundle, program, version: version2 };
+  return { bundle, program, version };
 }
 function getBuildInfoText(buildInfo) {
   return JSON.stringify(buildInfo);
@@ -107064,10 +107001,10 @@ function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
     /*separateBeginAndEnd*/
     true
   );
-  ts_performance_exports.mark("beforeEmit");
+  mark("beforeEmit");
   const result = emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers);
-  ts_performance_exports.mark("afterEmit");
-  ts_performance_exports.measure("Emit", "beforeEmit", "afterEmit");
+  mark("afterEmit");
+  measure("Emit", "beforeEmit", "afterEmit");
   (_b = tracing) == null ? void 0 : _b.pop();
   return result;
 }
@@ -111081,12 +111018,12 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     return cache[nodeId] || (cache[nodeId] = generateNameForNode(node, privateName, flags != null ? flags : 0 /* None */, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix)));
   }
   function isUniqueName(name, privateName) {
-    return isFileLevelUniqueName2(name, privateName) && !isReservedName(name, privateName) && !generatedNames.has(name);
+    return isFileLevelUniqueNameInCurrentFile(name, privateName) && !isReservedName(name, privateName) && !generatedNames.has(name);
   }
   function isReservedName(name, privateName) {
     return privateName ? !!(reservedPrivateNames == null ? void 0 : reservedPrivateNames.has(name)) : !!(reservedNames == null ? void 0 : reservedNames.has(name));
   }
-  function isFileLevelUniqueName2(name, _isPrivate) {
+  function isFileLevelUniqueNameInCurrentFile(name, _isPrivate) {
     return currentSourceFile ? isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true;
   }
   function isUniqueLocalName(name, container) {
@@ -111205,7 +111142,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   function makeFileLevelOptimisticUniqueName(name) {
     return makeUniqueName(
       name,
-      isFileLevelUniqueName2,
+      isFileLevelUniqueNameInCurrentFile,
       /*optimistic*/
       true,
       /*scoped*/
@@ -111385,7 +111322,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       case 3 /* Unique */:
         return makeUniqueName(
           idText(name),
-          autoGenerate.flags & 32 /* FileLevel */ ? isFileLevelUniqueName2 : isUniqueName,
+          autoGenerate.flags & 32 /* FileLevel */ ? isFileLevelUniqueNameInCurrentFile : isUniqueName,
           !!(autoGenerate.flags & 16 /* Optimistic */),
           !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */),
           isPrivateIdentifier(name),
@@ -114406,12 +114343,12 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           }
         }
       }
-      function createDiagnosticForNodeArray2(nodes, message, arg0, arg1, arg2) {
+      function createDiagnosticForNodeArray2(nodes, message, ...args) {
         const start = nodes.pos;
-        return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2);
+        return createFileDiagnostic(sourceFile, start, nodes.end - start, message, ...args);
       }
-      function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
-        return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2);
+      function createDiagnosticForNode2(node, message, ...args) {
+        return createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args);
       }
     });
   }
@@ -115076,11 +115013,12 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         const unqualifiedLibName = removeSuffix(removePrefix(libName, "lib."), ".d.ts");
         const suggestion = getSpellingSuggestion(unqualifiedLibName, libs, identity);
         const diagnostic = suggestion ? Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : Diagnostics.Cannot_find_lib_definition_for_0;
+        const args = suggestion ? [libName, suggestion] : [libName];
         (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
           kind: 0 /* FilePreprocessingReferencedDiagnostic */,
           reason: { kind: 7 /* LibReferenceDirective */, file: file.path, index },
           diagnostic,
-          args: [libName, suggestion]
+          args
         });
       }
     });
@@ -115545,7 +115483,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
   }
   function verifyDeprecatedCompilerOptions() {
-    function createDiagnostic(name, value, useInstead, message, arg0, arg1, arg2, arg3) {
+    function createDiagnostic(name, value, useInstead, message, ...args) {
       if (useInstead) {
         const details = chainDiagnosticMessages(
           /*details*/
@@ -115553,7 +115491,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           Diagnostics.Use_0_instead,
           useInstead
         );
-        const chain = chainDiagnosticMessages(details, message, arg0, arg1, arg2, arg3);
+        const chain = chainDiagnosticMessages(details, message, ...args);
         createDiagnosticForOption(
           /*onKey*/
           !value,
@@ -115570,10 +115508,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           /*option2*/
           void 0,
           message,
-          arg0,
-          arg1,
-          arg2,
-          arg3
+          ...args
         );
       }
     }
@@ -115626,8 +115561,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     });
   }
   function verifyDeprecatedProjectReference(ref, parentFile, index) {
-    function createDiagnostic(_name, _value, _useInstead, message, arg0, arg1, arg2, arg3) {
-      createDiagnosticForReference(parentFile, index, message, arg0, arg1, arg2, arg3);
+    function createDiagnostic(_name, _value, _useInstead, message, ...args) {
+      createDiagnosticForReference(parentFile, index, message, ...args);
     }
     checkDeprecations("5.0", "5.5", createDiagnostic, (createDeprecatedDiagnostic) => {
       if (ref.prepend) {
@@ -115739,8 +115674,9 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         if (!referenceInfo)
           return void 0;
         const { sourceFile, index } = referenceInfo;
-        const referencesSyntax = firstDefined(
-          getTsConfigPropArray(sourceFile, "references"),
+        const referencesSyntax = forEachTsConfigPropArray(
+          sourceFile,
+          "references",
           (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0
         );
         return referencesSyntax && referencesSyntax.elements.length > index ? createDiagnosticForNodeInSourceFile(
@@ -115809,28 +115745,26 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       }
     });
   }
-  function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, arg0, arg1, arg2) {
+  function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, ...args) {
     let needCompilerDiagnostic = true;
-    const pathsSyntax = getOptionPathsSyntax();
-    for (const pathProp of pathsSyntax) {
+    forEachOptionPathsSyntax((pathProp) => {
       if (isObjectLiteralExpression(pathProp.initializer)) {
-        for (const keyProps of getPropertyAssignment(pathProp.initializer, key)) {
+        forEachPropertyAssignment(pathProp.initializer, key, (keyProps) => {
           const initializer = keyProps.initializer;
           if (isArrayLiteralExpression(initializer) && initializer.elements.length > valueIndex) {
-            programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message, arg0, arg1, arg2));
+            programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, initializer.elements[valueIndex], message, ...args));
             needCompilerDiagnostic = false;
           }
-        }
+        });
       }
-    }
+    });
     if (needCompilerDiagnostic) {
-      programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1, arg2));
+      programDiagnostics.add(createCompilerDiagnostic(message, ...args));
     }
   }
-  function createDiagnosticForOptionPaths(onKey, key, message, arg0) {
+  function createDiagnosticForOptionPaths(onKey, key, message, ...args) {
     let needCompilerDiagnostic = true;
-    const pathsSyntax = getOptionPathsSyntax();
-    for (const pathProp of pathsSyntax) {
+    forEachOptionPathsSyntax((pathProp) => {
       if (isObjectLiteralExpression(pathProp.initializer) && createOptionDiagnosticInObjectLiteralSyntax(
         pathProp.initializer,
         onKey,
@@ -115838,25 +115772,23 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         /*key2*/
         void 0,
         message,
-        arg0
+        ...args
       )) {
         needCompilerDiagnostic = false;
       }
-    }
+    });
     if (needCompilerDiagnostic) {
-      programDiagnostics.add(createCompilerDiagnostic(message, arg0));
+      programDiagnostics.add(createCompilerDiagnostic(message, ...args));
     }
   }
-  function getOptionsSyntaxByName(name) {
-    const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
-    return compilerOptionsObjectLiteralSyntax && getPropertyAssignment(compilerOptionsObjectLiteralSyntax, name);
+  function forEachOptionsSyntaxByName(name, callback) {
+    return forEachPropertyAssignment(getCompilerOptionsObjectLiteralSyntax(), name, callback);
   }
-  function getOptionPathsSyntax() {
-    return getOptionsSyntaxByName("paths") || emptyArray;
+  function forEachOptionPathsSyntax(callback) {
+    return forEachOptionsSyntaxByName("paths", callback);
   }
   function getOptionsSyntaxByValue(name, value) {
-    const syntaxByName = getOptionsSyntaxByName(name);
-    return syntaxByName && firstDefined(syntaxByName, (property) => isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : void 0);
+    return forEachOptionsSyntaxByName(name, (property) => isStringLiteral(property.initializer) && property.initializer.text === value ? property.initializer : void 0);
   }
   function getOptionsSyntaxByArrayElementValue(name, value) {
     const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
@@ -115874,7 +115806,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       option3
     );
   }
-  function createOptionValueDiagnostic(option1, message, arg0, arg1) {
+  function createOptionValueDiagnostic(option1, message, ...args) {
     createDiagnosticForOption(
       /*onKey*/
       false,
@@ -115882,57 +115814,53 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       /*option2*/
       void 0,
       message,
-      arg0,
-      arg1
+      ...args
     );
   }
-  function createDiagnosticForReference(sourceFile, index, message, arg0, arg1, arg2, arg3) {
-    const referencesSyntax = firstDefined(
-      getTsConfigPropArray(sourceFile || options.configFile, "references"),
+  function createDiagnosticForReference(sourceFile, index, message, ...args) {
+    const referencesSyntax = forEachTsConfigPropArray(
+      sourceFile || options.configFile,
+      "references",
       (property) => isArrayLiteralExpression(property.initializer) ? property.initializer : void 0
     );
     if (referencesSyntax && referencesSyntax.elements.length > index) {
-      programDiagnostics.add(createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message, arg0, arg1, arg2, arg3));
+      programDiagnostics.add(createDiagnosticForNodeInSourceFile(sourceFile || options.configFile, referencesSyntax.elements[index], message, ...args));
     } else {
-      programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1, arg2, arg3));
+      programDiagnostics.add(createCompilerDiagnostic(message, ...args));
     }
   }
-  function createDiagnosticForOption(onKey, option1, option2, message, arg0, arg1, arg2, arg3) {
+  function createDiagnosticForOption(onKey, option1, option2, message, ...args) {
     const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
-    const needCompilerDiagnostic = !compilerOptionsObjectLiteralSyntax || !createOptionDiagnosticInObjectLiteralSyntax(compilerOptionsObjectLiteralSyntax, onKey, option1, option2, message, arg0, arg1, arg2, arg3);
+    const needCompilerDiagnostic = !compilerOptionsObjectLiteralSyntax || !createOptionDiagnosticInObjectLiteralSyntax(compilerOptionsObjectLiteralSyntax, onKey, option1, option2, message, ...args);
     if (needCompilerDiagnostic) {
       if ("messageText" in message) {
         programDiagnostics.add(createCompilerDiagnosticFromMessageChain(message));
       } else {
-        programDiagnostics.add(createCompilerDiagnostic(message, arg0, arg1, arg2, arg3));
+        programDiagnostics.add(createCompilerDiagnostic(message, ...args));
       }
     }
   }
   function getCompilerOptionsObjectLiteralSyntax() {
     if (_compilerOptionsObjectLiteralSyntax === void 0) {
-      _compilerOptionsObjectLiteralSyntax = false;
-      const jsonObjectLiteral = getTsConfigObjectLiteralExpression(options.configFile);
-      if (jsonObjectLiteral) {
-        for (const prop of getPropertyAssignment(jsonObjectLiteral, "compilerOptions")) {
-          if (isObjectLiteralExpression(prop.initializer)) {
-            _compilerOptionsObjectLiteralSyntax = prop.initializer;
-            break;
-          }
-        }
-      }
+      _compilerOptionsObjectLiteralSyntax = forEachPropertyAssignment(
+        getTsConfigObjectLiteralExpression(options.configFile),
+        "compilerOptions",
+        (prop) => isObjectLiteralExpression(prop.initializer) ? prop.initializer : void 0
+      ) || false;
     }
     return _compilerOptionsObjectLiteralSyntax || void 0;
   }
-  function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, arg0, arg1, arg2, arg3) {
-    const props = getPropertyAssignment(objectLiteral, key1, key2);
-    for (const prop of props) {
+  function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, ...args) {
+    let needsCompilerDiagnostic = false;
+    forEachPropertyAssignment(objectLiteral, key1, (prop) => {
       if ("messageText" in message) {
         programDiagnostics.add(createDiagnosticForNodeFromMessageChain(options.configFile, onKey ? prop.name : prop.initializer, message));
       } else {
-        programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message, arg0, arg1, arg2, arg3));
+        programDiagnostics.add(createDiagnosticForNodeInSourceFile(options.configFile, onKey ? prop.name : prop.initializer, message, ...args));
       }
-    }
-    return !!props.length;
+      needsCompilerDiagnostic = true;
+    }, key2);
+    return needsCompilerDiagnostic;
   }
   function createRedundantOptionDiagnostic(errorOnOption, redundantWithOption) {
     const compilerOptionsObjectLiteralSyntax = getCompilerOptionsObjectLiteralSyntax();
@@ -116830,16 +116758,16 @@ function convertToDiagnostics(diagnostics, newProgram) {
     return emptyArray;
   let buildInfoDirectory;
   return diagnostics.map((diagnostic) => {
-    const result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3);
+    const result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPathInBuildInfoDirectory);
     result.reportsUnnecessary = diagnostic.reportsUnnecessary;
     result.reportsDeprecated = diagnostic.reportDeprecated;
     result.source = diagnostic.source;
     result.skippedOn = diagnostic.skippedOn;
     const { relatedInformation } = diagnostic;
-    result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, newProgram, toPath3)) : [] : void 0;
+    result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, newProgram, toPathInBuildInfoDirectory)) : [] : void 0;
     return result;
   });
-  function toPath3(path) {
+  function toPathInBuildInfoDirectory(path) {
     buildInfoDirectory != null ? buildInfoDirectory : buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory()));
     return toPath(path, buildInfoDirectory, newProgram.getCanonicalFileName);
   }
@@ -117742,7 +117670,7 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
   const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
   const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
   let state;
-  const filePaths = (_a2 = program.fileNames) == null ? void 0 : _a2.map(toPath3);
+  const filePaths = (_a2 = program.fileNames) == null ? void 0 : _a2.map(toPathInBuildInfoDirectory);
   let filePathsSetList;
   const latestChangedDtsFile = program.latestChangedDtsFile ? toAbsolutePath(program.latestChangedDtsFile) : void 0;
   if (isProgramBundleEmitBuildInfo(program)) {
@@ -117823,7 +117751,7 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
     close: noop,
     hasChangedEmitSignature: returnFalse
   };
-  function toPath3(path) {
+  function toPathInBuildInfoDirectory(path) {
     return toPath(path, buildInfoDirectory, getCanonicalFileName);
   }
   function toAbsolutePath(path) {
@@ -118862,15 +118790,13 @@ function getErrorSummaryText(errorCount, filesInError, newLine, host) {
   const nonNilFiles = filesInError.filter((fileInError) => fileInError !== void 0);
   const distinctFileNamesWithLines = nonNilFiles.map((fileInError) => `${fileInError.fileName}:${fileInError.line}`).filter((value, index, self) => self.indexOf(value) === index);
   const firstFileReference = nonNilFiles[0] && prettyPathForFileError(nonNilFiles[0], host.getCurrentDirectory());
-  const d = errorCount === 1 ? createCompilerDiagnostic(
-    filesInError[0] !== void 0 ? Diagnostics.Found_1_error_in_1 : Diagnostics.Found_1_error,
-    errorCount,
-    firstFileReference
-  ) : createCompilerDiagnostic(
-    distinctFileNamesWithLines.length === 0 ? Diagnostics.Found_0_errors : distinctFileNamesWithLines.length === 1 ? Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1 : Diagnostics.Found_0_errors_in_1_files,
-    errorCount,
-    distinctFileNamesWithLines.length === 1 ? firstFileReference : distinctFileNamesWithLines.length
-  );
+  let messageAndArgs;
+  if (errorCount === 1) {
+    messageAndArgs = filesInError[0] !== void 0 ? [Diagnostics.Found_1_error_in_0, firstFileReference] : [Diagnostics.Found_1_error];
+  } else {
+    messageAndArgs = distinctFileNamesWithLines.length === 0 ? [Diagnostics.Found_0_errors, errorCount] : distinctFileNamesWithLines.length === 1 ? [Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1, errorCount, firstFileReference] : [Diagnostics.Found_0_errors_in_1_files, errorCount, distinctFileNamesWithLines.length];
+  }
+  const d = createCompilerDiagnostic(...messageAndArgs);
   const suffix = distinctFileNamesWithLines.length > 1 ? createTabularErrorsDisplay(nonNilFiles, host) : "";
   return `${newLine}${flattenDiagnosticMessageText(d.messageText, newLine)}${newLine}${newLine}${suffix}`;
 }
@@ -119080,15 +119006,15 @@ function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) {
         toFileName(referencedResolvedRef.sourceFile.fileName, fileNameConvertor),
         options.outFile ? "--outFile" : "--out"
       );
-    case 8 /* AutomaticTypeDirectiveFile */:
+    case 8 /* AutomaticTypeDirectiveFile */: {
+      const messageAndArgs = options.types ? reason.packageId ? [Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1, reason.typeReference, packageIdToString(reason.packageId)] : [Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions, reason.typeReference] : reason.packageId ? [Diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1, reason.typeReference, packageIdToString(reason.packageId)] : [Diagnostics.Entry_point_for_implicit_type_library_0, reason.typeReference];
       return chainDiagnosticMessages(
         /*details*/
         void 0,
-        options.types ? reason.packageId ? Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1 : Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions : reason.packageId ? Diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1 : Diagnostics.Entry_point_for_implicit_type_library_0,
-        reason.typeReference,
-        reason.packageId && packageIdToString(reason.packageId)
+        ...messageAndArgs
       );
-    case 6 /* LibFile */:
+    }
+    case 6 /* LibFile */: {
       if (reason.index !== void 0)
         return chainDiagnosticMessages(
           /*details*/
@@ -119097,12 +119023,13 @@ function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) {
           options.lib[reason.index]
         );
       const target = forEachEntry(targetOptionDeclaration.type, (value, key) => value === getEmitScriptTarget(options) ? key : void 0);
+      const messageAndArgs = target ? [Diagnostics.Default_library_for_target_0, target] : [Diagnostics.Default_library];
       return chainDiagnosticMessages(
         /*details*/
         void 0,
-        target ? Diagnostics.Default_library_for_target_0 : Diagnostics.Default_library,
-        target
+        ...messageAndArgs
       );
+    }
     default:
       Debug.assertNever(reason);
   }