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

package/lib/tsserver.js

@@ -338,8 +338,8 @@ __export(server_exports, {
   convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
   convertJsonOption: () => convertJsonOption,
   convertToBase64: () => convertToBase64,
+  convertToJson: () => convertToJson,
   convertToObject: () => convertToObject,
-  convertToObjectWorker: () => convertToObjectWorker,
   convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
   convertToRelativePath: () => convertToRelativePath,
   convertToTSConfig: () => convertToTSConfig,
@@ -604,10 +604,12 @@ __export(server_exports, {
   forEachKey: () => forEachKey,
   forEachLeadingCommentRange: () => forEachLeadingCommentRange,
   forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
+  forEachPropertyAssignment: () => forEachPropertyAssignment,
   forEachResolvedProjectReference: () => forEachResolvedProjectReference,
   forEachReturnStatement: () => forEachReturnStatement,
   forEachRight: () => forEachRight,
   forEachTrailingCommentRange: () => forEachTrailingCommentRange,
+  forEachTsConfigPropArray: () => forEachTsConfigPropArray,
   forEachUnique: () => forEachUnique,
   forEachYieldExpression: () => forEachYieldExpression,
   forSomeAncestorDirectory: () => forSomeAncestorDirectory,
@@ -940,7 +942,6 @@ __export(server_exports, {
   getProperties: () => getProperties,
   getProperty: () => getProperty,
   getPropertyArrayElementValue: () => getPropertyArrayElementValue,
-  getPropertyAssignment: () => getPropertyAssignment,
   getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
@@ -1045,7 +1046,6 @@ __export(server_exports, {
   getTransformers: () => getTransformers,
   getTsBuildInfoEmitOutputFilePath: () => getTsBuildInfoEmitOutputFilePath,
   getTsConfigObjectLiteralExpression: () => getTsConfigObjectLiteralExpression,
-  getTsConfigPropArray: () => getTsConfigPropArray,
   getTsConfigPropArrayElementValue: () => getTsConfigPropArrayElementValue,
   getTypeAnnotationNode: () => getTypeAnnotationNode,
   getTypeArgumentOrTypeParameterList: () => getTypeArgumentOrTypeParameterList,
@@ -1485,6 +1485,7 @@ __export(server_exports, {
   isJsxText: () => isJsxText,
   isJumpStatementTarget: () => isJumpStatementTarget,
   isKeyword: () => isKeyword,
+  isKeywordOrPunctuation: () => isKeywordOrPunctuation,
   isKnownSymbol: () => isKnownSymbol,
   isLabelName: () => isLabelName,
   isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
@@ -2285,7 +2286,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230320`;
+var version = `${versionMajorMinor}.0-dev.20230322`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -10120,6 +10121,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}'."),
@@ -10565,13 +10567,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."),
@@ -16031,17 +16034,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 start2 = skipTrivia(sourceFile.text, nodes.pos);
-  return createFileDiagnostic(sourceFile, start2, nodes.end - start2, message, arg0, arg1, arg2, arg3);
+  return createFileDiagnostic(sourceFile, start2, nodes.end - start2, 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);
@@ -16498,17 +16501,20 @@ function isIdentifierTypePredicate(predicate) {
 function isThisTypePredicate(predicate) {
   return predicate && predicate.kind === 0 /* This */;
 }
-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) {
@@ -16517,11 +16523,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);
@@ -17867,6 +17872,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 */;
 }
@@ -30421,14 +30432,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
       );
@@ -30860,24 +30869,24 @@ var Parser;
   function inAwaitContext() {
     return inContext(32768 /* AwaitContext */);
   }
-  function parseErrorAtCurrentToken(message, arg0) {
-    return parseErrorAt(scanner2.getTokenStart(), scanner2.getTokenEnd(), message, arg0);
+  function parseErrorAtCurrentToken(message, ...args) {
+    return parseErrorAt(scanner2.getTokenStart(), scanner2.getTokenEnd(), message, ...args);
   }
-  function parseErrorAtPosition(start2, length2, message, arg0) {
+  function parseErrorAtPosition(start2, length2, message, ...args) {
     const lastError = lastOrUndefined(parseDiagnostics);
     let result;
     if (!lastError || start2 !== lastError.start) {
-      result = createDetachedDiagnostic(fileName, start2, length2, message, arg0);
+      result = createDetachedDiagnostic(fileName, start2, length2, message, ...args);
       parseDiagnostics.push(result);
     }
     parseErrorBeforeNextFinishedNode = true;
     return result;
   }
-  function parseErrorAt(start2, end, message, arg0) {
-    return parseErrorAtPosition(start2, end - start2, message, arg0);
+  function parseErrorAt(start2, end, message, ...args) {
+    return parseErrorAtPosition(start2, end - start2, 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(scanner2.getTokenEnd(), length2, message);
@@ -31083,6 +31092,7 @@ var Parser;
       nextTokenJSDoc();
       return true;
     }
+    Debug.assert(isKeywordOrPunctuation(kind));
     parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
     return false;
   }
@@ -31131,7 +31141,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,
@@ -31185,11 +31199,11 @@ var Parser;
     }
     return node;
   }
-  function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
+  function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, ...args) {
     if (reportAtCurrentPosition) {
-      parseErrorAtPosition(scanner2.getTokenFullStart(), 0, diagnosticMessage, arg0);
+      parseErrorAtPosition(scanner2.getTokenFullStart(), 0, diagnosticMessage, ...args);
     } else if (diagnosticMessage) {
-      parseErrorAtCurrentToken(diagnosticMessage, arg0);
+      parseErrorAtCurrentToken(diagnosticMessage, ...args);
     }
     const pos = getNodePos();
     const result = kind === 79 /* Identifier */ ? factoryCreateIdentifier(
@@ -33548,6 +33562,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));
       }
     }
@@ -36495,14 +36510,14 @@ var Parser;
       }
       function parseReturnTag(start3, tagName, indent3, indentText) {
         if (some(tags, isJSDocReturnTag)) {
-          parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, tagName.escapedText);
+          parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
         }
         const typeExpression = tryParseTypeExpression();
         return finishNode(factory2.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start3, getNodePos(), indent3, indentText)), start3);
       }
       function parseTypeTag(start3, tagName, indent3, indentText) {
         if (some(tags, isJSDocTypeTag)) {
-          parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, tagName.escapedText);
+          parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
         }
         const typeExpression = parseJSDocTypeExpression(
           /*mayOmitBraces*/
@@ -38987,13 +39002,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 = {};
@@ -39034,7 +39049,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 {
@@ -39245,9 +39260,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
@@ -39304,7 +39317,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() {
@@ -39314,24 +39346,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",
@@ -39377,10 +39394,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,
@@ -39391,52 +39407,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 */) {
@@ -39451,38 +39461,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;
@@ -39495,112 +39480,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);
@@ -39612,7 +39525,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);
     }
@@ -39972,8 +39885,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");
@@ -40075,9 +39988,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));
     }
   }
 }
@@ -40176,27 +40089,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);
@@ -40204,69 +40132,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);
@@ -40275,15 +40145,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;
       }
     }
@@ -40294,9 +40206,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;
 }
@@ -40398,42 +40310,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) {
@@ -40444,29 +40347,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 = /^[^*?]*(?=\/[^/]*[*?])/;
@@ -40575,7 +40478,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) {
@@ -40686,6 +40589,8 @@ function convertCompilerOptionsForTelemetry(opts) {
   return out;
 }
 function getOptionValueWithEmptyStrings(value, option) {
+  if (value === void 0)
+    return value;
   switch (option.type) {
     case "object":
       return "";
@@ -40700,7 +40605,7 @@ function getOptionValueWithEmptyStrings(value, option) {
         return getOptionValueWithEmptyStrings(value, option.element);
     case "list":
       const elementType = option.element;
-      return isArray(value) ? value.map((v) => getOptionValueWithEmptyStrings(v, elementType)) : "";
+      return isArray(value) ? mapDefined(value, (v) => getOptionValueWithEmptyStrings(v, elementType)) : "";
     default:
       return forEachEntry(option.type, (optionEnumValue, optionStringValue) => {
         if (optionEnumValue === value) {
@@ -43453,8 +43358,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;
@@ -43648,7 +43553,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
             );
@@ -43656,7 +43561,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);
         }
@@ -45117,9 +45022,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);
@@ -47277,6 +47182,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),
@@ -48104,8 +48010,8 @@ function createTypeChecker(host) {
     getDiagnostics2(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;
@@ -48114,16 +48020,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;
   }
@@ -48134,19 +48040,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);
@@ -50020,7 +49926,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function markExportAsReferenced(node) {
-    if (compilerOptions.verbatimModuleSyntax) {
+    if (!canCollectSymbolAliasAccessabilityData) {
       return;
     }
     const symbol = getSymbolOfDeclaration(node);
@@ -50033,7 +49939,7 @@ function createTypeChecker(host) {
     }
   }
   function markAliasSymbolAsReferenced(symbol) {
-    Debug.assert(!compilerOptions.verbatimModuleSyntax);
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
     const links = getSymbolLinks(symbol);
     if (!links.referenced) {
       links.referenced = true;
@@ -50164,6 +50070,9 @@ function createTypeChecker(host) {
         }
       }
       symbol = getMergedSymbol(getSymbol2(getExportsOfSymbol(namespace), right.escapedText, meaning));
+      if (!symbol && namespace.flags & 2097152 /* Alias */) {
+        symbol = getMergedSymbol(getSymbol2(getExportsOfSymbol(resolveAlias(namespace)), right.escapedText, meaning));
+      }
       if (!symbol) {
         if (!ignoreErrors) {
           const namespaceName = getFullyQualifiedName(namespace);
@@ -50200,7 +50109,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 */)) {
@@ -51913,8 +51822,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 */));
@@ -58082,7 +57994,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);
@@ -58318,7 +58230,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));
       }
     }
@@ -60470,6 +60382,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) {
@@ -61037,7 +60955,7 @@ function createTypeChecker(host) {
           links.resolvedType = getTypeFromTypeNode(node.type);
           break;
         default:
-          throw Debug.assertNever(node.operator);
+          Debug.assertNever(node.operator);
       }
     }
     return links.resolvedType;
@@ -61121,7 +61039,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}`>
@@ -62004,7 +61922,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;
@@ -62795,7 +62716,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);
@@ -63421,6 +63348,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) {
@@ -63464,7 +63394,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));
@@ -63730,7 +63665,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;
@@ -63749,6 +63684,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;
@@ -63838,10 +63778,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 || [];
@@ -63933,13 +63873,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);
@@ -65119,6 +65059,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) {
@@ -65226,7 +65186,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 {
@@ -66109,22 +66069,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 */) {
@@ -67568,21 +67513,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);
@@ -67724,7 +67667,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;
@@ -68197,36 +68144,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;
@@ -70144,7 +70089,7 @@ function createTypeChecker(host) {
     });
   }
   function markAliasReferenced(symbol, location) {
-    if (compilerOptions.verbatimModuleSyntax) {
+    if (!canCollectSymbolAliasAccessabilityData) {
       return;
     }
     if (isNonLocalAlias(
@@ -71436,7 +71381,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
       );
@@ -72701,7 +72650,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);
         }
       }
@@ -74275,16 +74224,16 @@ function createTypeChecker(host) {
     }
     return { start: start2, length: length2, sourceFile };
   }
-  function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
+  function getDiagnosticForCallNode(node, message, ...args) {
     if (isCallExpression(node)) {
       const { sourceFile, start: start2, length: length2 } = getDiagnosticSpanForCallNode(node);
       if ("message" in message) {
-        return createFileDiagnostic(sourceFile, start2, length2, message, arg0, arg1, arg2, arg3);
+        return createFileDiagnostic(sourceFile, start2, 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);
     }
@@ -74372,11 +74321,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;
@@ -75307,7 +75253,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);
@@ -75981,12 +75927,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 = [];
@@ -76004,13 +75950,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;
@@ -79716,9 +79656,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)) {
@@ -79781,8 +79721,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) {
@@ -79838,11 +79778,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;
     }
@@ -79860,7 +79800,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();
@@ -79884,7 +79824,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;
@@ -79898,7 +79838,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;
@@ -80076,7 +80016,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);
@@ -80485,9 +80425,8 @@ function createTypeChecker(host) {
           const sourceFile = getSourceFileOfNode(parent2);
           const range = isJSDocTemplateTag(parent2) ? rangeOfNode(parent2) : rangeOfTypeParameters(sourceFile, parent2.typeParameters);
           const only = parent2.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));
@@ -82045,7 +81984,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));
               }
             });
           }
@@ -83641,6 +83580,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(
@@ -83726,14 +83668,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,
@@ -85070,7 +85012,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));
@@ -85111,7 +85053,7 @@ function createTypeChecker(host) {
     return isConstEnumSymbol(s) || !!s.constEnumOnlyModule;
   }
   function isReferencedAliasDeclaration(node, checkChildren) {
-    Debug.assert(!compilerOptions.verbatimModuleSyntax);
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
     if (isAliasSymbolDeclaration2(node)) {
       const symbol = getSymbolOfDeclaration(node);
       const links = symbol && getSymbolLinks(symbol);
@@ -85449,12 +85391,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);
@@ -86586,10 +86528,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;
         }
@@ -87058,12 +87000,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;
     }
@@ -87071,35 +87013,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, start2, length2, message, arg0, arg1, arg2) {
+  function grammarErrorAtPos(nodeForSourceFile, start2, length2, message, ...args) {
     const sourceFile = getSourceFileOfNode(nodeForSourceFile);
     if (!hasParseDiagnostics(sourceFile)) {
-      diagnostics.add(createFileDiagnostic(sourceFile, start2, length2, message, arg0, arg1, arg2));
+      diagnostics.add(createFileDiagnostic(sourceFile, start2, 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;
@@ -87244,7 +87186,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);
@@ -87254,9 +87196,7 @@ function createTypeChecker(host) {
         /*length*/
         0,
         message,
-        arg0,
-        arg1,
-        arg2
+        ...args
       ));
       return true;
     }
@@ -87402,6 +87342,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);
@@ -99466,10 +99410,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;
@@ -99635,7 +99582,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) {
@@ -99643,30 +99593,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);
@@ -111754,8 +111722,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);
@@ -111843,10 +111810,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;
 }
@@ -115860,12 +115827,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) {
@@ -115984,7 +115951,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   function makeFileLevelOptimisticUniqueName(name) {
     return makeUniqueName2(
       name,
-      isFileLevelUniqueName2,
+      isFileLevelUniqueNameInCurrentFile,
       /*optimistic*/
       true,
       /*scoped*/
@@ -116164,7 +116131,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       case 3 /* Unique */:
         return makeUniqueName2(
           idText(name),
-          autoGenerate.flags & 32 /* FileLevel */ ? isFileLevelUniqueName2 : isUniqueName,
+          autoGenerate.flags & 32 /* FileLevel */ ? isFileLevelUniqueNameInCurrentFile : isUniqueName,
           !!(autoGenerate.flags & 16 /* Optimistic */),
           !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */),
           isPrivateIdentifier(name),
@@ -119239,12 +119206,12 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           }
         }
       }
-      function createDiagnosticForNodeArray2(nodes, message, arg0, arg1, arg2) {
+      function createDiagnosticForNodeArray2(nodes, message, ...args) {
         const start2 = nodes.pos;
-        return createFileDiagnostic(sourceFile, start2, nodes.end - start2, message, arg0, arg1, arg2);
+        return createFileDiagnostic(sourceFile, start2, nodes.end - start2, 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);
       }
     });
   }
@@ -119909,11 +119876,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
         });
       }
     });
@@ -120378,7 +120346,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*/
@@ -120386,7 +120354,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,
@@ -120403,10 +120371,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           /*option2*/
           void 0,
           message,
-          arg0,
-          arg1,
-          arg2,
-          arg3
+          ...args
         );
       }
     }
@@ -120459,8 +120424,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) {
@@ -120572,8 +120537,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(
@@ -120642,28 +120608,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,
@@ -120671,25 +120635,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();
@@ -120707,7 +120669,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       option3
     );
   }
-  function createOptionValueDiagnostic(option1, message, arg0, arg1) {
+  function createOptionValueDiagnostic(option1, message, ...args) {
     createDiagnosticForOption(
       /*onKey*/
       false,
@@ -120715,57 +120677,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();
@@ -121683,16 +121641,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);
   }
@@ -122600,7 +122558,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)) {
@@ -122681,7 +122639,7 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
     close: noop,
     hasChangedEmitSignature: returnFalse
   };
-  function toPath3(path) {
+  function toPathInBuildInfoDirectory(path) {
     return toPath(path, buildInfoDirectory, getCanonicalFileName);
   }
   function toAbsolutePath(path) {
@@ -123727,15 +123685,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}`;
 }
@@ -123945,15 +123901,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*/
@@ -123962,12 +123918,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);
   }
@@ -127320,7 +127277,7 @@ function renderPackageNameValidationFailureWorker(typing, result, name, isScopeN
     case 0 /* Ok */:
       return Debug.fail();
     default:
-      throw Debug.assertNever(result);
+      Debug.assertNever(result);
   }
 }
 
@@ -128952,9 +128909,6 @@ function isStringAndEmptyAnonymousObjectIntersection(type) {
   const { types, checker } = type;
   return types.length === 2 && (areIntersectedTypesAvoidingStringReduction(checker, types[0], types[1]) || areIntersectedTypesAvoidingStringReduction(checker, types[1], types[0]));
 }
-function isPunctuation(kind) {
-  return 18 /* FirstPunctuation */ <= kind && kind <= 78 /* LastPunctuation */;
-}
 function isInsideTemplateLiteral(node, position, sourceFile) {
   return isTemplateLiteralKind(node.kind) && (node.getStart(sourceFile) < position && position < node.end) || !!node.isUnterminated && position === node.end;
 }
@@ -129060,6 +129014,7 @@ var typeKeywords = [
   147 /* ReadonlyKeyword */,
   153 /* StringKeyword */,
   154 /* SymbolKeyword */,
+  113 /* TypeOfKeyword */,
   111 /* TrueKeyword */,
   115 /* VoidKeyword */,
   156 /* UndefinedKeyword */,
@@ -134553,6 +134508,234 @@ function cleanText(text) {
   return text.replace(/\\?(\r?\n|\r|\u2028|\u2029)/g, "");
 }
 
+// src/services/classifier2020.ts
+var TokenEncodingConsts = /* @__PURE__ */ ((TokenEncodingConsts2) => {
+  TokenEncodingConsts2[TokenEncodingConsts2["typeOffset"] = 8] = "typeOffset";
+  TokenEncodingConsts2[TokenEncodingConsts2["modifierMask"] = 255] = "modifierMask";
+  return TokenEncodingConsts2;
+})(TokenEncodingConsts || {});
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2[TokenType2["class"] = 0] = "class";
+  TokenType2[TokenType2["enum"] = 1] = "enum";
+  TokenType2[TokenType2["interface"] = 2] = "interface";
+  TokenType2[TokenType2["namespace"] = 3] = "namespace";
+  TokenType2[TokenType2["typeParameter"] = 4] = "typeParameter";
+  TokenType2[TokenType2["type"] = 5] = "type";
+  TokenType2[TokenType2["parameter"] = 6] = "parameter";
+  TokenType2[TokenType2["variable"] = 7] = "variable";
+  TokenType2[TokenType2["enumMember"] = 8] = "enumMember";
+  TokenType2[TokenType2["property"] = 9] = "property";
+  TokenType2[TokenType2["function"] = 10] = "function";
+  TokenType2[TokenType2["member"] = 11] = "member";
+  return TokenType2;
+})(TokenType || {});
+var TokenModifier = /* @__PURE__ */ ((TokenModifier2) => {
+  TokenModifier2[TokenModifier2["declaration"] = 0] = "declaration";
+  TokenModifier2[TokenModifier2["static"] = 1] = "static";
+  TokenModifier2[TokenModifier2["async"] = 2] = "async";
+  TokenModifier2[TokenModifier2["readonly"] = 3] = "readonly";
+  TokenModifier2[TokenModifier2["defaultLibrary"] = 4] = "defaultLibrary";
+  TokenModifier2[TokenModifier2["local"] = 5] = "local";
+  return TokenModifier2;
+})(TokenModifier || {});
+function getSemanticClassifications2(program, cancellationToken, sourceFile, span) {
+  const classifications = getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span);
+  Debug.assert(classifications.spans.length % 3 === 0);
+  const dense = classifications.spans;
+  const result = [];
+  for (let i = 0; i < dense.length; i += 3) {
+    result.push({
+      textSpan: createTextSpan(dense[i], dense[i + 1]),
+      classificationType: dense[i + 2]
+    });
+  }
+  return result;
+}
+function getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span) {
+  return {
+    spans: getSemanticTokens(program, sourceFile, span, cancellationToken),
+    endOfLineState: 0 /* None */
+  };
+}
+function getSemanticTokens(program, sourceFile, span, cancellationToken) {
+  const resultTokens = [];
+  const collector = (node, typeIdx, modifierSet) => {
+    resultTokens.push(node.getStart(sourceFile), node.getWidth(sourceFile), (typeIdx + 1 << 8 /* typeOffset */) + modifierSet);
+  };
+  if (program && sourceFile) {
+    collectTokens(program, sourceFile, span, collector, cancellationToken);
+  }
+  return resultTokens;
+}
+function collectTokens(program, sourceFile, span, collector, cancellationToken) {
+  const typeChecker = program.getTypeChecker();
+  let inJSXElement = false;
+  function visit(node) {
+    switch (node.kind) {
+      case 265 /* ModuleDeclaration */:
+      case 261 /* ClassDeclaration */:
+      case 262 /* InterfaceDeclaration */:
+      case 260 /* FunctionDeclaration */:
+      case 229 /* ClassExpression */:
+      case 216 /* FunctionExpression */:
+      case 217 /* ArrowFunction */:
+        cancellationToken.throwIfCancellationRequested();
+    }
+    if (!node || !textSpanIntersectsWith(span, node.pos, node.getFullWidth()) || node.getFullWidth() === 0) {
+      return;
+    }
+    const prevInJSXElement = inJSXElement;
+    if (isJsxElement(node) || isJsxSelfClosingElement(node)) {
+      inJSXElement = true;
+    }
+    if (isJsxExpression(node)) {
+      inJSXElement = false;
+    }
+    if (isIdentifier(node) && !inJSXElement && !inImportClause(node) && !isInfinityOrNaNString(node.escapedText)) {
+      let symbol = typeChecker.getSymbolAtLocation(node);
+      if (symbol) {
+        if (symbol.flags & 2097152 /* Alias */) {
+          symbol = typeChecker.getAliasedSymbol(symbol);
+        }
+        let typeIdx = classifySymbol2(symbol, getMeaningFromLocation(node));
+        if (typeIdx !== void 0) {
+          let modifierSet = 0;
+          if (node.parent) {
+            const parentIsDeclaration = isBindingElement(node.parent) || tokenFromDeclarationMapping.get(node.parent.kind) === typeIdx;
+            if (parentIsDeclaration && node.parent.name === node) {
+              modifierSet = 1 << 0 /* declaration */;
+            }
+          }
+          if (typeIdx === 6 /* parameter */ && isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
+            typeIdx = 9 /* property */;
+          }
+          typeIdx = reclassifyByType(typeChecker, node, typeIdx);
+          const decl = symbol.valueDeclaration;
+          if (decl) {
+            const modifiers = getCombinedModifierFlags(decl);
+            const nodeFlags = getCombinedNodeFlags(decl);
+            if (modifiers & 32 /* Static */) {
+              modifierSet |= 1 << 1 /* static */;
+            }
+            if (modifiers & 512 /* Async */) {
+              modifierSet |= 1 << 2 /* async */;
+            }
+            if (typeIdx !== 0 /* class */ && typeIdx !== 2 /* interface */) {
+              if (modifiers & 64 /* Readonly */ || nodeFlags & 2 /* Const */ || symbol.getFlags() & 8 /* EnumMember */) {
+                modifierSet |= 1 << 3 /* readonly */;
+              }
+            }
+            if ((typeIdx === 7 /* variable */ || typeIdx === 10 /* function */) && isLocalDeclaration(decl, sourceFile)) {
+              modifierSet |= 1 << 5 /* local */;
+            }
+            if (program.isSourceFileDefaultLibrary(decl.getSourceFile())) {
+              modifierSet |= 1 << 4 /* defaultLibrary */;
+            }
+          } else if (symbol.declarations && symbol.declarations.some((d) => program.isSourceFileDefaultLibrary(d.getSourceFile()))) {
+            modifierSet |= 1 << 4 /* defaultLibrary */;
+          }
+          collector(node, typeIdx, modifierSet);
+        }
+      }
+    }
+    forEachChild(node, visit);
+    inJSXElement = prevInJSXElement;
+  }
+  visit(sourceFile);
+}
+function classifySymbol2(symbol, meaning) {
+  const flags = symbol.getFlags();
+  if (flags & 32 /* Class */) {
+    return 0 /* class */;
+  } else if (flags & 384 /* Enum */) {
+    return 1 /* enum */;
+  } else if (flags & 524288 /* TypeAlias */) {
+    return 5 /* type */;
+  } else if (flags & 64 /* Interface */) {
+    if (meaning & 2 /* Type */) {
+      return 2 /* interface */;
+    }
+  } else if (flags & 262144 /* TypeParameter */) {
+    return 4 /* typeParameter */;
+  }
+  let decl = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];
+  if (decl && isBindingElement(decl)) {
+    decl = getDeclarationForBindingElement(decl);
+  }
+  return decl && tokenFromDeclarationMapping.get(decl.kind);
+}
+function reclassifyByType(typeChecker, node, typeIdx) {
+  if (typeIdx === 7 /* variable */ || typeIdx === 9 /* property */ || typeIdx === 6 /* parameter */) {
+    const type = typeChecker.getTypeAtLocation(node);
+    if (type) {
+      const test = (condition) => {
+        return condition(type) || type.isUnion() && type.types.some(condition);
+      };
+      if (typeIdx !== 6 /* parameter */ && test((t) => t.getConstructSignatures().length > 0)) {
+        return 0 /* class */;
+      }
+      if (test((t) => t.getCallSignatures().length > 0) && !test((t) => t.getProperties().length > 0) || isExpressionInCallExpression(node)) {
+        return typeIdx === 9 /* property */ ? 11 /* member */ : 10 /* function */;
+      }
+    }
+  }
+  return typeIdx;
+}
+function isLocalDeclaration(decl, sourceFile) {
+  if (isBindingElement(decl)) {
+    decl = getDeclarationForBindingElement(decl);
+  }
+  if (isVariableDeclaration(decl)) {
+    return (!isSourceFile(decl.parent.parent.parent) || isCatchClause(decl.parent)) && decl.getSourceFile() === sourceFile;
+  } else if (isFunctionDeclaration(decl)) {
+    return !isSourceFile(decl.parent) && decl.getSourceFile() === sourceFile;
+  }
+  return false;
+}
+function getDeclarationForBindingElement(element) {
+  while (true) {
+    if (isBindingElement(element.parent.parent)) {
+      element = element.parent.parent;
+    } else {
+      return element.parent.parent;
+    }
+  }
+}
+function inImportClause(node) {
+  const parent2 = node.parent;
+  return parent2 && (isImportClause(parent2) || isImportSpecifier(parent2) || isNamespaceImport(parent2));
+}
+function isExpressionInCallExpression(node) {
+  while (isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
+    node = node.parent;
+  }
+  return isCallExpression(node.parent) && node.parent.expression === node;
+}
+function isRightSideOfQualifiedNameOrPropertyAccess2(node) {
+  return isQualifiedName(node.parent) && node.parent.right === node || isPropertyAccessExpression(node.parent) && node.parent.name === node;
+}
+var tokenFromDeclarationMapping = /* @__PURE__ */ new Map([
+  [258 /* VariableDeclaration */, 7 /* variable */],
+  [167 /* Parameter */, 6 /* parameter */],
+  [170 /* PropertyDeclaration */, 9 /* property */],
+  [265 /* ModuleDeclaration */, 3 /* namespace */],
+  [264 /* EnumDeclaration */, 1 /* enum */],
+  [303 /* EnumMember */, 8 /* enumMember */],
+  [261 /* ClassDeclaration */, 0 /* class */],
+  [172 /* MethodDeclaration */, 11 /* member */],
+  [260 /* FunctionDeclaration */, 10 /* function */],
+  [216 /* FunctionExpression */, 10 /* function */],
+  [171 /* MethodSignature */, 11 /* member */],
+  [175 /* GetAccessor */, 9 /* property */],
+  [176 /* SetAccessor */, 9 /* property */],
+  [169 /* PropertySignature */, 9 /* property */],
+  [262 /* InterfaceDeclaration */, 2 /* interface */],
+  [263 /* TypeAliasDeclaration */, 5 /* type */],
+  [166 /* TypeParameter */, 4 /* typeParameter */],
+  [300 /* PropertyAssignment */, 9 /* property */],
+  [301 /* ShorthandPropertyAssignment */, 9 /* property */]
+]);
+
 // src/services/services.ts
 var servicesVersion = "0.8";
 function createNode(kind, pos, end, parent2) {
@@ -135985,7 +136168,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     synchronizeHostData();
     const responseFormat = format || "original" /* Original */;
     if (responseFormat === "2020" /* TwentyTwenty */) {
-      return ts_classifier_exports.v2020.getSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span);
+      return getSemanticClassifications2(program, cancellationToken, getValidSourceFile(fileName), span);
     } else {
       return getSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span);
     }
@@ -135996,7 +136179,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     if (responseFormat === "original" /* Original */) {
       return getEncodedSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span);
     } else {
-      return ts_classifier_exports.v2020.getEncodedSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span);
+      return getEncodedSemanticClassifications2(program, cancellationToken, getValidSourceFile(fileName), span);
     }
   }
   function getSyntacticClassifications2(fileName, span) {
@@ -138563,234 +138746,6 @@ __export(ts_classifier_v2020_exports, {
   getSemanticClassifications: () => getSemanticClassifications2
 });
 
-// src/services/classifier2020.ts
-var TokenEncodingConsts = /* @__PURE__ */ ((TokenEncodingConsts2) => {
-  TokenEncodingConsts2[TokenEncodingConsts2["typeOffset"] = 8] = "typeOffset";
-  TokenEncodingConsts2[TokenEncodingConsts2["modifierMask"] = 255] = "modifierMask";
-  return TokenEncodingConsts2;
-})(TokenEncodingConsts || {});
-var TokenType = /* @__PURE__ */ ((TokenType2) => {
-  TokenType2[TokenType2["class"] = 0] = "class";
-  TokenType2[TokenType2["enum"] = 1] = "enum";
-  TokenType2[TokenType2["interface"] = 2] = "interface";
-  TokenType2[TokenType2["namespace"] = 3] = "namespace";
-  TokenType2[TokenType2["typeParameter"] = 4] = "typeParameter";
-  TokenType2[TokenType2["type"] = 5] = "type";
-  TokenType2[TokenType2["parameter"] = 6] = "parameter";
-  TokenType2[TokenType2["variable"] = 7] = "variable";
-  TokenType2[TokenType2["enumMember"] = 8] = "enumMember";
-  TokenType2[TokenType2["property"] = 9] = "property";
-  TokenType2[TokenType2["function"] = 10] = "function";
-  TokenType2[TokenType2["member"] = 11] = "member";
-  return TokenType2;
-})(TokenType || {});
-var TokenModifier = /* @__PURE__ */ ((TokenModifier2) => {
-  TokenModifier2[TokenModifier2["declaration"] = 0] = "declaration";
-  TokenModifier2[TokenModifier2["static"] = 1] = "static";
-  TokenModifier2[TokenModifier2["async"] = 2] = "async";
-  TokenModifier2[TokenModifier2["readonly"] = 3] = "readonly";
-  TokenModifier2[TokenModifier2["defaultLibrary"] = 4] = "defaultLibrary";
-  TokenModifier2[TokenModifier2["local"] = 5] = "local";
-  return TokenModifier2;
-})(TokenModifier || {});
-function getSemanticClassifications2(program, cancellationToken, sourceFile, span) {
-  const classifications = getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span);
-  Debug.assert(classifications.spans.length % 3 === 0);
-  const dense = classifications.spans;
-  const result = [];
-  for (let i = 0; i < dense.length; i += 3) {
-    result.push({
-      textSpan: createTextSpan(dense[i], dense[i + 1]),
-      classificationType: dense[i + 2]
-    });
-  }
-  return result;
-}
-function getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span) {
-  return {
-    spans: getSemanticTokens(program, sourceFile, span, cancellationToken),
-    endOfLineState: 0 /* None */
-  };
-}
-function getSemanticTokens(program, sourceFile, span, cancellationToken) {
-  const resultTokens = [];
-  const collector = (node, typeIdx, modifierSet) => {
-    resultTokens.push(node.getStart(sourceFile), node.getWidth(sourceFile), (typeIdx + 1 << 8 /* typeOffset */) + modifierSet);
-  };
-  if (program && sourceFile) {
-    collectTokens(program, sourceFile, span, collector, cancellationToken);
-  }
-  return resultTokens;
-}
-function collectTokens(program, sourceFile, span, collector, cancellationToken) {
-  const typeChecker = program.getTypeChecker();
-  let inJSXElement = false;
-  function visit(node) {
-    switch (node.kind) {
-      case 265 /* ModuleDeclaration */:
-      case 261 /* ClassDeclaration */:
-      case 262 /* InterfaceDeclaration */:
-      case 260 /* FunctionDeclaration */:
-      case 229 /* ClassExpression */:
-      case 216 /* FunctionExpression */:
-      case 217 /* ArrowFunction */:
-        cancellationToken.throwIfCancellationRequested();
-    }
-    if (!node || !textSpanIntersectsWith(span, node.pos, node.getFullWidth()) || node.getFullWidth() === 0) {
-      return;
-    }
-    const prevInJSXElement = inJSXElement;
-    if (isJsxElement(node) || isJsxSelfClosingElement(node)) {
-      inJSXElement = true;
-    }
-    if (isJsxExpression(node)) {
-      inJSXElement = false;
-    }
-    if (isIdentifier(node) && !inJSXElement && !inImportClause(node) && !isInfinityOrNaNString(node.escapedText)) {
-      let symbol = typeChecker.getSymbolAtLocation(node);
-      if (symbol) {
-        if (symbol.flags & 2097152 /* Alias */) {
-          symbol = typeChecker.getAliasedSymbol(symbol);
-        }
-        let typeIdx = classifySymbol2(symbol, getMeaningFromLocation(node));
-        if (typeIdx !== void 0) {
-          let modifierSet = 0;
-          if (node.parent) {
-            const parentIsDeclaration = isBindingElement(node.parent) || tokenFromDeclarationMapping.get(node.parent.kind) === typeIdx;
-            if (parentIsDeclaration && node.parent.name === node) {
-              modifierSet = 1 << 0 /* declaration */;
-            }
-          }
-          if (typeIdx === 6 /* parameter */ && isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
-            typeIdx = 9 /* property */;
-          }
-          typeIdx = reclassifyByType(typeChecker, node, typeIdx);
-          const decl = symbol.valueDeclaration;
-          if (decl) {
-            const modifiers = getCombinedModifierFlags(decl);
-            const nodeFlags = getCombinedNodeFlags(decl);
-            if (modifiers & 32 /* Static */) {
-              modifierSet |= 1 << 1 /* static */;
-            }
-            if (modifiers & 512 /* Async */) {
-              modifierSet |= 1 << 2 /* async */;
-            }
-            if (typeIdx !== 0 /* class */ && typeIdx !== 2 /* interface */) {
-              if (modifiers & 64 /* Readonly */ || nodeFlags & 2 /* Const */ || symbol.getFlags() & 8 /* EnumMember */) {
-                modifierSet |= 1 << 3 /* readonly */;
-              }
-            }
-            if ((typeIdx === 7 /* variable */ || typeIdx === 10 /* function */) && isLocalDeclaration(decl, sourceFile)) {
-              modifierSet |= 1 << 5 /* local */;
-            }
-            if (program.isSourceFileDefaultLibrary(decl.getSourceFile())) {
-              modifierSet |= 1 << 4 /* defaultLibrary */;
-            }
-          } else if (symbol.declarations && symbol.declarations.some((d) => program.isSourceFileDefaultLibrary(d.getSourceFile()))) {
-            modifierSet |= 1 << 4 /* defaultLibrary */;
-          }
-          collector(node, typeIdx, modifierSet);
-        }
-      }
-    }
-    forEachChild(node, visit);
-    inJSXElement = prevInJSXElement;
-  }
-  visit(sourceFile);
-}
-function classifySymbol2(symbol, meaning) {
-  const flags = symbol.getFlags();
-  if (flags & 32 /* Class */) {
-    return 0 /* class */;
-  } else if (flags & 384 /* Enum */) {
-    return 1 /* enum */;
-  } else if (flags & 524288 /* TypeAlias */) {
-    return 5 /* type */;
-  } else if (flags & 64 /* Interface */) {
-    if (meaning & 2 /* Type */) {
-      return 2 /* interface */;
-    }
-  } else if (flags & 262144 /* TypeParameter */) {
-    return 4 /* typeParameter */;
-  }
-  let decl = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];
-  if (decl && isBindingElement(decl)) {
-    decl = getDeclarationForBindingElement(decl);
-  }
-  return decl && tokenFromDeclarationMapping.get(decl.kind);
-}
-function reclassifyByType(typeChecker, node, typeIdx) {
-  if (typeIdx === 7 /* variable */ || typeIdx === 9 /* property */ || typeIdx === 6 /* parameter */) {
-    const type = typeChecker.getTypeAtLocation(node);
-    if (type) {
-      const test = (condition) => {
-        return condition(type) || type.isUnion() && type.types.some(condition);
-      };
-      if (typeIdx !== 6 /* parameter */ && test((t) => t.getConstructSignatures().length > 0)) {
-        return 0 /* class */;
-      }
-      if (test((t) => t.getCallSignatures().length > 0) && !test((t) => t.getProperties().length > 0) || isExpressionInCallExpression(node)) {
-        return typeIdx === 9 /* property */ ? 11 /* member */ : 10 /* function */;
-      }
-    }
-  }
-  return typeIdx;
-}
-function isLocalDeclaration(decl, sourceFile) {
-  if (isBindingElement(decl)) {
-    decl = getDeclarationForBindingElement(decl);
-  }
-  if (isVariableDeclaration(decl)) {
-    return (!isSourceFile(decl.parent.parent.parent) || isCatchClause(decl.parent)) && decl.getSourceFile() === sourceFile;
-  } else if (isFunctionDeclaration(decl)) {
-    return !isSourceFile(decl.parent) && decl.getSourceFile() === sourceFile;
-  }
-  return false;
-}
-function getDeclarationForBindingElement(element) {
-  while (true) {
-    if (isBindingElement(element.parent.parent)) {
-      element = element.parent.parent;
-    } else {
-      return element.parent.parent;
-    }
-  }
-}
-function inImportClause(node) {
-  const parent2 = node.parent;
-  return parent2 && (isImportClause(parent2) || isImportSpecifier(parent2) || isNamespaceImport(parent2));
-}
-function isExpressionInCallExpression(node) {
-  while (isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
-    node = node.parent;
-  }
-  return isCallExpression(node.parent) && node.parent.expression === node;
-}
-function isRightSideOfQualifiedNameOrPropertyAccess2(node) {
-  return isQualifiedName(node.parent) && node.parent.right === node || isPropertyAccessExpression(node.parent) && node.parent.name === node;
-}
-var tokenFromDeclarationMapping = /* @__PURE__ */ new Map([
-  [258 /* VariableDeclaration */, 7 /* variable */],
-  [167 /* Parameter */, 6 /* parameter */],
-  [170 /* PropertyDeclaration */, 9 /* property */],
-  [265 /* ModuleDeclaration */, 3 /* namespace */],
-  [264 /* EnumDeclaration */, 1 /* enum */],
-  [303 /* EnumMember */, 8 /* enumMember */],
-  [261 /* ClassDeclaration */, 0 /* class */],
-  [172 /* MethodDeclaration */, 11 /* member */],
-  [260 /* FunctionDeclaration */, 10 /* function */],
-  [216 /* FunctionExpression */, 10 /* function */],
-  [171 /* MethodSignature */, 11 /* member */],
-  [175 /* GetAccessor */, 9 /* property */],
-  [176 /* SetAccessor */, 9 /* property */],
-  [169 /* PropertySignature */, 9 /* property */],
-  [262 /* InterfaceDeclaration */, 2 /* interface */],
-  [263 /* TypeAliasDeclaration */, 5 /* type */],
-  [166 /* TypeParameter */, 4 /* typeParameter */],
-  [300 /* PropertyAssignment */, 9 /* property */],
-  [301 /* ShorthandPropertyAssignment */, 9 /* property */]
-]);
-
 // src/services/_namespaces/ts.codefix.ts
 var ts_codefix_exports = {};
 __export(ts_codefix_exports, {
@@ -148143,7 +148098,7 @@ function getInfo14(sourceFile, program, pos) {
     /*checkArgumentIsStringLiteralLike*/
     true
   )) {
-    throw Debug.failBadSyntaxKind(parent2);
+    Debug.failBadSyntaxKind(parent2);
   }
   const decl = cast(parent2.parent, isVariableDeclaration);
   const defaultImportName = tryCast(decl.name, isIdentifier);
@@ -151448,7 +151403,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         return true;
       }
     }
-    return isDeclarationName(contextToken2) && !isShorthandPropertyAssignment(contextToken2.parent) && !isJsxAttribute(contextToken2.parent) && !(isClassLike(contextToken2.parent) && (contextToken2 !== previousToken || position > previousToken.end));
+    return isDeclarationName(contextToken2) && !isShorthandPropertyAssignment(contextToken2.parent) && !isJsxAttribute(contextToken2.parent) && !((isClassLike(contextToken2.parent) || isInterfaceDeclaration(contextToken2.parent)) && (contextToken2 !== previousToken || position > previousToken.end));
   }
   function isPreviousPropertyDeclarationTerminated(contextToken2, position2) {
     return contextToken2.kind !== 63 /* EqualsToken */ && (contextToken2.kind === 26 /* SemicolonToken */ || !positionsAreOnSameLine(contextToken2.end, position2, sourceFile));
@@ -161373,7 +161328,7 @@ function getDescriptionForFunctionLikeDeclaration(scope) {
     case 176 /* SetAccessor */:
       return `'set ${scope.name.getText()}'`;
     default:
-      throw Debug.assertNever(scope, `Unexpected scope kind ${scope.kind}`);
+      Debug.assertNever(scope, `Unexpected scope kind ${scope.kind}`);
   }
 }
 function getDescriptionForClassLikeDeclaration(scope) {
@@ -168092,8 +168047,8 @@ var SmartIndenter;
 })(SmartIndenter || (SmartIndenter = {}));
 
 // src/server/_namespaces/ts.ts
-var ts_exports3 = {};
-__export(ts_exports3, {
+var ts_exports2 = {};
+__export(ts_exports2, {
   ANONYMOUS: () => ANONYMOUS,
   AccessFlags: () => AccessFlags,
   AssertionLevel: () => AssertionLevel,
@@ -168396,8 +168351,8 @@ __export(ts_exports3, {
   convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
   convertJsonOption: () => convertJsonOption,
   convertToBase64: () => convertToBase64,
+  convertToJson: () => convertToJson,
   convertToObject: () => convertToObject,
-  convertToObjectWorker: () => convertToObjectWorker,
   convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
   convertToRelativePath: () => convertToRelativePath,
   convertToTSConfig: () => convertToTSConfig,
@@ -168662,10 +168617,12 @@ __export(ts_exports3, {
   forEachKey: () => forEachKey,
   forEachLeadingCommentRange: () => forEachLeadingCommentRange,
   forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
+  forEachPropertyAssignment: () => forEachPropertyAssignment,
   forEachResolvedProjectReference: () => forEachResolvedProjectReference,
   forEachReturnStatement: () => forEachReturnStatement,
   forEachRight: () => forEachRight,
   forEachTrailingCommentRange: () => forEachTrailingCommentRange,
+  forEachTsConfigPropArray: () => forEachTsConfigPropArray,
   forEachUnique: () => forEachUnique,
   forEachYieldExpression: () => forEachYieldExpression,
   forSomeAncestorDirectory: () => forSomeAncestorDirectory,
@@ -168998,7 +168955,6 @@ __export(ts_exports3, {
   getProperties: () => getProperties,
   getProperty: () => getProperty,
   getPropertyArrayElementValue: () => getPropertyArrayElementValue,
-  getPropertyAssignment: () => getPropertyAssignment,
   getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
@@ -169103,7 +169059,6 @@ __export(ts_exports3, {
   getTransformers: () => getTransformers,
   getTsBuildInfoEmitOutputFilePath: () => getTsBuildInfoEmitOutputFilePath,
   getTsConfigObjectLiteralExpression: () => getTsConfigObjectLiteralExpression,
-  getTsConfigPropArray: () => getTsConfigPropArray,
   getTsConfigPropArrayElementValue: () => getTsConfigPropArrayElementValue,
   getTypeAnnotationNode: () => getTypeAnnotationNode,
   getTypeArgumentOrTypeParameterList: () => getTypeArgumentOrTypeParameterList,
@@ -169543,6 +169498,7 @@ __export(ts_exports3, {
   isJsxText: () => isJsxText,
   isJumpStatementTarget: () => isJumpStatementTarget,
   isKeyword: () => isKeyword,
+  isKeywordOrPunctuation: () => isKeywordOrPunctuation,
   isKnownSymbol: () => isKnownSymbol,
   isLabelName: () => isLabelName,
   isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
@@ -173005,7 +172961,7 @@ var Project3 = class {
         serverHost: this.projectService.host,
         session: this.projectService.session
       };
-      const pluginModule = pluginModuleFactory({ typescript: ts_exports3 });
+      const pluginModule = pluginModuleFactory({ typescript: ts_exports2 });
       const newLS = pluginModule.create(info);
       for (const k of Object.keys(this.languageService)) {
         if (!(k in newLS)) {
@@ -182361,8 +182317,8 @@ start(initializeNodeSystem(), require("os").platform());
   convertCompilerOptionsFromJson,
   convertJsonOption,
   convertToBase64,
+  convertToJson,
   convertToObject,
-  convertToObjectWorker,
   convertToOptionsWithAbsolutePaths,
   convertToRelativePath,
   convertToTSConfig,
@@ -182627,10 +182583,12 @@ start(initializeNodeSystem(), require("os").platform());
   forEachKey,
   forEachLeadingCommentRange,
   forEachNameInAccessChainWalkingLeft,
+  forEachPropertyAssignment,
   forEachResolvedProjectReference,
   forEachReturnStatement,
   forEachRight,
   forEachTrailingCommentRange,
+  forEachTsConfigPropArray,
   forEachUnique,
   forEachYieldExpression,
   forSomeAncestorDirectory,
@@ -182963,7 +182921,6 @@ start(initializeNodeSystem(), require("os").platform());
   getProperties,
   getProperty,
   getPropertyArrayElementValue,
-  getPropertyAssignment,
   getPropertyAssignmentAliasLikeExpression,
   getPropertyNameForPropertyNameNode,
   getPropertyNameForUniqueESSymbol,
@@ -183068,7 +183025,6 @@ start(initializeNodeSystem(), require("os").platform());
   getTransformers,
   getTsBuildInfoEmitOutputFilePath,
   getTsConfigObjectLiteralExpression,
-  getTsConfigPropArray,
   getTsConfigPropArrayElementValue,
   getTypeAnnotationNode,
   getTypeArgumentOrTypeParameterList,
@@ -183508,6 +183464,7 @@ start(initializeNodeSystem(), require("os").platform());
   isJsxText,
   isJumpStatementTarget,
   isKeyword,
+  isKeywordOrPunctuation,
   isKnownSymbol,
   isLabelName,
   isLabelOfLabeledStatement,