typescript 5.1.0-dev.20230319 → 5.1.0-dev.20230321

package/lib/tsserverlibrary.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.1";
-      version = `${versionMajorMinor}.0-dev.20230319`;
+      version = `${versionMajorMinor}.0-dev.20230321`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -4439,7 +4439,7 @@ ${lanes.join("\n")}
         TypeFlags2[TypeFlags2["InstantiablePrimitive"] = 406847488] = "InstantiablePrimitive";
         TypeFlags2[TypeFlags2["Instantiable"] = 465829888] = "Instantiable";
         TypeFlags2[TypeFlags2["StructuredOrInstantiable"] = 469499904] = "StructuredOrInstantiable";
-        TypeFlags2[TypeFlags2["ObjectFlagsType"] = 3899393] = "ObjectFlagsType";
+        TypeFlags2[TypeFlags2["ObjectFlagsType"] = 138117121] = "ObjectFlagsType";
         TypeFlags2[TypeFlags2["Simplifiable"] = 25165824] = "Simplifiable";
         TypeFlags2[TypeFlags2["Singleton"] = 67358815] = "Singleton";
         TypeFlags2[TypeFlags2["Narrowable"] = 536624127] = "Narrowable";
@@ -8389,13 +8389,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 +13859,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);
@@ -15684,6 +15685,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 */;
   }
@@ -17454,7 +17461,7 @@ ${lanes.join("\n")}
     return (_a2 = symbol.declarations) == null ? void 0 : _a2.find(isClassLike);
   }
   function getObjectFlags(type) {
-    return type.flags & 3899393 /* ObjectFlagsType */ ? type.objectFlags : 0;
+    return type.flags & 138117121 /* ObjectFlagsType */ ? type.objectFlags : 0;
   }
   function forSomeAncestorDirectory(directory, callback) {
     return !!forEachAncestorDirectory(directory, (d) => callback(d) ? true : void 0);
@@ -27997,7 +28004,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 +28539,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 +28976,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 +29199,7 @@ ${lanes.join("\n")}
             nextTokenJSDoc();
             return true;
           }
+          Debug.assert(isKeywordOrPunctuation(kind));
           parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
           return false;
         }
@@ -29243,7 +29248,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 +29306,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 +31669,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 +34617,14 @@ ${lanes.join("\n")}
             }
             function parseReturnTag(start2, tagName, indent3, indentText) {
               if (some(tags, isJSDocReturnTag)) {
-                parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, tagName.escapedText);
+                parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
               }
               const typeExpression = tryParseTypeExpression();
               return finishNode(factory2.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start2, getNodePos(), indent3, indentText)), start2);
             }
             function parseTypeTag(start2, tagName, indent3, indentText) {
               if (some(tags, isJSDocTypeTag)) {
-                parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, tagName.escapedText);
+                parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
               }
               const typeExpression = parseJSDocTypeExpression(
                 /*mayOmitBraces*/
@@ -35427,13 +35437,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 +35484,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 +35674,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 +35715,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 +35763,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 +35776,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 +35830,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 +35849,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 +35894,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);
       }
@@ -36365,7 +36254,7 @@ ${lanes.join("\n")}
             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 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 +36356,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 +36457,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 +36500,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 +36513,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 +36574,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,42 +36678,33 @@ ${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)));
-    }
-  }
-  function normalizeOptionValue(option, basePath, value) {
-    if (isNullOrUndefined(value))
-      return void 0;
-    if (option.type === "listOrElement" && !isArray(value))
-      return normalizeOptionValue(option.element, basePath, value);
-    else if (option.type === "list" || option.type === "listOrElement") {
-      const listOption = option;
-      if (listOption.element.isFilePath || !isString(listOption.element.type)) {
-        return filter(map(value, (v) => normalizeOptionValue(listOption.element, basePath, v)), (v) => listOption.listPreserveFalsyValues ? true : !!v);
-      }
-      return value;
-    } else if (!isString(option.type)) {
-      return option.type.get(isString(value) ? value.toLowerCase() : value);
+      errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
     }
-    return normalizeNonListOptionValue(option, basePath, value);
   }
   function normalizeNonListOptionValue(option, basePath, value) {
     if (option.isFilePath) {
@@ -36836,29 +36715,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 +36844,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 +36955,8 @@ ${lanes.join("\n")}
     return out;
   }
   function getOptionValueWithEmptyStrings(value, option) {
+    if (value === void 0)
+      return value;
     switch (option.type) {
       case "object":
         return "";
@@ -37090,7 +36971,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 +37002,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 +38508,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 +41255,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 +41450,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 +41458,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 +42919,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 +44987,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 +45815,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 +45825,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 +45845,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 +47731,7 @@ ${lanes.join("\n")}
       return void 0;
     }
     function markExportAsReferenced(node) {
-      if (compilerOptions.verbatimModuleSyntax) {
+      if (!canCollectSymbolAliasAccessabilityData) {
         return;
       }
       const symbol = getSymbolOfDeclaration(node);
@@ -47843,7 +47744,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 +47875,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);
@@ -49723,8 +49627,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 */));
@@ -56128,7 +56035,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));
         }
       }
@@ -58895,31 +58802,21 @@ ${lanes.join("\n")}
       }
       return type;
       function addSpans(texts2, types2) {
-        const isTextsArray = isArray(texts2);
         for (let i = 0; i < types2.length; i++) {
           const t = types2[i];
-          const addText = isTextsArray ? texts2[i + 1] : texts2;
           if (t.flags & (2944 /* Literal */ | 65536 /* Null */ | 32768 /* Undefined */)) {
             text += getTemplateStringForType(t) || "";
-            text += addText;
-            if (!isTextsArray)
-              return true;
+            text += texts2[i + 1];
           } else if (t.flags & 134217728 /* TemplateLiteral */) {
             text += t.texts[0];
             if (!addSpans(t.texts, t.types))
               return false;
-            text += addText;
-            if (!isTextsArray)
-              return true;
+            text += texts2[i + 1];
           } else if (isGenericIndexType(t) || isPatternLiteralPlaceholderType(t)) {
             newTypes.push(t);
             newTexts.push(text);
-            text = addText;
-          } else if (t.flags & 2097152 /* Intersection */) {
-            const added = addSpans(texts2[i + 1], t.types);
-            if (!added)
-              return false;
-          } else if (isTextsArray) {
+            text = texts2[i + 1];
+          } else {
             return false;
           }
         }
@@ -58931,6 +58828,11 @@ ${lanes.join("\n")}
     }
     function createTemplateLiteralType(texts, types) {
       const type = createType(134217728 /* TemplateLiteral */);
+      type.objectFlags = getPropagatingFlagsOfTypes(
+        types,
+        /*excludeKinds*/
+        98304 /* Nullable */
+      );
       type.texts = texts;
       type.types = types;
       return type;
@@ -59230,6 +59132,9 @@ ${lanes.join("\n")}
       return accessNode.kind === 210 /* ElementAccessExpression */ ? accessNode.argumentExpression : accessNode.kind === 197 /* IndexedAccessType */ ? accessNode.indexType : accessNode.kind === 165 /* ComputedPropertyName */ ? accessNode.expression : accessNode;
     }
     function isPatternLiteralPlaceholderType(type) {
+      if (type.flags & 2097152 /* Intersection */) {
+        return some(type.types, (t) => !!(t.flags & (2944 /* Literal */ | 65536 /* Null */ | 32768 /* Undefined */)) || isPatternLiteralPlaceholderType(t));
+      }
       return !!(type.flags & (1 /* Any */ | 4 /* String */ | 8 /* Number */ | 64 /* BigInt */)) || isPatternLiteralType(type);
     }
     function isPatternLiteralType(type) {
@@ -59245,7 +59150,7 @@ ${lanes.join("\n")}
       return !!(getGenericObjectFlags(type) & 8388608 /* IsGenericIndexType */);
     }
     function getGenericObjectFlags(type) {
-      if (type.flags & 3145728 /* UnionOrIntersection */) {
+      if (type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */)) {
         if (!(type.objectFlags & 2097152 /* IsGenericTypeComputed */)) {
           type.objectFlags |= 2097152 /* IsGenericTypeComputed */ | reduceLeft(type.types, (flags, t) => flags | getGenericObjectFlags(t), 0);
         }
@@ -59257,7 +59162,7 @@ ${lanes.join("\n")}
         }
         return type.objectFlags & 12582912 /* IsGenericType */;
       }
-      return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
+      return (type.flags & 58982400 /* InstantiableNonPrimitive */ || isGenericMappedType(type) || isGenericTupleType(type) ? 4194304 /* IsGenericObjectType */ : 0) | (type.flags & (58982400 /* InstantiableNonPrimitive */ | 4194304 /* Index */ | 268435456 /* StringMapping */) && !isPatternLiteralType(type) ? 8388608 /* IsGenericIndexType */ : 0);
     }
     function getSimplifiedType(type, writing) {
       return type.flags & 8388608 /* IndexedAccess */ ? getSimplifiedIndexedAccessType(type, writing) : type.flags & 16777216 /* Conditional */ ? getSimplifiedConditionalType(type, writing) : type;
@@ -60271,6 +60176,9 @@ ${lanes.join("\n")}
         if (!result) {
           const newMapper = createTypeMapper(typeParameters, typeArguments);
           result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments) : target.objectFlags & 32 /* Mapped */ ? instantiateMappedType(target, newMapper, newAliasSymbol, newAliasTypeArguments) : instantiateAnonymousType(target, newMapper, newAliasSymbol, newAliasTypeArguments);
+          if (result.flags & 138117121 /* ObjectFlagsType */ && !(result.objectFlags & 524288 /* CouldContainTypeVariablesComputed */)) {
+            result.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (some(typeArguments, couldContainTypeVariables) ? 1048576 /* CouldContainTypeVariables */ : 0);
+          }
           target.instantiations.set(id, result);
         }
         return result;
@@ -60399,7 +60307,7 @@ ${lanes.join("\n")}
       ) : strictNullChecks && modifiers & 8 /* ExcludeOptional */ && isOptional ? getTypeWithFacts(propType, 524288 /* NEUndefined */) : propType;
     }
     function instantiateAnonymousType(type, mapper, aliasSymbol, aliasTypeArguments) {
-      const result = createObjectType(type.objectFlags | 64 /* Instantiated */, type.symbol);
+      const result = createObjectType(type.objectFlags & ~(524288 /* CouldContainTypeVariablesComputed */ | 1048576 /* CouldContainTypeVariables */) | 64 /* Instantiated */, type.symbol);
       if (type.objectFlags & 32 /* Mapped */) {
         result.declaration = type.declaration;
         const origTypeParameter = getTypeParameterFromMappedType(type);
@@ -60604,7 +60512,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);
@@ -61273,7 +61187,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));
@@ -61539,7 +61458,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;
@@ -61558,6 +61477,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;
@@ -61647,10 +61571,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 || [];
@@ -61742,13 +61666,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);
@@ -63035,7 +62959,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 {
@@ -63918,22 +63842,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 */) {
@@ -64134,7 +64043,7 @@ ${lanes.join("\n")}
           return type.symbol;
         }
         if (isTupleType(type)) {
-          return type.target;
+          return type;
         }
       }
       if (type.flags & 262144 /* TypeParameter */) {
@@ -64907,8 +64816,8 @@ ${lanes.join("\n")}
       if (objectFlags & 524288 /* CouldContainTypeVariablesComputed */) {
         return !!(objectFlags & 1048576 /* CouldContainTypeVariables */);
       }
-      const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || forEach(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & 3145728 /* UnionOrIntersection */ && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
-      if (type.flags & 3899393 /* ObjectFlagsType */) {
+      const result = !!(type.flags & 465829888 /* Instantiable */ || type.flags & 524288 /* Object */ && !isNonGenericTopLevelType(type) && (objectFlags & 4 /* Reference */ && (type.node || some(getTypeArguments(type), couldContainTypeVariables)) || objectFlags & 16 /* Anonymous */ && type.symbol && type.symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 2048 /* TypeLiteral */ | 4096 /* ObjectLiteral */) && type.symbol.declarations || objectFlags & (32 /* Mapped */ | 1024 /* ReverseMapped */ | 4194304 /* ObjectRestType */ | 8388608 /* InstantiationExpressionType */)) || type.flags & (3145728 /* UnionOrIntersection */ | 134217728 /* TemplateLiteral */) && !(type.flags & 1024 /* EnumLiteral */) && !isNonGenericTopLevelType(type) && some(type.types, couldContainTypeVariables));
+      if (type.flags & 138117121 /* ObjectFlagsType */) {
         type.objectFlags |= 524288 /* CouldContainTypeVariablesComputed */ | (result ? 1048576 /* CouldContainTypeVariables */ : 0);
       }
       return result;
@@ -65533,7 +65442,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;
@@ -66006,36 +65919,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;
@@ -67953,7 +67864,7 @@ ${lanes.join("\n")}
       });
     }
     function markAliasReferenced(symbol, location) {
-      if (compilerOptions.verbatimModuleSyntax) {
+      if (!canCollectSymbolAliasAccessabilityData) {
         return;
       }
       if (isNonLocalAlias(
@@ -69091,30 +69002,52 @@ ${lanes.join("\n")}
       }
       return void 0;
     }
-    function getContextualTypeForElementExpression(arrayContextualType, index) {
-      return arrayContextualType && (index >= 0 && getTypeOfPropertyOfContextualType(arrayContextualType, "" + index) || mapType(
-        arrayContextualType,
-        (t) => isTupleType(t) ? getElementTypeOfSliceOfTupleType(
-          t,
-          0,
-          /*endSkipCount*/
-          0,
-          /*writing*/
-          false,
-          /*noReductions*/
-          true
-        ) : getIteratedTypeOrElementType(
-          1 /* Element */,
-          t,
-          undefinedType,
-          /*errorNode*/
-          void 0,
-          /*checkAssignability*/
-          false
-        ),
+    function getSpreadIndices(elements) {
+      let first2, last2;
+      for (let i = 0; i < elements.length; i++) {
+        if (isSpreadElement(elements[i])) {
+          first2 != null ? first2 : first2 = i;
+          last2 = i;
+        }
+      }
+      return { first: first2, last: last2 };
+    }
+    function getContextualTypeForElementExpression(type, index, length2, firstSpreadIndex, lastSpreadIndex) {
+      return type && mapType(
+        type,
+        (t) => {
+          if (isTupleType(t)) {
+            if ((firstSpreadIndex === void 0 || index < firstSpreadIndex) && index < t.target.fixedLength) {
+              return getTypeArguments(t)[index];
+            }
+            const offset = length2 !== void 0 && (lastSpreadIndex === void 0 || index > lastSpreadIndex) ? length2 - index : 0;
+            const fixedEndLength = offset > 0 && t.target.hasRestElement ? getEndElementCount(t.target, 3 /* Fixed */) : 0;
+            if (offset > 0 && offset <= fixedEndLength) {
+              return getTypeArguments(t)[getTypeReferenceArity(t) - offset];
+            }
+            return getElementTypeOfSliceOfTupleType(
+              t,
+              firstSpreadIndex === void 0 ? t.target.fixedLength : Math.min(t.target.fixedLength, firstSpreadIndex),
+              length2 === void 0 || lastSpreadIndex === void 0 ? fixedEndLength : Math.min(fixedEndLength, length2 - lastSpreadIndex),
+              /*writing*/
+              false,
+              /*noReductions*/
+              true
+            );
+          }
+          return (!firstSpreadIndex || index < firstSpreadIndex) && getTypeOfPropertyOfContextualType(t, "" + index) || getIteratedTypeOrElementType(
+            1 /* Element */,
+            t,
+            undefinedType,
+            /*errorNode*/
+            void 0,
+            /*checkAssignability*/
+            false
+          );
+        },
         /*noReductions*/
         true
-      ));
+      );
     }
     function getContextualTypeForConditionalOperand(node, contextFlags) {
       const conditional = node.parent;
@@ -69223,7 +69156,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
         );
@@ -69301,9 +69238,9 @@ ${lanes.join("\n")}
         case 207 /* ArrayLiteralExpression */: {
           const arrayLiteral = parent2;
           const type = getApparentTypeOfContextualType(arrayLiteral, contextFlags);
-          const spreadIndex = (_b = (_a2 = getNodeLinks(arrayLiteral)).firstSpreadIndex) != null ? _b : _a2.firstSpreadIndex = findIndex(arrayLiteral.elements, isSpreadElement);
           const elementIndex = indexOfNode(arrayLiteral.elements, node);
-          return getContextualTypeForElementExpression(type, spreadIndex < 0 || elementIndex < spreadIndex ? elementIndex : -1);
+          const spreadIndices = (_b = (_a2 = getNodeLinks(arrayLiteral)).spreadIndices) != null ? _b : _a2.spreadIndices = getSpreadIndices(arrayLiteral.elements);
+          return getContextualTypeForElementExpression(type, elementIndex, arrayLiteral.elements.length, spreadIndices.first, spreadIndices.last);
         }
         case 225 /* ConditionalExpression */:
           return getContextualTypeForConditionalOperand(node, contextFlags);
@@ -70488,7 +70425,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);
           }
         }
@@ -71715,7 +71652,7 @@ ${lanes.join("\n")}
             flags.push(4 /* Rest */);
           }
         } else {
-          const contextualType = getIndexedAccessType(restType, getNumberLiteralType(i - index), 256 /* Contextual */);
+          const contextualType = isTupleType(restType) ? getContextualTypeForElementExpression(restType, i - index, argCount - index) || unknownType : getIndexedAccessType(restType, getNumberLiteralType(i - index), 256 /* Contextual */);
           const argType = checkExpressionWithContextualType(arg, contextualType, context, checkMode);
           const hasPrimitiveContextualType = inConstContext || maybeTypeOfKind(contextualType, 402784252 /* Primitive */ | 4194304 /* Index */ | 134217728 /* TemplateLiteral */ | 268435456 /* StringMapping */);
           types.push(hasPrimitiveContextualType ? getRegularTypeOfLiteralType(argType) : getWidenedLiteralType(argType));
@@ -72062,16 +71999,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);
       }
@@ -72159,11 +72096,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;
@@ -73768,12 +73702,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 = [];
@@ -73791,13 +73725,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;
@@ -77503,9 +77431,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)) {
@@ -77568,8 +77496,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) {
@@ -77625,11 +77553,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;
       }
@@ -77647,7 +77575,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();
@@ -77671,7 +77599,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;
@@ -77685,7 +77613,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;
@@ -77863,7 +77791,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);
@@ -78272,9 +78200,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));
@@ -79832,7 +79759,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));
                 }
               });
             }
@@ -81428,6 +81355,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(
@@ -81513,14 +81443,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,
@@ -82857,7 +82787,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));
@@ -82898,7 +82828,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);
@@ -83236,12 +83166,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);
@@ -84376,7 +84306,7 @@ ${lanes.join("\n")}
             throw Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind);
         }
         if (!inDestructuring) {
-          const effectiveName = getPropertyNameForPropertyNameNode(name);
+          const effectiveName = getEffectivePropertyNameForPropertyNameNode(name);
           if (effectiveName === void 0) {
             continue;
           }
@@ -84845,12 +84775,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;
       }
@@ -84858,35 +84788,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;
@@ -85031,7 +84961,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);
@@ -85041,9 +84971,7 @@ ${lanes.join("\n")}
           /*length*/
           0,
           message,
-          arg0,
-          arg1,
-          arg2
+          ...args
         ));
         return true;
       }
@@ -85189,6 +85117,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);
@@ -109853,8 +109785,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);
@@ -109899,10 +109830,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;
   }
@@ -113912,12 +113843,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) {
@@ -114036,7 +113967,7 @@ ${lanes.join("\n")}
     function makeFileLevelOptimisticUniqueName(name) {
       return makeUniqueName2(
         name,
-        isFileLevelUniqueName2,
+        isFileLevelUniqueNameInCurrentFile,
         /*optimistic*/
         true,
         /*scoped*/
@@ -114216,7 +114147,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),
@@ -115234,7 +115165,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";
@@ -117234,12 +117164,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);
         }
       });
     }
@@ -117904,11 +117834,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
           });
         }
       });
@@ -118373,7 +118304,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*/
@@ -118381,7 +118312,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,
@@ -118398,10 +118329,7 @@ ${lanes.join("\n")}
             /*option2*/
             void 0,
             message,
-            arg0,
-            arg1,
-            arg2,
-            arg3
+            ...args
           );
         }
       }
@@ -118454,8 +118382,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) {
@@ -118637,7 +118565,7 @@ ${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) {
@@ -118645,17 +118573,17 @@ ${lanes.join("\n")}
           for (const keyProps of getPropertyAssignment(pathProp.initializer, key)) {
             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) {
@@ -118666,13 +118594,13 @@ ${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) {
@@ -118702,7 +118630,7 @@ ${lanes.join("\n")}
         option3
       );
     }
-    function createOptionValueDiagnostic(option1, message, arg0, arg1) {
+    function createOptionValueDiagnostic(option1, message, ...args) {
       createDiagnosticForOption(
         /*onKey*/
         false,
@@ -118710,29 +118638,28 @@ ${lanes.join("\n")}
         /*option2*/
         void 0,
         message,
-        arg0,
-        arg1
+        ...args
       );
     }
-    function createDiagnosticForReference(sourceFile, index, message, arg0, arg1, arg2, arg3) {
+    function createDiagnosticForReference(sourceFile, index, message, ...args) {
       const referencesSyntax = firstDefined(
         getTsConfigPropArray(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));
         }
       }
     }
@@ -118751,13 +118678,13 @@ ${lanes.join("\n")}
       }
       return _compilerOptionsObjectLiteralSyntax || void 0;
     }
-    function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, arg0, arg1, arg2, arg3) {
+    function createOptionDiagnosticInObjectLiteralSyntax(objectLiteral, onKey, key1, key2, message, ...args) {
       const props = getPropertyAssignment(objectLiteral, key1, key2);
       for (const prop of props) {
         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;
@@ -119095,7 +119022,6 @@ ${lanes.join("\n")}
     "src/compiler/program.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
       init_ts_performance();
       ForegroundColorEscapeSequences = /* @__PURE__ */ ((ForegroundColorEscapeSequences2) => {
         ForegroundColorEscapeSequences2["Grey"] = "\x1B[90m";
@@ -119810,16 +119736,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);
     }
@@ -120722,7 +120648,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)) {
@@ -120803,7 +120729,7 @@ ${lanes.join("\n")}
       close: noop,
       hasChangedEmitSignature: returnFalse
     };
-    function toPath3(path) {
+    function toPathInBuildInfoDirectory(path) {
       return toPath(path, buildInfoDirectory, getCanonicalFileName);
     }
     function toAbsolutePath(path) {
@@ -120885,7 +120811,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";
@@ -121765,7 +121690,6 @@ ${lanes.join("\n")}
     "src/compiler/resolutionCache.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
     }
   });
 
@@ -121878,15 +121802,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}`;
   }
@@ -122096,15 +122018,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*/
@@ -122113,12 +122035,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);
     }
@@ -123160,7 +123083,6 @@ ${lanes.join("\n")}
     "src/compiler/watchPublic.ts"() {
       "use strict";
       init_ts2();
-      init_ts2();
     }
   });
 
@@ -125180,7 +125102,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);
@@ -127256,9 +127177,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;
   }
@@ -131735,7 +131653,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+\/=]+)$)?/;
     }
   });
@@ -132965,6 +132882,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);
@@ -133731,7 +133883,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);
       }
@@ -133742,7 +133894,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) {
@@ -134402,9 +134554,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) {
@@ -137006,241 +137159,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, {
@@ -170349,7 +170267,7 @@ ${options.prefix}` : "\n" : options.prefix
               serverHost: this.projectService.host,
               session: this.projectService.session
             };
-            const pluginModule = pluginModuleFactory({ typescript: ts_exports3 });
+            const pluginModule = pluginModuleFactory({ typescript: ts_exports2 });
             const newLS = pluginModule.create(info);
             for (const k of Object.keys(this.languageService)) {
               if (!(k in newLS)) {
@@ -178681,8 +178599,8 @@ ${e.message}`;
   });
 
   // src/server/_namespaces/ts.ts
-  var ts_exports3 = {};
-  __export(ts_exports3, {
+  var ts_exports2 = {};
+  __export(ts_exports2, {
     ANONYMOUS: () => ANONYMOUS,
     AccessFlags: () => AccessFlags,
     AssertionLevel: () => AssertionLevel,
@@ -178985,8 +178903,8 @@ ${e.message}`;
     convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
     convertJsonOption: () => convertJsonOption,
     convertToBase64: () => convertToBase64,
+    convertToJson: () => convertToJson,
     convertToObject: () => convertToObject,
-    convertToObjectWorker: () => convertToObjectWorker,
     convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
     convertToRelativePath: () => convertToRelativePath,
     convertToTSConfig: () => convertToTSConfig,
@@ -180132,6 +180050,7 @@ ${e.message}`;
     isJsxText: () => isJsxText,
     isJumpStatementTarget: () => isJumpStatementTarget,
     isKeyword: () => isKeyword,
+    isKeywordOrPunctuation: () => isKeywordOrPunctuation,
     isKnownSymbol: () => isKnownSymbol,
     isLabelName: () => isLabelName,
     isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
@@ -181039,8 +180958,8 @@ ${e.message}`;
   });
 
   // src/tsserverlibrary/_namespaces/ts.ts
-  var ts_exports4 = {};
-  __export(ts_exports4, {
+  var ts_exports3 = {};
+  __export(ts_exports3, {
     ANONYMOUS: () => ANONYMOUS,
     AccessFlags: () => AccessFlags,
     AssertionLevel: () => AssertionLevel,
@@ -181343,8 +181262,8 @@ ${e.message}`;
     convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
     convertJsonOption: () => convertJsonOption,
     convertToBase64: () => convertToBase64,
+    convertToJson: () => convertToJson,
     convertToObject: () => convertToObject,
-    convertToObjectWorker: () => convertToObjectWorker,
     convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
     convertToRelativePath: () => convertToRelativePath,
     convertToTSConfig: () => convertToTSConfig,
@@ -182490,6 +182409,7 @@ ${e.message}`;
     isJsxText: () => isJsxText,
     isJumpStatementTarget: () => isJumpStatementTarget,
     isKeyword: () => isKeyword,
+    isKeywordOrPunctuation: () => isKeywordOrPunctuation,
     isKnownSymbol: () => isKnownSymbol,
     isLabelName: () => isLabelName,
     isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
@@ -183301,7 +183221,7 @@ ${e.message}`;
   var require_tsserverlibrary = __commonJS({
     "src/tsserverlibrary/tsserverlibrary.ts"(exports, module2) {
       init_ts7();
-      module2.exports = ts_exports4;
+      module2.exports = ts_exports3;
     }
   });
   return require_tsserverlibrary();