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

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230320`;
+      version = `${versionMajorMinor}.0-dev.20230322`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -7944,6 +7944,7 @@ ${lanes.join("\n")}
         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}'."),
@@ -8389,13 +8390,14 @@ ${lanes.join("\n")}
         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."),
@@ -13858,17 +13860,17 @@ ${lanes.join("\n")}
         return Debug.assertNever(name);
     }
   }
-  function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) {
+  function createDiagnosticForNode(node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
-    return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3);
+    return createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args);
   }
-  function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) {
+  function createDiagnosticForNodeArray(sourceFile, nodes, message, ...args) {
     const start = skipTrivia(sourceFile.text, nodes.pos);
-    return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2, arg3);
+    return createFileDiagnostic(sourceFile, start, nodes.end - start, message, ...args);
   }
-  function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) {
+  function createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args) {
     const span = getErrorSpanForNode(sourceFile, node);
-    return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3);
+    return createFileDiagnostic(sourceFile, span.start, span.length, message, ...args);
   }
   function createDiagnosticForNodeFromMessageChain(sourceFile, node, messageChain, relatedInformation) {
     const span = getErrorSpanForNode(sourceFile, node);
@@ -14321,17 +14323,20 @@ ${lanes.join("\n")}
   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) {
@@ -14340,11 +14345,10 @@ ${lanes.join("\n")}
     }
   }
   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);
@@ -15684,6 +15688,12 @@ ${lanes.join("\n")}
   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 */;
   }
@@ -27997,7 +28007,6 @@ ${lanes.join("\n")}
     "src/compiler/parser.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
       init_ts_performance();
       parseBaseNodeFactory = {
         createBaseSourceFileNode: (kind) => new (SourceFileConstructor || (SourceFileConstructor = objectAllocator.getSourceFileConstructor()))(kind, -1, -1),
@@ -28533,14 +28542,12 @@ ${lanes.join("\n")}
           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
             );
@@ -28972,24 +28979,24 @@ ${lanes.join("\n")}
         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(start, length2, message, arg0) {
+        function parseErrorAtPosition(start, length2, message, ...args) {
           const lastError = lastOrUndefined(parseDiagnostics);
           let result;
           if (!lastError || start !== lastError.start) {
-            result = createDetachedDiagnostic(fileName, start, length2, message, arg0);
+            result = createDetachedDiagnostic(fileName, start, length2, message, ...args);
             parseDiagnostics.push(result);
           }
           parseErrorBeforeNextFinishedNode = true;
           return result;
         }
-        function parseErrorAt(start, end, message, arg0) {
-          return parseErrorAtPosition(start, end - start, message, arg0);
+        function parseErrorAt(start, end, message, ...args) {
+          return parseErrorAtPosition(start, end - start, message, ...args);
         }
-        function parseErrorAtRange(range, message, arg0) {
-          parseErrorAt(range.pos, range.end, message, arg0);
+        function parseErrorAtRange(range, message, ...args) {
+          parseErrorAt(range.pos, range.end, message, ...args);
         }
         function scanError(message, length2) {
           parseErrorAtPosition(scanner2.getTokenEnd(), length2, message);
@@ -29195,6 +29202,7 @@ ${lanes.join("\n")}
             nextTokenJSDoc();
             return true;
           }
+          Debug.assert(isKeywordOrPunctuation(kind));
           parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
           return false;
         }
@@ -29243,7 +29251,11 @@ ${lanes.join("\n")}
           );
         }
         function parseExpectedTokenJSDoc(t) {
-          return parseOptionalTokenJSDoc(t) || createMissingNode(
+          const optional = parseOptionalTokenJSDoc(t);
+          if (optional)
+            return optional;
+          Debug.assert(isKeywordOrPunctuation(t));
+          return createMissingNode(
             t,
             /*reportAtCurrentPosition*/
             false,
@@ -29297,11 +29309,11 @@ ${lanes.join("\n")}
           }
           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(
@@ -31660,6 +31672,7 @@ ${lanes.join("\n")}
             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));
             }
           }
@@ -34607,14 +34620,14 @@ ${lanes.join("\n")}
             }
             function parseReturnTag(start2, tagName, indent2, 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(start2, getNodePos(), indent2, indentText)), start2);
             }
             function parseTypeTag(start2, tagName, indent2, 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*/
@@ -35427,13 +35440,13 @@ ${lanes.join("\n")}
   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 = {};
@@ -35474,7 +35487,7 @@ ${lanes.join("\n")}
             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 {
@@ -35664,9 +35677,7 @@ ${lanes.join("\n")}
       config: convertConfigFileToObject(
         jsonSourceFile,
         jsonSourceFile.parseDiagnostics,
-        /*reportOptionsErrors*/
-        false,
-        /*optionsIterator*/
+        /*jsonConversionNotifier*/
         void 0
       ),
       error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : void 0
@@ -35707,24 +35718,9 @@ ${lanes.join("\n")}
         // 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",
@@ -35770,10 +35766,9 @@ ${lanes.join("\n")}
     }
     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,
@@ -35784,52 +35779,46 @@ ${lanes.join("\n")}
       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 */) {
@@ -35844,38 +35833,13 @@ ${lanes.join("\n")}
         }
         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;
@@ -35888,112 +35852,40 @@ ${lanes.join("\n")}
       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);
@@ -36005,7 +35897,7 @@ ${lanes.join("\n")}
   function isCompilerOptionsValue(option, value) {
     if (option) {
       if (isNullOrUndefined(value))
-        return true;
+        return !option.disallowNullOrUndefined;
       if (option.type === "list") {
         return isArray(value);
       }
@@ -36364,8 +36256,8 @@ ${lanes.join("\n")}
           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");
@@ -36467,9 +36359,9 @@ ${lanes.join("\n")}
       }
       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));
       }
     }
   }
@@ -36568,27 +36460,42 @@ ${lanes.join("\n")}
     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);
@@ -36596,69 +36503,11 @@ ${lanes.join("\n")}
     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);
@@ -36667,15 +36516,57 @@ ${lanes.join("\n")}
       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;
         }
       }
@@ -36686,9 +36577,9 @@ ${lanes.join("\n")}
       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;
   }
@@ -36790,43 +36681,34 @@ ${lanes.join("\n")}
       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)));
+      errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, 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);
-    }
-    return normalizeNonListOptionValue(option, basePath, value);
-  }
   function normalizeNonListOptionValue(option, basePath, value) {
     if (option.isFilePath) {
       value = getNormalizedAbsolutePath(value, basePath);
@@ -36836,29 +36718,29 @@ ${lanes.join("\n")}
     }
     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);
   }
   function getFileNamesFromConfigSpecs(configFileSpecs, basePath, options, host, extraFileExtensions = emptyArray) {
     basePath = normalizePath(basePath);
@@ -36965,7 +36847,7 @@ ${lanes.join("\n")}
     });
     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) {
@@ -37076,6 +36958,8 @@ ${lanes.join("\n")}
     return out;
   }
   function getOptionValueWithEmptyStrings(value, option) {
+    if (value === void 0)
+      return value;
     switch (option.type) {
       case "object":
         return "";
@@ -37090,7 +36974,7 @@ ${lanes.join("\n")}
           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) {
@@ -37121,7 +37005,7 @@ ${lanes.join("\n")}
         return Debug.fail("Expected 'option.type' to have entries.");
     }
   }
-  var compileOnSaveCommandLineOption, jsxOptionMap, inverseJsxOptionMap, libEntries, libs, libMap, optionsForWatch, commonOptionsWithBuild, targetOptionDeclaration, moduleOptionDeclaration, commandOptionsWithoutBuild, optionDeclarations, semanticDiagnosticsOptionDeclarations, affectsEmitOptionDeclarations, affectsDeclarationPathOptionDeclarations, moduleResolutionOptionDeclarations, sourceFileAffectingCompilerOptions, optionsAffectingProgramStructure, transpileOptionValueCompilerOptions, optionsForBuild, buildOpts, typeAcquisitionDeclarations, optionsNameMapCache, compilerOptionsAlternateMode, defaultInitCompilerOptions, compilerOptionsDidYouMeanDiagnostics, buildOptionsNameMapCache, buildOptionsAlternateMode, buildOptionsDidYouMeanDiagnostics, typeAcquisitionDidYouMeanDiagnostics, watchOptionsNameMapCache, watchOptionsDidYouMeanDiagnostics, commandLineCompilerOptionsMapCache, commandLineWatchOptionsMapCache, commandLineTypeAcquisitionMapCache, extendsOptionDeclaration, _tsconfigRootOptions, defaultIncludeSpec, invalidTrailingRecursionPattern, wildcardDirectoryPattern;
+  var compileOnSaveCommandLineOption, jsxOptionMap, inverseJsxOptionMap, libEntries, libs, libMap, optionsForWatch, commonOptionsWithBuild, targetOptionDeclaration, moduleOptionDeclaration, commandOptionsWithoutBuild, optionDeclarations, semanticDiagnosticsOptionDeclarations, affectsEmitOptionDeclarations, affectsDeclarationPathOptionDeclarations, moduleResolutionOptionDeclarations, sourceFileAffectingCompilerOptions, optionsAffectingProgramStructure, transpileOptionValueCompilerOptions, optionsForBuild, buildOpts, typeAcquisitionDeclarations, optionsNameMapCache, compilerOptionsAlternateMode, defaultInitCompilerOptions, compilerOptionsDidYouMeanDiagnostics, buildOptionsNameMapCache, buildOptionsAlternateMode, buildOptionsDidYouMeanDiagnostics, typeAcquisitionDidYouMeanDiagnostics, watchOptionsNameMapCache, watchOptionsDidYouMeanDiagnostics, commandLineCompilerOptionsMapCache, commandLineWatchOptionsMapCache, commandLineTypeAcquisitionMapCache, extendsOptionDeclaration, compilerOptionsDeclaration, watchOptionsDeclaration, typeAcquisitionDeclaration, _tsconfigRootOptions, defaultIncludeSpec, invalidTrailingRecursionPattern, wildcardDirectoryPattern;
   var init_commandLineParser = __esm({
     "src/compiler/commandLineParser.ts"() {
       "use strict";
@@ -38627,7 +38511,26 @@ ${lanes.join("\n")}
           name: "extends",
           type: "string"
         },
-        category: Diagnostics.File_Management
+        category: Diagnostics.File_Management,
+        disallowNullOrUndefined: true
+      };
+      compilerOptionsDeclaration = {
+        name: "compilerOptions",
+        type: "object",
+        elementOptions: getCommandLineCompilerOptionsMap(),
+        extraKeyDiagnostics: compilerOptionsDidYouMeanDiagnostics
+      };
+      watchOptionsDeclaration = {
+        name: "watchOptions",
+        type: "object",
+        elementOptions: getCommandLineWatchOptionsMap(),
+        extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics
+      };
+      typeAcquisitionDeclaration = {
+        name: "typeAcquisition",
+        type: "object",
+        elementOptions: getCommandLineTypeAcquisitionMap(),
+        extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
       };
       defaultIncludeSpec = "**/*";
       invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/;
@@ -41355,8 +41258,8 @@ ${lanes.join("\n")}
     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;
@@ -41550,7 +41453,7 @@ ${lanes.join("\n")}
             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
               );
@@ -41558,7 +41461,7 @@ ${lanes.join("\n")}
                 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);
           }
@@ -43019,9 +42922,9 @@ ${lanes.join("\n")}
         }
       }
     }
-    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);
@@ -45087,6 +44990,7 @@ ${lanes.join("\n")}
     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),
@@ -45914,8 +45818,8 @@ ${lanes.join("\n")}
       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;
@@ -45924,16 +45828,16 @@ ${lanes.join("\n")}
         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;
     }
@@ -45944,19 +45848,19 @@ ${lanes.join("\n")}
         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);
@@ -47830,7 +47734,7 @@ ${lanes.join("\n")}
       return void 0;
     }
     function markExportAsReferenced(node) {
-      if (compilerOptions.verbatimModuleSyntax) {
+      if (!canCollectSymbolAliasAccessabilityData) {
         return;
       }
       const symbol = getSymbolOfDeclaration(node);
@@ -47843,7 +47747,7 @@ ${lanes.join("\n")}
       }
     }
     function markAliasSymbolAsReferenced(symbol) {
-      Debug.assert(!compilerOptions.verbatimModuleSyntax);
+      Debug.assert(canCollectSymbolAliasAccessabilityData);
       const links = getSymbolLinks(symbol);
       if (!links.referenced) {
         links.referenced = true;
@@ -47974,6 +47878,9 @@ ${lanes.join("\n")}
           }
         }
         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);
@@ -48010,7 +47917,7 @@ ${lanes.join("\n")}
           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 */)) {
@@ -49723,8 +49630,11 @@ ${lanes.join("\n")}
           }
           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 */));
@@ -55892,7 +55802,7 @@ ${lanes.join("\n")}
       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);
@@ -56128,7 +56038,7 @@ ${lanes.join("\n")}
       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));
         }
       }
@@ -58280,6 +58190,12 @@ ${lanes.join("\n")}
         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) {
@@ -58847,7 +58763,7 @@ ${lanes.join("\n")}
             links.resolvedType = getTypeFromTypeNode(node.type);
             break;
           default:
-            throw Debug.assertNever(node.operator);
+            Debug.assertNever(node.operator);
         }
       }
       return links.resolvedType;
@@ -58931,7 +58847,7 @@ ${lanes.join("\n")}
       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}`>
@@ -59814,7 +59730,10 @@ ${lanes.join("\n")}
             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;
@@ -60605,7 +60524,13 @@ ${lanes.join("\n")}
       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);
@@ -61231,6 +61156,9 @@ ${lanes.join("\n")}
       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) {
@@ -61274,7 +61202,12 @@ ${lanes.join("\n")}
       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));
@@ -61540,7 +61473,7 @@ ${lanes.join("\n")}
     }
     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;
@@ -61559,6 +61492,11 @@ ${lanes.join("\n")}
       }
       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;
@@ -61648,10 +61586,10 @@ ${lanes.join("\n")}
           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 || [];
@@ -61743,13 +61681,13 @@ ${lanes.join("\n")}
           );
         }
       }
-      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);
@@ -62929,6 +62867,26 @@ ${lanes.join("\n")}
             )) {
               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) {
@@ -63036,7 +62994,7 @@ ${lanes.join("\n")}
             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 {
@@ -63919,22 +63877,7 @@ ${lanes.join("\n")}
       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 */) {
@@ -65378,21 +65321,19 @@ ${lanes.join("\n")}
         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);
@@ -65534,7 +65475,11 @@ ${lanes.join("\n")}
           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;
@@ -66007,36 +65952,34 @@ ${lanes.join("\n")}
       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;
@@ -67954,7 +67897,7 @@ ${lanes.join("\n")}
       });
     }
     function markAliasReferenced(symbol, location) {
-      if (compilerOptions.verbatimModuleSyntax) {
+      if (!canCollectSymbolAliasAccessabilityData) {
         return;
       }
       if (isNonLocalAlias(
@@ -69246,7 +69189,11 @@ ${lanes.join("\n")}
       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
         );
@@ -70511,7 +70458,7 @@ ${lanes.join("\n")}
         }
         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);
           }
         }
@@ -72085,16 +72032,16 @@ ${lanes.join("\n")}
       }
       return { start, length: length2, sourceFile };
     }
-    function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
+    function getDiagnosticForCallNode(node, message, ...args) {
       if (isCallExpression(node)) {
         const { sourceFile, start, length: length2 } = getDiagnosticSpanForCallNode(node);
         if ("message" in message) {
-          return createFileDiagnostic(sourceFile, start, length2, message, arg0, arg1, arg2, arg3);
+          return createFileDiagnostic(sourceFile, start, length2, message, ...args);
         }
         return createDiagnosticForFileFromMessageChain(sourceFile, message);
       } else {
         if ("message" in message) {
-          return createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
+          return createDiagnosticForNode(node, message, ...args);
         }
         return createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, message);
       }
@@ -72182,11 +72129,8 @@ ${lanes.join("\n")}
         }
         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;
@@ -73117,7 +73061,7 @@ ${lanes.join("\n")}
         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);
@@ -73791,12 +73735,12 @@ ${lanes.join("\n")}
       }
       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 = [];
@@ -73814,13 +73758,7 @@ ${lanes.join("\n")}
           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;
@@ -77526,9 +77464,9 @@ ${lanes.join("\n")}
         }
       }
     }
-    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)) {
@@ -77591,8 +77529,8 @@ ${lanes.join("\n")}
       }
       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) {
@@ -77648,11 +77586,11 @@ ${lanes.join("\n")}
       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;
       }
@@ -77670,7 +77608,7 @@ ${lanes.join("\n")}
           }
           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();
@@ -77694,7 +77632,7 @@ ${lanes.join("\n")}
           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;
@@ -77708,7 +77646,7 @@ ${lanes.join("\n")}
           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;
@@ -77886,7 +77824,7 @@ ${lanes.join("\n")}
         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);
@@ -78295,9 +78233,8 @@ ${lanes.join("\n")}
             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));
@@ -79855,7 +79792,7 @@ ${lanes.join("\n")}
               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));
                 }
               });
             }
@@ -81451,6 +81388,9 @@ ${lanes.join("\n")}
       ) && !getSymbolLinks(getSymbolOfDeclaration(statement)).constEnumReferenced;
     }
     function checkImportsForTypeOnlyConversion(sourceFile) {
+      if (!canCollectSymbolAliasAccessabilityData) {
+        return;
+      }
       for (const statement of sourceFile.statements) {
         if (canConvertImportDeclarationToTypeOnly(statement) || canConvertImportEqualsDeclarationToTypeOnly(statement)) {
           error(
@@ -81536,14 +81476,14 @@ ${lanes.join("\n")}
           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,
@@ -82880,7 +82820,7 @@ ${lanes.join("\n")}
       return false;
     }
     function isValueAliasDeclaration(node) {
-      Debug.assert(!compilerOptions.verbatimModuleSyntax);
+      Debug.assert(canCollectSymbolAliasAccessabilityData);
       switch (node.kind) {
         case 269 /* ImportEqualsDeclaration */:
           return isAliasResolvedToValue(getSymbolOfDeclaration(node));
@@ -82921,7 +82861,7 @@ ${lanes.join("\n")}
       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);
@@ -83259,12 +83199,12 @@ ${lanes.join("\n")}
         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);
@@ -84396,10 +84336,10 @@ ${lanes.join("\n")}
             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;
           }
@@ -84868,12 +84808,12 @@ ${lanes.join("\n")}
       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;
       }
@@ -84881,35 +84821,35 @@ ${lanes.join("\n")}
     function hasParseDiagnostics(sourceFile) {
       return sourceFile.parseDiagnostics.length > 0;
     }
-    function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+    function grammarErrorOnFirstToken(node, message, ...args) {
       const sourceFile = getSourceFileOfNode(node);
       if (!hasParseDiagnostics(sourceFile)) {
         const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
-        diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
+        diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, ...args));
         return true;
       }
       return false;
     }
-    function grammarErrorAtPos(nodeForSourceFile, start, length2, message, arg0, arg1, arg2) {
+    function grammarErrorAtPos(nodeForSourceFile, start, length2, message, ...args) {
       const sourceFile = getSourceFileOfNode(nodeForSourceFile);
       if (!hasParseDiagnostics(sourceFile)) {
-        diagnostics.add(createFileDiagnostic(sourceFile, start, length2, message, arg0, arg1, arg2));
+        diagnostics.add(createFileDiagnostic(sourceFile, start, length2, message, ...args));
         return true;
       }
       return false;
     }
-    function grammarErrorOnNodeSkippedOn(key, node, message, arg0, arg1, arg2) {
+    function grammarErrorOnNodeSkippedOn(key, node, message, ...args) {
       const sourceFile = getSourceFileOfNode(node);
       if (!hasParseDiagnostics(sourceFile)) {
-        errorSkippedOn(key, node, message, arg0, arg1, arg2);
+        errorSkippedOn(key, node, message, ...args);
         return true;
       }
       return false;
     }
-    function grammarErrorOnNode(node, message, arg0, arg1, arg2) {
+    function grammarErrorOnNode(node, message, ...args) {
       const sourceFile = getSourceFileOfNode(node);
       if (!hasParseDiagnostics(sourceFile)) {
-        diagnostics.add(createDiagnosticForNode(node, message, arg0, arg1, arg2));
+        diagnostics.add(createDiagnosticForNode(node, message, ...args));
         return true;
       }
       return false;
@@ -85054,7 +84994,7 @@ ${lanes.join("\n")}
       }
       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);
@@ -85064,9 +85004,7 @@ ${lanes.join("\n")}
           /*length*/
           0,
           message,
-          arg0,
-          arg1,
-          arg2
+          ...args
         ));
         return true;
       }
@@ -85212,6 +85150,10 @@ ${lanes.join("\n")}
       }
       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);
@@ -97511,10 +97453,13 @@ ${lanes.join("\n")}
           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;
@@ -97680,7 +97625,10 @@ ${lanes.join("\n")}
       }
       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) {
@@ -97688,30 +97636,48 @@ ${lanes.join("\n")}
       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);
@@ -109876,8 +109842,7 @@ ${lanes.join("\n")}
     }
   }
   function createBuildInfo(program, bundle) {
-    const version2 = version;
-    return { bundle, program, version: version2 };
+    return { bundle, program, version };
   }
   function getBuildInfoText(buildInfo) {
     return JSON.stringify(buildInfo);
@@ -109922,10 +109887,10 @@ ${lanes.join("\n")}
       /*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;
   }
@@ -113935,12 +113900,12 @@ ${lanes.join("\n")}
       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) {
@@ -114059,7 +114024,7 @@ ${lanes.join("\n")}
     function makeFileLevelOptimisticUniqueName(name) {
       return makeUniqueName2(
         name,
-        isFileLevelUniqueName2,
+        isFileLevelUniqueNameInCurrentFile,
         /*optimistic*/
         true,
         /*scoped*/
@@ -114239,7 +114204,7 @@ ${lanes.join("\n")}
         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),
@@ -115257,7 +115222,6 @@ ${lanes.join("\n")}
     "src/compiler/watchUtilities.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
       ConfigFileProgramReloadLevel = /* @__PURE__ */ ((ConfigFileProgramReloadLevel2) => {
         ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["None"] = 0] = "None";
         ConfigFileProgramReloadLevel2[ConfigFileProgramReloadLevel2["Partial"] = 1] = "Partial";
@@ -117257,12 +117221,12 @@ ${lanes.join("\n")}
             }
           }
         }
-        function createDiagnosticForNodeArray2(nodes, message, arg0, arg1, arg2) {
+        function createDiagnosticForNodeArray2(nodes, message, ...args) {
           const start = nodes.pos;
-          return createFileDiagnostic(sourceFile, start, nodes.end - start, message, arg0, arg1, arg2);
+          return createFileDiagnostic(sourceFile, start, nodes.end - start, message, ...args);
         }
-        function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
-          return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2);
+        function createDiagnosticForNode2(node, message, ...args) {
+          return createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args);
         }
       });
     }
@@ -117927,11 +117891,12 @@ ${lanes.join("\n")}
           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
           });
         }
       });
@@ -118396,7 +118361,7 @@ ${lanes.join("\n")}
       }
     }
     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*/
@@ -118404,7 +118369,7 @@ ${lanes.join("\n")}
             Diagnostics.Use_0_instead,
             useInstead
           );
-          const chain = chainDiagnosticMessages(details, message, arg0, arg1, arg2, arg3);
+          const chain = chainDiagnosticMessages(details, message, ...args);
           createDiagnosticForOption(
             /*onKey*/
             !value,
@@ -118421,10 +118386,7 @@ ${lanes.join("\n")}
             /*option2*/
             void 0,
             message,
-            arg0,
-            arg1,
-            arg2,
-            arg3
+            ...args
           );
         }
       }
@@ -118477,8 +118439,8 @@ ${lanes.join("\n")}
       });
     }
     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) {
@@ -118590,8 +118552,9 @@ ${lanes.join("\n")}
           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(
@@ -118660,28 +118623,26 @@ ${lanes.join("\n")}
         }
       });
     }
-    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,
@@ -118689,25 +118650,23 @@ ${lanes.join("\n")}
           /*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();
@@ -118725,7 +118684,7 @@ ${lanes.join("\n")}
         option3
       );
     }
-    function createOptionValueDiagnostic(option1, message, arg0, arg1) {
+    function createOptionValueDiagnostic(option1, message, ...args) {
       createDiagnosticForOption(
         /*onKey*/
         false,
@@ -118733,57 +118692,53 @@ ${lanes.join("\n")}
         /*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();
@@ -119118,7 +119073,6 @@ ${lanes.join("\n")}
     "src/compiler/program.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
       init_ts_performance();
       ForegroundColorEscapeSequences = /* @__PURE__ */ ((ForegroundColorEscapeSequences2) => {
         ForegroundColorEscapeSequences2["Grey"] = "\x1B[90m";
@@ -119833,16 +119787,16 @@ ${lanes.join("\n")}
       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);
     }
@@ -120745,7 +120699,7 @@ ${lanes.join("\n")}
     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)) {
@@ -120826,7 +120780,7 @@ ${lanes.join("\n")}
       close: noop,
       hasChangedEmitSignature: returnFalse
     };
-    function toPath3(path) {
+    function toPathInBuildInfoDirectory(path) {
       return toPath(path, buildInfoDirectory, getCanonicalFileName);
     }
     function toAbsolutePath(path) {
@@ -120908,7 +120862,6 @@ ${lanes.join("\n")}
     "src/compiler/builder.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
       BuilderFileEmit = /* @__PURE__ */ ((BuilderFileEmit2) => {
         BuilderFileEmit2[BuilderFileEmit2["None"] = 0] = "None";
         BuilderFileEmit2[BuilderFileEmit2["Js"] = 1] = "Js";
@@ -121788,7 +121741,6 @@ ${lanes.join("\n")}
     "src/compiler/resolutionCache.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
     }
   });
 
@@ -121901,15 +121853,13 @@ ${lanes.join("\n")}
     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}`;
   }
@@ -122119,15 +122069,15 @@ ${lanes.join("\n")}
           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*/
@@ -122136,12 +122086,13 @@ ${lanes.join("\n")}
             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);
     }
@@ -123183,7 +123134,6 @@ ${lanes.join("\n")}
     "src/compiler/watchPublic.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
     }
   });
 
@@ -125203,7 +125153,6 @@ ${lanes.join("\n")}
     "src/compiler/tsbuildPublic.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
       init_ts_performance();
       minimumDate = /* @__PURE__ */ new Date(-864e13);
       maximumDate = /* @__PURE__ */ new Date(864e13);
@@ -125533,7 +125482,7 @@ ${lanes.join("\n")}
       case 0 /* Ok */:
         return Debug.fail();
       default:
-        throw Debug.assertNever(result);
+        Debug.assertNever(result);
     }
   }
   var unprefixedNodeCoreModuleList, prefixedNodeCoreModuleList, nodeCoreModuleList, nodeCoreModules, NameValidationResult, maxPackageNameLength;
@@ -127293,9 +127242,6 @@ ${lanes.join("\n")}
     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;
   }
@@ -128752,6 +128698,7 @@ ${lanes.join("\n")}
         147 /* ReadonlyKeyword */,
         153 /* StringKeyword */,
         154 /* SymbolKeyword */,
+        113 /* TypeOfKeyword */,
         111 /* TrueKeyword */,
         115 /* VoidKeyword */,
         156 /* UndefinedKeyword */,
@@ -131772,7 +131719,6 @@ ${lanes.join("\n")}
     "src/services/sourcemaps.ts"() {
       "use strict";
       init_ts4();
-      init_ts4();
       base64UrlRegExp = /^data:(?:application\/json(?:;charset=[uU][tT][fF]-8);base64,([A-Za-z0-9+\/=]+)$)?/;
     }
   });
@@ -133002,6 +132948,241 @@ ${lanes.join("\n")}
     }
   });
 
+  // src/services/classifier2020.ts
+  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 TokenEncodingConsts, TokenType, TokenModifier, tokenFromDeclarationMapping;
+  var init_classifier2020 = __esm({
+    "src/services/classifier2020.ts"() {
+      "use strict";
+      init_ts4();
+      TokenEncodingConsts = /* @__PURE__ */ ((TokenEncodingConsts2) => {
+        TokenEncodingConsts2[TokenEncodingConsts2["typeOffset"] = 8] = "typeOffset";
+        TokenEncodingConsts2[TokenEncodingConsts2["modifierMask"] = 255] = "modifierMask";
+        return TokenEncodingConsts2;
+      })(TokenEncodingConsts || {});
+      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 || {});
+      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 || {});
+      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
   function createNode(kind, pos, end, parent2) {
     const node = isNodeKind(kind) ? new NodeObject(kind, pos, end) : kind === 79 /* Identifier */ ? new IdentifierObject(79 /* Identifier */, pos, end) : kind === 80 /* PrivateIdentifier */ ? new PrivateIdentifierObject(80 /* PrivateIdentifier */, pos, end) : new TokenObject(kind, pos, end);
@@ -133768,7 +133949,7 @@ ${lanes.join("\n")}
       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);
       }
@@ -133779,7 +133960,7 @@ ${lanes.join("\n")}
       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) {
@@ -134439,9 +134620,10 @@ ${lanes.join("\n")}
     "src/services/services.ts"() {
       "use strict";
       init_ts4();
-      init_ts4();
       init_ts_NavigateTo();
       init_ts_NavigationBar();
+      init_classifier();
+      init_classifier2020();
       servicesVersion = "0.8";
       NodeObject = class {
         constructor(kind, pos, end) {
@@ -137043,241 +137225,6 @@ ${lanes.join("\n")}
     }
   });
 
-  // src/services/classifier2020.ts
-  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 TokenEncodingConsts, TokenType, TokenModifier, tokenFromDeclarationMapping;
-  var init_classifier2020 = __esm({
-    "src/services/classifier2020.ts"() {
-      "use strict";
-      init_ts4();
-      TokenEncodingConsts = /* @__PURE__ */ ((TokenEncodingConsts2) => {
-        TokenEncodingConsts2[TokenEncodingConsts2["typeOffset"] = 8] = "typeOffset";
-        TokenEncodingConsts2[TokenEncodingConsts2["modifierMask"] = 255] = "modifierMask";
-        return TokenEncodingConsts2;
-      })(TokenEncodingConsts || {});
-      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 || {});
-      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 || {});
-      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.classifier.v2020.ts
   var ts_classifier_v2020_exports = {};
   __export(ts_classifier_v2020_exports, {
@@ -147049,7 +146996,7 @@ ${lanes.join("\n")}
       /*checkArgumentIsStringLiteralLike*/
       true
     )) {
-      throw Debug.failBadSyntaxKind(parent2);
+      Debug.failBadSyntaxKind(parent2);
     }
     const decl = cast(parent2.parent, isVariableDeclaration);
     const defaultImportName = tryCast(decl.name, isIdentifier);
@@ -150515,7 +150462,7 @@ ${lanes.join("\n")}
           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));
@@ -160665,7 +160612,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       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) {
@@ -167868,8 +167815,8 @@ ${options.prefix}` : "\n" : options.prefix
   });
 
   // src/typescript/_namespaces/ts.ts
-  var ts_exports3 = {};
-  __export(ts_exports3, {
+  var ts_exports2 = {};
+  __export(ts_exports2, {
     ANONYMOUS: () => ANONYMOUS,
     AccessFlags: () => AccessFlags,
     AssertionLevel: () => AssertionLevel,
@@ -168172,8 +168119,8 @@ ${options.prefix}` : "\n" : options.prefix
     convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
     convertJsonOption: () => convertJsonOption,
     convertToBase64: () => convertToBase64,
+    convertToJson: () => convertToJson,
     convertToObject: () => convertToObject,
-    convertToObjectWorker: () => convertToObjectWorker,
     convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
     convertToRelativePath: () => convertToRelativePath,
     convertToTSConfig: () => convertToTSConfig,
@@ -168438,10 +168385,12 @@ ${options.prefix}` : "\n" : options.prefix
     forEachKey: () => forEachKey,
     forEachLeadingCommentRange: () => forEachLeadingCommentRange,
     forEachNameInAccessChainWalkingLeft: () => forEachNameInAccessChainWalkingLeft,
+    forEachPropertyAssignment: () => forEachPropertyAssignment,
     forEachResolvedProjectReference: () => forEachResolvedProjectReference,
     forEachReturnStatement: () => forEachReturnStatement,
     forEachRight: () => forEachRight,
     forEachTrailingCommentRange: () => forEachTrailingCommentRange,
+    forEachTsConfigPropArray: () => forEachTsConfigPropArray,
     forEachUnique: () => forEachUnique,
     forEachYieldExpression: () => forEachYieldExpression,
     forSomeAncestorDirectory: () => forSomeAncestorDirectory,
@@ -168774,7 +168723,6 @@ ${options.prefix}` : "\n" : options.prefix
     getProperties: () => getProperties,
     getProperty: () => getProperty,
     getPropertyArrayElementValue: () => getPropertyArrayElementValue,
-    getPropertyAssignment: () => getPropertyAssignment,
     getPropertyAssignmentAliasLikeExpression: () => getPropertyAssignmentAliasLikeExpression,
     getPropertyNameForPropertyNameNode: () => getPropertyNameForPropertyNameNode,
     getPropertyNameForUniqueESSymbol: () => getPropertyNameForUniqueESSymbol,
@@ -168879,7 +168827,6 @@ ${options.prefix}` : "\n" : options.prefix
     getTransformers: () => getTransformers,
     getTsBuildInfoEmitOutputFilePath: () => getTsBuildInfoEmitOutputFilePath,
     getTsConfigObjectLiteralExpression: () => getTsConfigObjectLiteralExpression,
-    getTsConfigPropArray: () => getTsConfigPropArray,
     getTsConfigPropArrayElementValue: () => getTsConfigPropArrayElementValue,
     getTypeAnnotationNode: () => getTypeAnnotationNode,
     getTypeArgumentOrTypeParameterList: () => getTypeArgumentOrTypeParameterList,
@@ -169319,6 +169266,7 @@ ${options.prefix}` : "\n" : options.prefix
     isJsxText: () => isJsxText,
     isJumpStatementTarget: () => isJumpStatementTarget,
     isKeyword: () => isKeyword,
+    isKeywordOrPunctuation: () => isKeywordOrPunctuation,
     isKnownSymbol: () => isKnownSymbol,
     isLabelName: () => isLabelName,
     isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
@@ -170146,7 +170094,7 @@ ${options.prefix}` : "\n" : options.prefix
           }
         };
       }
-      module2.exports = ts_exports3;
+      module2.exports = ts_exports2;
     }
   });
   return require_typescript();