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

package/lib/tsserver.js

@@ -338,8 +338,8 @@ __export(server_exports, {
   convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
   convertJsonOption: () => convertJsonOption,
   convertToBase64: () => convertToBase64,
+  convertToJson: () => convertToJson,
   convertToObject: () => convertToObject,
-  convertToObjectWorker: () => convertToObjectWorker,
   convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
   convertToRelativePath: () => convertToRelativePath,
   convertToTSConfig: () => convertToTSConfig,
@@ -1485,6 +1485,7 @@ __export(server_exports, {
   isJsxText: () => isJsxText,
   isJumpStatementTarget: () => isJumpStatementTarget,
   isKeyword: () => isKeyword,
+  isKeywordOrPunctuation: () => isKeywordOrPunctuation,
   isKnownSymbol: () => isKnownSymbol,
   isLabelName: () => isLabelName,
   isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
@@ -2285,7 +2286,7 @@ module.exports = __toCommonJS(server_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.1";
-var version = `${versionMajorMinor}.0-dev.20230319`;
+var version = `${versionMajorMinor}.0-dev.20230321`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6632,7 +6633,7 @@ var TypeFlags = /* @__PURE__ */ ((TypeFlags2) => {
   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";
@@ -10565,13 +10566,14 @@ var Diagnostics = {
   Output_Formatting: diag(6256, 3 /* Message */, "Output_Formatting_6256", "Output Formatting"),
   Completeness: diag(6257, 3 /* Message */, "Completeness_6257", "Completeness"),
   _0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file: diag(6258, 1 /* Error */, "_0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file_6258", "'{0}' should be set inside the 'compilerOptions' object of the config json file"),
-  Found_1_error_in_1: diag(6259, 3 /* Message */, "Found_1_error_in_1_6259", "Found 1 error in {1}"),
+  Found_1_error_in_0: diag(6259, 3 /* Message */, "Found_1_error_in_0_6259", "Found 1 error in {0}"),
   Found_0_errors_in_the_same_file_starting_at_Colon_1: diag(6260, 3 /* Message */, "Found_0_errors_in_the_same_file_starting_at_Colon_1_6260", "Found {0} errors in the same file, starting at: {1}"),
   Found_0_errors_in_1_files: diag(6261, 3 /* Message */, "Found_0_errors_in_1_files_6261", "Found {0} errors in {1} files."),
   File_name_0_has_a_1_extension_looking_up_2_instead: diag(6262, 3 /* Message */, "File_name_0_has_a_1_extension_looking_up_2_instead_6262", "File name '{0}' has a '{1}' extension - looking up '{2}' instead."),
   Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set: diag(6263, 1 /* Error */, "Module_0_was_resolved_to_1_but_allowArbitraryExtensions_is_not_set_6263", "Module '{0}' was resolved to '{1}', but '--allowArbitraryExtensions' is not set."),
   Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present: diag(6264, 3 /* Message */, "Enable_importing_files_with_any_extension_provided_a_declaration_file_is_present_6264", "Enable importing files with any extension, provided a declaration file is present."),
   Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_node_modules_folder: diag(6265, 3 /* Message */, "Resolving_type_reference_directive_for_program_that_specifies_custom_typeRoots_skipping_lookup_in_no_6265", "Resolving type reference directive for program that specifies custom typeRoots, skipping lookup in 'node_modules' folder."),
+  Option_0_can_only_be_specified_on_command_line: diag(6266, 1 /* Error */, "Option_0_can_only_be_specified_on_command_line_6266", "Option '{0}' can only be specified on command line."),
   Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve: diag(6270, 3 /* Message */, "Directory_0_has_no_containing_package_json_scope_Imports_will_not_resolve_6270", "Directory '{0}' has no containing package.json scope. Imports will not resolve."),
   Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1: diag(6271, 3 /* Message */, "Import_specifier_0_does_not_exist_in_package_json_scope_at_path_1_6271", "Import specifier '{0}' does not exist in package.json scope at path '{1}'."),
   Invalid_import_specifier_0_has_no_possible_resolutions: diag(6272, 3 /* Message */, "Invalid_import_specifier_0_has_no_possible_resolutions_6272", "Invalid import specifier '{0}' has no possible resolutions."),
@@ -16031,17 +16033,17 @@ function entityNameToString(name) {
       return Debug.assertNever(name);
   }
 }
-function createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3) {
+function createDiagnosticForNode(node, message, ...args) {
   const sourceFile = getSourceFileOfNode(node);
-  return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3);
+  return createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args);
 }
-function createDiagnosticForNodeArray(sourceFile, nodes, message, arg0, arg1, arg2, arg3) {
+function createDiagnosticForNodeArray(sourceFile, nodes, message, ...args) {
   const start2 = skipTrivia(sourceFile.text, nodes.pos);
-  return createFileDiagnostic(sourceFile, start2, nodes.end - start2, message, arg0, arg1, arg2, arg3);
+  return createFileDiagnostic(sourceFile, start2, nodes.end - start2, message, ...args);
 }
-function createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2, arg3) {
+function createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args) {
   const span = getErrorSpanForNode(sourceFile, node);
-  return createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2, arg3);
+  return createFileDiagnostic(sourceFile, span.start, span.length, message, ...args);
 }
 function createDiagnosticForNodeFromMessageChain(sourceFile, node, messageChain, relatedInformation) {
   const span = getErrorSpanForNode(sourceFile, node);
@@ -17867,6 +17869,12 @@ function getAncestor(node, kind) {
 function isKeyword(token) {
   return 82 /* FirstKeyword */ <= token && token <= 163 /* LastKeyword */;
 }
+function isPunctuation(token) {
+  return 18 /* FirstPunctuation */ <= token && token <= 78 /* LastPunctuation */;
+}
+function isKeywordOrPunctuation(token) {
+  return isKeyword(token) || isPunctuation(token);
+}
 function isContextualKeyword(token) {
   return 127 /* FirstContextualKeyword */ <= token && token <= 163 /* LastContextualKeyword */;
 }
@@ -19713,7 +19721,7 @@ function getClassLikeDeclarationOfSymbol(symbol) {
   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);
@@ -30421,14 +30429,12 @@ var Parser;
     scriptKind2 = ensureScriptKind(fileName2, scriptKind2);
     if (scriptKind2 === 6 /* JSON */) {
       const result2 = parseJsonText2(fileName2, sourceText2, languageVersion2, syntaxCursor2, setParentNodes);
-      convertToObjectWorker(
+      convertToJson(
         result2,
         (_a2 = result2.statements[0]) == null ? void 0 : _a2.expression,
         result2.parseDiagnostics,
         /*returnValue*/
         false,
-        /*knownRootOptions*/
-        void 0,
         /*jsonConversionNotifier*/
         void 0
       );
@@ -30860,24 +30866,24 @@ var Parser;
   function inAwaitContext() {
     return inContext(32768 /* AwaitContext */);
   }
-  function parseErrorAtCurrentToken(message, arg0) {
-    return parseErrorAt(scanner2.getTokenStart(), scanner2.getTokenEnd(), message, arg0);
+  function parseErrorAtCurrentToken(message, ...args) {
+    return parseErrorAt(scanner2.getTokenStart(), scanner2.getTokenEnd(), message, ...args);
   }
-  function parseErrorAtPosition(start2, length2, message, arg0) {
+  function parseErrorAtPosition(start2, length2, message, ...args) {
     const lastError = lastOrUndefined(parseDiagnostics);
     let result;
     if (!lastError || start2 !== lastError.start) {
-      result = createDetachedDiagnostic(fileName, start2, length2, message, arg0);
+      result = createDetachedDiagnostic(fileName, start2, length2, message, ...args);
       parseDiagnostics.push(result);
     }
     parseErrorBeforeNextFinishedNode = true;
     return result;
   }
-  function parseErrorAt(start2, end, message, arg0) {
-    return parseErrorAtPosition(start2, end - start2, message, arg0);
+  function parseErrorAt(start2, end, message, ...args) {
+    return parseErrorAtPosition(start2, end - start2, message, ...args);
   }
-  function parseErrorAtRange(range, message, arg0) {
-    parseErrorAt(range.pos, range.end, message, arg0);
+  function parseErrorAtRange(range, message, ...args) {
+    parseErrorAt(range.pos, range.end, message, ...args);
   }
   function scanError(message, length2) {
     parseErrorAtPosition(scanner2.getTokenEnd(), length2, message);
@@ -31083,6 +31089,7 @@ var Parser;
       nextTokenJSDoc();
       return true;
     }
+    Debug.assert(isKeywordOrPunctuation(kind));
     parseErrorAtCurrentToken(Diagnostics._0_expected, tokenToString(kind));
     return false;
   }
@@ -31131,7 +31138,11 @@ var Parser;
     );
   }
   function parseExpectedTokenJSDoc(t) {
-    return parseOptionalTokenJSDoc(t) || createMissingNode(
+    const optional = parseOptionalTokenJSDoc(t);
+    if (optional)
+      return optional;
+    Debug.assert(isKeywordOrPunctuation(t));
+    return createMissingNode(
       t,
       /*reportAtCurrentPosition*/
       false,
@@ -31185,11 +31196,11 @@ var Parser;
     }
     return node;
   }
-  function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, arg0) {
+  function createMissingNode(kind, reportAtCurrentPosition, diagnosticMessage, ...args) {
     if (reportAtCurrentPosition) {
-      parseErrorAtPosition(scanner2.getTokenFullStart(), 0, diagnosticMessage, arg0);
+      parseErrorAtPosition(scanner2.getTokenFullStart(), 0, diagnosticMessage, ...args);
     } else if (diagnosticMessage) {
-      parseErrorAtCurrentToken(diagnosticMessage, arg0);
+      parseErrorAtCurrentToken(diagnosticMessage, ...args);
     }
     const pos = getNodePos();
     const result = kind === 79 /* Identifier */ ? factoryCreateIdentifier(
@@ -33548,6 +33559,7 @@ var Parser;
       if (simpleUnaryExpression.kind === 214 /* TypeAssertionExpression */) {
         parseErrorAt(pos, end, Diagnostics.A_type_assertion_expression_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses);
       } else {
+        Debug.assert(isKeywordOrPunctuation(unaryOperator));
         parseErrorAt(pos, end, Diagnostics.An_unary_expression_with_the_0_operator_is_not_allowed_in_the_left_hand_side_of_an_exponentiation_expression_Consider_enclosing_the_expression_in_parentheses, tokenToString(unaryOperator));
       }
     }
@@ -36495,14 +36507,14 @@ var Parser;
       }
       function parseReturnTag(start3, tagName, indent3, indentText) {
         if (some(tags, isJSDocReturnTag)) {
-          parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, tagName.escapedText);
+          parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
         }
         const typeExpression = tryParseTypeExpression();
         return finishNode(factory2.createJSDocReturnTag(tagName, typeExpression, parseTrailingTagComments(start3, getNodePos(), indent3, indentText)), start3);
       }
       function parseTypeTag(start3, tagName, indent3, indentText) {
         if (some(tags, isJSDocTypeTag)) {
-          parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, tagName.escapedText);
+          parseErrorAt(tagName.pos, scanner2.getTokenStart(), Diagnostics._0_tag_already_specified, unescapeLeadingUnderscores(tagName.escapedText));
         }
         const typeExpression = parseJSDocTypeExpression(
           /*mayOmitBraces*/
@@ -38987,13 +38999,13 @@ function parseListTypeOption(opt, value = "", errors) {
 function getOptionName(option) {
   return option.name;
 }
-function createUnknownOptionError(unknownOption, diagnostics, createDiagnostics, unknownOptionErrorText) {
+function createUnknownOptionError(unknownOption, diagnostics, unknownOptionErrorText, node, sourceFile) {
   var _a2;
   if ((_a2 = diagnostics.alternateMode) == null ? void 0 : _a2.getOptionsNameMap().optionsNameMap.has(unknownOption.toLowerCase())) {
-    return createDiagnostics(diagnostics.alternateMode.diagnostic, unknownOption);
+    return createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.alternateMode.diagnostic, unknownOption);
   }
   const possibleOption = getSpellingSuggestion(unknownOption, diagnostics.optionDeclarations, getOptionName);
-  return possibleOption ? createDiagnostics(diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnostics(diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
+  return possibleOption ? createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownDidYouMeanDiagnostic, unknownOptionErrorText || unknownOption, possibleOption.name) : createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, diagnostics.unknownOptionDiagnostic, unknownOptionErrorText || unknownOption);
 }
 function parseCommandLineWorker(diagnostics, commandLine, readFile) {
   const options = {};
@@ -39034,7 +39046,7 @@ function parseCommandLineWorker(diagnostics, commandLine, readFile) {
           if (watchOpt) {
             i = parseOptionValue(args, i, watchOptionsDidYouMeanDiagnostics, watchOpt, watchOptions || (watchOptions = {}), errors);
           } else {
-            errors.push(createUnknownOptionError(inputOptionName, diagnostics, createCompilerDiagnostic, s));
+            errors.push(createUnknownOptionError(inputOptionName, diagnostics, s));
           }
         }
       } else {
@@ -39245,9 +39257,7 @@ function parseConfigFileTextToJson(fileName, jsonText) {
     config: convertConfigFileToObject(
       jsonSourceFile,
       jsonSourceFile.parseDiagnostics,
-      /*reportOptionsErrors*/
-      false,
-      /*optionsIterator*/
+      /*jsonConversionNotifier*/
       void 0
     ),
     error: jsonSourceFile.parseDiagnostics.length ? jsonSourceFile.parseDiagnostics[0] : void 0
@@ -39304,7 +39314,26 @@ var extendsOptionDeclaration = {
     name: "extends",
     type: "string"
   },
-  category: Diagnostics.File_Management
+  category: Diagnostics.File_Management,
+  disallowNullOrUndefined: true
+};
+var compilerOptionsDeclaration = {
+  name: "compilerOptions",
+  type: "object",
+  elementOptions: getCommandLineCompilerOptionsMap(),
+  extraKeyDiagnostics: compilerOptionsDidYouMeanDiagnostics
+};
+var watchOptionsDeclaration = {
+  name: "watchOptions",
+  type: "object",
+  elementOptions: getCommandLineWatchOptionsMap(),
+  extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics
+};
+var typeAcquisitionDeclaration = {
+  name: "typeAcquisition",
+  type: "object",
+  elementOptions: getCommandLineTypeAcquisitionMap(),
+  extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
 };
 var _tsconfigRootOptions;
 function getTsconfigRootOptionsMap() {
@@ -39314,24 +39343,9 @@ function getTsconfigRootOptionsMap() {
       // should never be needed since this is root
       type: "object",
       elementOptions: commandLineOptionsToMap([
-        {
-          name: "compilerOptions",
-          type: "object",
-          elementOptions: getCommandLineCompilerOptionsMap(),
-          extraKeyDiagnostics: compilerOptionsDidYouMeanDiagnostics
-        },
-        {
-          name: "watchOptions",
-          type: "object",
-          elementOptions: getCommandLineWatchOptionsMap(),
-          extraKeyDiagnostics: watchOptionsDidYouMeanDiagnostics
-        },
-        {
-          name: "typeAcquisition",
-          type: "object",
-          elementOptions: getCommandLineTypeAcquisitionMap(),
-          extraKeyDiagnostics: typeAcquisitionDidYouMeanDiagnostics
-        },
+        compilerOptionsDeclaration,
+        watchOptionsDeclaration,
+        typeAcquisitionDeclaration,
         extendsOptionDeclaration,
         {
           name: "references",
@@ -39377,10 +39391,9 @@ function getTsconfigRootOptionsMap() {
   }
   return _tsconfigRootOptions;
 }
-function convertConfigFileToObject(sourceFile, errors, reportOptionsErrors, optionsIterator) {
+function convertConfigFileToObject(sourceFile, errors, jsonConversionNotifier) {
   var _a2;
   const rootExpression = (_a2 = sourceFile.statements[0]) == null ? void 0 : _a2.expression;
-  const knownRootOptions = reportOptionsErrors ? getTsconfigRootOptionsMap() : void 0;
   if (rootExpression && rootExpression.kind !== 208 /* ObjectLiteralExpression */) {
     errors.push(createDiagnosticForNodeInSourceFile(
       sourceFile,
@@ -39391,52 +39404,46 @@ function convertConfigFileToObject(sourceFile, errors, reportOptionsErrors, opti
     if (isArrayLiteralExpression(rootExpression)) {
       const firstObject = find(rootExpression.elements, isObjectLiteralExpression);
       if (firstObject) {
-        return convertToObjectWorker(
+        return convertToJson(
           sourceFile,
           firstObject,
           errors,
           /*returnValue*/
           true,
-          knownRootOptions,
-          optionsIterator
+          jsonConversionNotifier
         );
       }
     }
     return {};
   }
-  return convertToObjectWorker(
+  return convertToJson(
     sourceFile,
     rootExpression,
     errors,
     /*returnValue*/
     true,
-    knownRootOptions,
-    optionsIterator
+    jsonConversionNotifier
   );
 }
 function convertToObject(sourceFile, errors) {
   var _a2;
-  return convertToObjectWorker(
+  return convertToJson(
     sourceFile,
     (_a2 = sourceFile.statements[0]) == null ? void 0 : _a2.expression,
     errors,
     /*returnValue*/
     true,
-    /*knownRootOptions*/
-    void 0,
     /*jsonConversionNotifier*/
     void 0
   );
 }
-function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue, knownRootOptions, jsonConversionNotifier) {
+function convertToJson(sourceFile, rootExpression, errors, returnValue, jsonConversionNotifier) {
   if (!rootExpression) {
     return returnValue ? {} : void 0;
   }
-  return convertPropertyValueToJson(rootExpression, knownRootOptions);
-  function isRootOptionMap(knownOptions) {
-    return knownRootOptions && knownRootOptions.elementOptions === knownOptions;
-  }
-  function convertObjectLiteralExpressionToJson(node, knownOptions, extraKeyDiagnostics, parentOption) {
+  return convertPropertyValueToJson(rootExpression, jsonConversionNotifier == null ? void 0 : jsonConversionNotifier.rootOptions);
+  function convertObjectLiteralExpressionToJson(node, objectOption) {
+    var _a2;
     const result = returnValue ? {} : void 0;
     for (const element of node.properties) {
       if (element.kind !== 300 /* PropertyAssignment */) {
@@ -39451,38 +39458,13 @@ function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue,
       }
       const textOfKey = isComputedNonLiteralName(element.name) ? void 0 : getTextOfPropertyName(element.name);
       const keyText = textOfKey && unescapeLeadingUnderscores(textOfKey);
-      const option = keyText && knownOptions ? knownOptions.get(keyText) : void 0;
-      if (keyText && extraKeyDiagnostics && !option) {
-        if (knownOptions) {
-          errors.push(createUnknownOptionError(
-            keyText,
-            extraKeyDiagnostics,
-            (message, arg0, arg1) => createDiagnosticForNodeInSourceFile(sourceFile, element.name, message, arg0, arg1)
-          ));
-        } else {
-          errors.push(createDiagnosticForNodeInSourceFile(sourceFile, element.name, extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
-        }
-      }
+      const option = keyText ? (_a2 = objectOption == null ? void 0 : objectOption.elementOptions) == null ? void 0 : _a2.get(keyText) : void 0;
       const value = convertPropertyValueToJson(element.initializer, option);
       if (typeof keyText !== "undefined") {
         if (returnValue) {
           result[keyText] = value;
         }
-        if (jsonConversionNotifier && // Current callbacks are only on known parent option or if we are setting values in the root
-        (parentOption || isRootOptionMap(knownOptions))) {
-          const isValidOptionValue = isCompilerOptionsValue(option, value);
-          if (parentOption) {
-            if (isValidOptionValue) {
-              jsonConversionNotifier.onSetValidOptionKeyValueInParent(parentOption, option, value);
-            }
-          } else if (isRootOptionMap(knownOptions)) {
-            if (isValidOptionValue) {
-              jsonConversionNotifier.onSetValidOptionKeyValueInRoot(keyText, element.name, value, element.initializer);
-            } else if (!option) {
-              jsonConversionNotifier.onSetUnknownOptionKeyValueInRoot(keyText, element.name, value, element.initializer);
-            }
-          }
-        }
+        jsonConversionNotifier == null ? void 0 : jsonConversionNotifier.onPropertySet(keyText, value, element, objectOption, option);
       }
     }
     return result;
@@ -39495,112 +39477,40 @@ function convertToObjectWorker(sourceFile, rootExpression, errors, returnValue,
     return filter(elements.map((element) => convertPropertyValueToJson(element, elementOption)), (v) => v !== void 0);
   }
   function convertPropertyValueToJson(valueExpression, option) {
-    let invalidReported;
     switch (valueExpression.kind) {
       case 111 /* TrueKeyword */:
-        reportInvalidOptionValue(option && option.type !== "boolean" && (option.type !== "listOrElement" || option.element.type !== "boolean"));
-        return validateValue(
-          /*value*/
-          true
-        );
+        return true;
       case 96 /* FalseKeyword */:
-        reportInvalidOptionValue(option && option.type !== "boolean" && (option.type !== "listOrElement" || option.element.type !== "boolean"));
-        return validateValue(
-          /*value*/
-          false
-        );
+        return false;
       case 105 /* NullKeyword */:
-        reportInvalidOptionValue(option && option.name === "extends");
-        return validateValue(
-          /*value*/
-          null
-        );
+        return null;
       case 10 /* StringLiteral */:
         if (!isDoubleQuotedString(valueExpression)) {
           errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected));
         }
-        reportInvalidOptionValue(option && isString(option.type) && option.type !== "string" && (option.type !== "listOrElement" || isString(option.element.type) && option.element.type !== "string"));
-        const text = valueExpression.text;
-        if (option) {
-          Debug.assert(option.type !== "listOrElement" || option.element.type === "string", "Only string or array of string is handled for now");
-        }
-        if (option && !isString(option.type)) {
-          const customOption = option;
-          if (!customOption.type.has(text.toLowerCase())) {
-            errors.push(
-              createDiagnosticForInvalidCustomType(
-                customOption,
-                (message, arg0, arg1) => createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, message, arg0, arg1)
-              )
-            );
-            invalidReported = true;
-          }
-        }
-        return validateValue(text);
+        return valueExpression.text;
       case 8 /* NumericLiteral */:
-        reportInvalidOptionValue(option && option.type !== "number" && (option.type !== "listOrElement" || option.element.type !== "number"));
-        return validateValue(Number(valueExpression.text));
+        return Number(valueExpression.text);
       case 222 /* PrefixUnaryExpression */:
         if (valueExpression.operator !== 40 /* MinusToken */ || valueExpression.operand.kind !== 8 /* NumericLiteral */) {
           break;
         }
-        reportInvalidOptionValue(option && option.type !== "number" && (option.type !== "listOrElement" || option.element.type !== "number"));
-        return validateValue(-Number(valueExpression.operand.text));
+        return -Number(valueExpression.operand.text);
       case 208 /* ObjectLiteralExpression */:
-        reportInvalidOptionValue(option && option.type !== "object" && (option.type !== "listOrElement" || option.element.type !== "object"));
         const objectLiteralExpression = valueExpression;
-        if (option) {
-          const { elementOptions, extraKeyDiagnostics, name: optionName } = option;
-          return validateValue(convertObjectLiteralExpressionToJson(
-            objectLiteralExpression,
-            elementOptions,
-            extraKeyDiagnostics,
-            optionName
-          ));
-        } else {
-          return validateValue(convertObjectLiteralExpressionToJson(
-            objectLiteralExpression,
-            /* knownOptions*/
-            void 0,
-            /*extraKeyDiagnosticMessage */
-            void 0,
-            /*parentOption*/
-            void 0
-          ));
-        }
+        return convertObjectLiteralExpressionToJson(objectLiteralExpression, option);
       case 207 /* ArrayLiteralExpression */:
-        reportInvalidOptionValue(option && option.type !== "list" && option.type !== "listOrElement");
-        return validateValue(convertArrayLiteralExpressionToJson(
+        return convertArrayLiteralExpressionToJson(
           valueExpression.elements,
           option && option.element
-        ));
+        );
     }
     if (option) {
-      reportInvalidOptionValue(
-        /*isError*/
-        true
-      );
+      errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
     } else {
       errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Property_value_can_only_be_string_literal_numeric_literal_true_false_null_object_literal_or_array_literal));
     }
     return void 0;
-    function validateValue(value) {
-      var _a2;
-      if (!invalidReported) {
-        const diagnostic = (_a2 = option == null ? void 0 : option.extraValidation) == null ? void 0 : _a2.call(option, value);
-        if (diagnostic) {
-          errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, ...diagnostic));
-          return void 0;
-        }
-      }
-      return value;
-    }
-    function reportInvalidOptionValue(isError) {
-      if (isError) {
-        errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, option.name, getCompilerOptionValueTypeString(option)));
-        invalidReported = true;
-      }
-    }
   }
   function isDoubleQuotedString(node) {
     return isStringLiteral(node) && isStringDoubleQuoted(node, sourceFile);
@@ -39612,7 +39522,7 @@ function getCompilerOptionValueTypeString(option) {
 function isCompilerOptionsValue(option, value) {
   if (option) {
     if (isNullOrUndefined(value))
-      return true;
+      return !option.disallowNullOrUndefined;
     if (option.type === "list") {
       return isArray(value);
     }
@@ -39973,7 +39883,7 @@ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, exis
           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");
@@ -40075,9 +39985,9 @@ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, exis
     }
     return "no-prop";
   }
-  function createCompilerDiagnosticOnlyIfJson(message, arg0, arg1) {
+  function createCompilerDiagnosticOnlyIfJson(message, ...args) {
     if (!sourceFile) {
-      errors.push(createCompilerDiagnostic(message, arg0, arg1));
+      errors.push(createCompilerDiagnostic(message, ...args));
     }
   }
 }
@@ -40176,27 +40086,42 @@ function parseOwnConfigOfJson(json, host, basePath, configFileName, errors) {
   const typeAcquisition = convertTypeAcquisitionFromJsonWorker(json.typeAcquisition, basePath, errors, configFileName);
   const watchOptions = convertWatchOptionsFromJsonWorker(json.watchOptions, basePath, errors);
   json.compileOnSave = convertCompileOnSaveOptionFromJson(json, basePath, errors);
+  const extendedConfigPath = json.extends || json.extends === "" ? getExtendsConfigPathOrArray(json.extends, host, basePath, configFileName, errors) : void 0;
+  return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
+}
+function getExtendsConfigPathOrArray(value, host, basePath, configFileName, errors, propertyAssignment, valueExpression, sourceFile) {
   let extendedConfigPath;
-  if (json.extends || json.extends === "") {
-    if (!isCompilerOptionsValue(extendsOptionDeclaration, json.extends)) {
-      errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", getCompilerOptionValueTypeString(extendsOptionDeclaration)));
-    } else {
-      const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
-      if (isString(json.extends)) {
-        extendedConfigPath = getExtendsConfigPath(json.extends, host, newBase, errors, createCompilerDiagnostic);
+  const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
+  if (isString(value)) {
+    extendedConfigPath = getExtendsConfigPath(
+      value,
+      host,
+      newBase,
+      errors,
+      valueExpression,
+      sourceFile
+    );
+  } else if (isArray(value)) {
+    extendedConfigPath = [];
+    for (let index = 0; index < value.length; index++) {
+      const fileName = value[index];
+      if (isString(fileName)) {
+        extendedConfigPath = append(extendedConfigPath, getExtendsConfigPath(
+          fileName,
+          host,
+          newBase,
+          errors,
+          valueExpression == null ? void 0 : valueExpression.elements[index],
+          sourceFile
+        ));
       } else {
-        extendedConfigPath = [];
-        for (const fileName of json.extends) {
-          if (isString(fileName)) {
-            extendedConfigPath = append(extendedConfigPath, getExtendsConfigPath(fileName, host, newBase, errors, createCompilerDiagnostic));
-          } else {
-            errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, "extends", getCompilerOptionValueTypeString(extendsOptionDeclaration.element)));
-          }
-        }
+        convertJsonOption(extendsOptionDeclaration.element, value, basePath, errors, propertyAssignment, valueExpression == null ? void 0 : valueExpression.elements[index], sourceFile);
       }
     }
+  } else {
+    convertJsonOption(extendsOptionDeclaration, value, basePath, errors, propertyAssignment, valueExpression, sourceFile);
   }
-  return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
+  return extendedConfigPath;
 }
 function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileName, errors) {
   const options = getDefaultCompilerOptions(configFileName);
@@ -40204,69 +40129,11 @@ function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileNa
   let watchOptions;
   let extendedConfigPath;
   let rootCompilerOptions;
-  const optionsIterator = {
-    onSetValidOptionKeyValueInParent(parentOption, option, value) {
-      let currentOption;
-      switch (parentOption) {
-        case "compilerOptions":
-          currentOption = options;
-          break;
-        case "watchOptions":
-          currentOption = watchOptions || (watchOptions = {});
-          break;
-        case "typeAcquisition":
-          currentOption = typeAcquisition || (typeAcquisition = getDefaultTypeAcquisition(configFileName));
-          break;
-        default:
-          Debug.fail("Unknown option");
-      }
-      currentOption[option.name] = normalizeOptionValue(option, basePath, value);
-    },
-    onSetValidOptionKeyValueInRoot(key, _keyNode, value, valueNode) {
-      switch (key) {
-        case "extends":
-          const newBase = configFileName ? directoryOfCombinedPath(configFileName, basePath) : basePath;
-          if (isString(value)) {
-            extendedConfigPath = getExtendsConfigPath(
-              value,
-              host,
-              newBase,
-              errors,
-              (message, arg0) => createDiagnosticForNodeInSourceFile(sourceFile, valueNode, message, arg0)
-            );
-          } else {
-            extendedConfigPath = [];
-            for (let index = 0; index < value.length; index++) {
-              const fileName = value[index];
-              if (isString(fileName)) {
-                extendedConfigPath = append(extendedConfigPath, getExtendsConfigPath(
-                  fileName,
-                  host,
-                  newBase,
-                  errors,
-                  (message, arg0) => createDiagnosticForNodeInSourceFile(sourceFile, valueNode.elements[index], message, arg0)
-                ));
-              }
-            }
-          }
-          return;
-      }
-    },
-    onSetUnknownOptionKeyValueInRoot(key, keyNode, _value, _valueNode) {
-      if (key === "excludes") {
-        errors.push(createDiagnosticForNodeInSourceFile(sourceFile, keyNode, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
-      }
-      if (find(commandOptionsWithoutBuild, (opt) => opt.name === key)) {
-        rootCompilerOptions = append(rootCompilerOptions, keyNode);
-      }
-    }
-  };
+  const rootOptions = getTsconfigRootOptionsMap();
   const json = convertConfigFileToObject(
     sourceFile,
     errors,
-    /*reportOptionsErrors*/
-    true,
-    optionsIterator
+    { rootOptions, onPropertySet }
   );
   if (!typeAcquisition) {
     typeAcquisition = getDefaultTypeAcquisition(configFileName);
@@ -40275,15 +40142,57 @@ function parseOwnConfigOfJsonSourceFile(sourceFile, host, basePath, configFileNa
     errors.push(createDiagnosticForNodeInSourceFile(sourceFile, rootCompilerOptions[0], Diagnostics._0_should_be_set_inside_the_compilerOptions_object_of_the_config_json_file, getTextOfPropertyName(rootCompilerOptions[0])));
   }
   return { raw: json, options, watchOptions, typeAcquisition, extendedConfigPath };
+  function onPropertySet(keyText, value, propertyAssignment, parentOption, option) {
+    if (option && option !== extendsOptionDeclaration)
+      value = convertJsonOption(option, value, basePath, errors, propertyAssignment, propertyAssignment.initializer, sourceFile);
+    if (parentOption == null ? void 0 : parentOption.name) {
+      if (option) {
+        let currentOption;
+        if (parentOption === compilerOptionsDeclaration)
+          currentOption = options;
+        else if (parentOption === watchOptionsDeclaration)
+          currentOption = watchOptions != null ? watchOptions : watchOptions = {};
+        else if (parentOption === typeAcquisitionDeclaration)
+          currentOption = typeAcquisition != null ? typeAcquisition : typeAcquisition = getDefaultTypeAcquisition(configFileName);
+        else
+          Debug.fail("Unknown option");
+        currentOption[option.name] = value;
+      } else if (keyText && (parentOption == null ? void 0 : parentOption.extraKeyDiagnostics)) {
+        if (parentOption.elementOptions) {
+          errors.push(createUnknownOptionError(
+            keyText,
+            parentOption.extraKeyDiagnostics,
+            /*unknownOptionErrorText*/
+            void 0,
+            propertyAssignment.name,
+            sourceFile
+          ));
+        } else {
+          errors.push(createDiagnosticForNodeInSourceFile(sourceFile, propertyAssignment.name, parentOption.extraKeyDiagnostics.unknownOptionDiagnostic, keyText));
+        }
+      }
+    } else if (parentOption === rootOptions) {
+      if (option === extendsOptionDeclaration) {
+        extendedConfigPath = getExtendsConfigPathOrArray(value, host, basePath, configFileName, errors, propertyAssignment, propertyAssignment.initializer, sourceFile);
+      } else if (!option) {
+        if (keyText === "excludes") {
+          errors.push(createDiagnosticForNodeInSourceFile(sourceFile, propertyAssignment.name, Diagnostics.Unknown_option_excludes_Did_you_mean_exclude));
+        }
+        if (find(commandOptionsWithoutBuild, (opt) => opt.name === keyText)) {
+          rootCompilerOptions = append(rootCompilerOptions, propertyAssignment.name);
+        }
+      }
+    }
+  }
 }
-function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiagnostic) {
+function getExtendsConfigPath(extendedConfig, host, basePath, errors, valueExpression, sourceFile) {
   extendedConfig = normalizeSlashes(extendedConfig);
   if (isRootedDiskPath(extendedConfig) || startsWith(extendedConfig, "./") || startsWith(extendedConfig, "../")) {
     let extendedConfigPath = getNormalizedAbsolutePath(extendedConfig, basePath);
     if (!host.fileExists(extendedConfigPath) && !endsWith(extendedConfigPath, ".json" /* Json */)) {
       extendedConfigPath = `${extendedConfigPath}.json`;
       if (!host.fileExists(extendedConfigPath)) {
-        errors.push(createDiagnostic(Diagnostics.File_0_not_found, extendedConfig));
+        errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.File_0_not_found, extendedConfig));
         return void 0;
       }
     }
@@ -40294,9 +40203,9 @@ function getExtendsConfigPath(extendedConfig, host, basePath, errors, createDiag
     return resolved.resolvedModule.resolvedFileName;
   }
   if (extendedConfig === "") {
-    errors.push(createDiagnostic(Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string, "extends"));
+    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.Compiler_option_0_cannot_be_given_an_empty_string, "extends"));
   } else {
-    errors.push(createDiagnostic(Diagnostics.File_0_not_found, extendedConfig));
+    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.File_0_not_found, extendedConfig));
   }
   return void 0;
 }
@@ -40398,43 +40307,34 @@ function convertOptionsFromJson(optionsNameMap, jsonOptions, basePath, defaultOp
     if (opt) {
       (defaultOptions || (defaultOptions = {}))[opt.name] = convertJsonOption(opt, jsonOptions[id], basePath, errors);
     } else {
-      errors.push(createUnknownOptionError(id, diagnostics, createCompilerDiagnostic));
+      errors.push(createUnknownOptionError(id, diagnostics));
     }
   }
   return defaultOptions;
 }
-function convertJsonOption(opt, value, basePath, errors) {
+function createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, node, message, ...args) {
+  return sourceFile && node ? createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args) : createCompilerDiagnostic(message, ...args);
+}
+function convertJsonOption(opt, value, basePath, errors, propertyAssignment, valueExpression, sourceFile) {
+  if (opt.isCommandLineOnly) {
+    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, propertyAssignment == null ? void 0 : propertyAssignment.name, Diagnostics.Option_0_can_only_be_specified_on_command_line, opt.name));
+    return void 0;
+  }
   if (isCompilerOptionsValue(opt, value)) {
     const optType = opt.type;
     if (optType === "list" && isArray(value)) {
-      return convertJsonOptionOfListType(opt, value, basePath, errors);
+      return convertJsonOptionOfListType(opt, value, basePath, errors, propertyAssignment, valueExpression, sourceFile);
     } else if (optType === "listOrElement") {
-      return isArray(value) ? convertJsonOptionOfListType(opt, value, basePath, errors) : convertJsonOption(opt.element, value, basePath, errors);
+      return isArray(value) ? convertJsonOptionOfListType(opt, value, basePath, errors, propertyAssignment, valueExpression, sourceFile) : convertJsonOption(opt.element, value, basePath, errors, propertyAssignment, valueExpression, sourceFile);
     } else if (!isString(opt.type)) {
-      return convertJsonOptionOfCustomType(opt, value, errors);
+      return convertJsonOptionOfCustomType(opt, value, errors, valueExpression, sourceFile);
     }
-    const validatedValue = validateJsonOptionValue(opt, value, errors);
+    const validatedValue = validateJsonOptionValue(opt, value, errors, valueExpression, sourceFile);
     return isNullOrUndefined(validatedValue) ? validatedValue : normalizeNonListOptionValue(opt, basePath, validatedValue);
   } else {
-    errors.push(createCompilerDiagnostic(Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
+    errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, Diagnostics.Compiler_option_0_requires_a_value_of_type_1, opt.name, getCompilerOptionValueTypeString(opt)));
   }
 }
-function normalizeOptionValue(option, basePath, value) {
-  if (isNullOrUndefined(value))
-    return void 0;
-  if (option.type === "listOrElement" && !isArray(value))
-    return normalizeOptionValue(option.element, basePath, value);
-  else if (option.type === "list" || option.type === "listOrElement") {
-    const listOption = option;
-    if (listOption.element.isFilePath || !isString(listOption.element.type)) {
-      return filter(map(value, (v) => normalizeOptionValue(listOption.element, basePath, v)), (v) => listOption.listPreserveFalsyValues ? true : !!v);
-    }
-    return value;
-  } else if (!isString(option.type)) {
-    return option.type.get(isString(value) ? value.toLowerCase() : value);
-  }
-  return normalizeNonListOptionValue(option, basePath, value);
-}
 function normalizeNonListOptionValue(option, basePath, value) {
   if (option.isFilePath) {
     value = getNormalizedAbsolutePath(value, basePath);
@@ -40444,29 +40344,29 @@ function normalizeNonListOptionValue(option, basePath, value) {
   }
   return value;
 }
-function validateJsonOptionValue(opt, value, errors) {
+function validateJsonOptionValue(opt, value, errors, valueExpression, sourceFile) {
   var _a2;
   if (isNullOrUndefined(value))
     return void 0;
   const d = (_a2 = opt.extraValidation) == null ? void 0 : _a2.call(opt, value);
   if (!d)
     return value;
-  errors.push(createCompilerDiagnostic(...d));
+  errors.push(createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, ...d));
   return void 0;
 }
-function convertJsonOptionOfCustomType(opt, value, errors) {
+function convertJsonOptionOfCustomType(opt, value, errors, valueExpression, sourceFile) {
   if (isNullOrUndefined(value))
     return void 0;
   const key = value.toLowerCase();
   const val = opt.type.get(key);
   if (val !== void 0) {
-    return validateJsonOptionValue(opt, val, errors);
+    return validateJsonOptionValue(opt, val, errors, valueExpression, sourceFile);
   } else {
-    errors.push(createCompilerDiagnosticForInvalidCustomType(opt));
+    errors.push(createDiagnosticForInvalidCustomType(opt, (message, ...args) => createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(sourceFile, valueExpression, message, ...args)));
   }
 }
-function convertJsonOptionOfListType(option, values, basePath, errors) {
-  return filter(map(values, (v) => convertJsonOption(option.element, v, basePath, errors)), (v) => option.listPreserveFalsyValues ? true : !!v);
+function convertJsonOptionOfListType(option, values, basePath, errors, propertyAssignment, valueExpression, sourceFile) {
+  return filter(map(values, (v, index) => convertJsonOption(option.element, v, basePath, errors, propertyAssignment, valueExpression == null ? void 0 : valueExpression.elements[index], sourceFile)), (v) => option.listPreserveFalsyValues ? true : !!v);
 }
 var invalidTrailingRecursionPattern = /(^|\/)\*\*\/?$/;
 var wildcardDirectoryPattern = /^[^*?]*(?=\/[^/]*[*?])/;
@@ -40575,7 +40475,7 @@ function validateSpecs(specs, errors, disallowTrailingRecursion, jsonSourceFile,
   });
   function createDiagnostic(message, spec) {
     const element = getTsConfigPropArrayElementValue(jsonSourceFile, specKey, spec);
-    return element ? createDiagnosticForNodeInSourceFile(jsonSourceFile, element, message, spec) : createCompilerDiagnostic(message, spec);
+    return createDiagnosticForNodeInSourceFileOrCompilerDiagnostic(jsonSourceFile, element, message, spec);
   }
 }
 function specToDiagnostic(spec, disallowTrailingRecursion) {
@@ -40686,6 +40586,8 @@ function convertCompilerOptionsForTelemetry(opts) {
   return out;
 }
 function getOptionValueWithEmptyStrings(value, option) {
+  if (value === void 0)
+    return value;
   switch (option.type) {
     case "object":
       return "";
@@ -40700,7 +40602,7 @@ function getOptionValueWithEmptyStrings(value, option) {
         return getOptionValueWithEmptyStrings(value, option.element);
     case "list":
       const elementType = option.element;
-      return isArray(value) ? value.map((v) => getOptionValueWithEmptyStrings(v, elementType)) : "";
+      return isArray(value) ? mapDefined(value, (v) => getOptionValueWithEmptyStrings(v, elementType)) : "";
     default:
       return forEachEntry(option.type, (optionEnumValue, optionStringValue) => {
         if (optionEnumValue === value) {
@@ -43453,8 +43355,8 @@ function createBinder() {
   var reportedUnreachableFlow = { flags: 1 /* Unreachable */ };
   var bindBinaryExpressionFlow = createBindBinaryExpressionFlow();
   return bindSourceFile2;
-  function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
-    return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, arg0, arg1, arg2);
+  function createDiagnosticForNode2(node, message, ...args) {
+    return createDiagnosticForNodeInSourceFile(getSourceFileOfNode(node) || file, node, message, ...args);
   }
   function bindSourceFile2(f, opts) {
     var _a2, _b;
@@ -43648,7 +43550,7 @@ function createBinder() {
           const declarationName = getNameOfDeclaration(node) || node;
           forEach(symbol.declarations, (declaration, index) => {
             const decl = getNameOfDeclaration(declaration) || declaration;
-            const diag3 = createDiagnosticForNode2(decl, message, messageNeedsName ? getDisplayName(declaration) : void 0);
+            const diag3 = messageNeedsName ? createDiagnosticForNode2(decl, message, getDisplayName(declaration)) : createDiagnosticForNode2(decl, message);
             file.bindDiagnostics.push(
               multipleDefaultExports ? addRelatedInfo(diag3, createDiagnosticForNode2(declarationName, index === 0 ? Diagnostics.Another_export_default_is_here : Diagnostics.and_here)) : diag3
             );
@@ -43656,7 +43558,7 @@ function createBinder() {
               relatedInformation.push(createDiagnosticForNode2(decl, Diagnostics.The_first_export_default_is_here));
             }
           });
-          const diag2 = createDiagnosticForNode2(declarationName, message, messageNeedsName ? getDisplayName(node) : void 0);
+          const diag2 = messageNeedsName ? createDiagnosticForNode2(declarationName, message, getDisplayName(node)) : createDiagnosticForNode2(declarationName, message);
           file.bindDiagnostics.push(addRelatedInfo(diag2, ...relatedInformation));
           symbol = createSymbol(0 /* None */, name);
         }
@@ -45117,9 +45019,9 @@ function createBinder() {
       }
     }
   }
-  function errorOnFirstToken(node, message, arg0, arg1, arg2) {
+  function errorOnFirstToken(node, message, ...args) {
     const span = getSpanOfTokenAtPosition(file, node.pos);
-    file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, arg0, arg1, arg2));
+    file.bindDiagnostics.push(createFileDiagnostic(file, span.start, span.length, message, ...args));
   }
   function errorOrSuggestionOnNode(isError, node, message) {
     errorOrSuggestionOnRange(isError, node, node, message);
@@ -47277,6 +47179,7 @@ function createTypeChecker(host) {
   var argumentsSymbol = createSymbol(4 /* Property */, "arguments");
   var requireSymbol = createSymbol(4 /* Property */, "require");
   var isolatedModulesLikeFlagName = compilerOptions.verbatimModuleSyntax ? "verbatimModuleSyntax" : "isolatedModules";
+  var canCollectSymbolAliasAccessabilityData = !compilerOptions.verbatimModuleSyntax || !!compilerOptions.importsNotUsedAsValues;
   var apparentArgumentCount;
   const checker = {
     getNodeCount: () => reduceLeft(host.getSourceFiles(), (n, s) => n + s.nodeCount, 0),
@@ -48104,8 +48007,8 @@ function createTypeChecker(host) {
     getDiagnostics2(sourceFile, cancellationToken2);
     return emitResolver;
   }
-  function lookupOrIssueError(location, message, arg0, arg1, arg2, arg3) {
-    const diagnostic = location ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
+  function lookupOrIssueError(location, message, ...args) {
+    const diagnostic = location ? createDiagnosticForNode(location, message, ...args) : createCompilerDiagnostic(message, ...args);
     const existing = diagnostics.lookup(diagnostic);
     if (existing) {
       return existing;
@@ -48114,16 +48017,16 @@ function createTypeChecker(host) {
       return diagnostic;
     }
   }
-  function errorSkippedOn(key, location, message, arg0, arg1, arg2, arg3) {
-    const diagnostic = error(location, message, arg0, arg1, arg2, arg3);
+  function errorSkippedOn(key, location, message, ...args) {
+    const diagnostic = error(location, message, ...args);
     diagnostic.skippedOn = key;
     return diagnostic;
   }
-  function createError(location, message, arg0, arg1, arg2, arg3) {
-    return location ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createCompilerDiagnostic(message, arg0, arg1, arg2, arg3);
+  function createError(location, message, ...args) {
+    return location ? createDiagnosticForNode(location, message, ...args) : createCompilerDiagnostic(message, ...args);
   }
-  function error(location, message, arg0, arg1, arg2, arg3) {
-    const diagnostic = createError(location, message, arg0, arg1, arg2, arg3);
+  function error(location, message, ...args) {
+    const diagnostic = createError(location, message, ...args);
     diagnostics.add(diagnostic);
     return diagnostic;
   }
@@ -48134,19 +48037,19 @@ function createTypeChecker(host) {
       suggestionDiagnostics.add({ ...diagnostic, category: 2 /* Suggestion */ });
     }
   }
-  function errorOrSuggestion(isError, location, message, arg0, arg1, arg2, arg3) {
+  function errorOrSuggestion(isError, location, message, ...args) {
     if (location.pos < 0 || location.end < 0) {
       if (!isError) {
         return;
       }
       const file = getSourceFileOfNode(location);
-      addErrorOrSuggestion(isError, "message" in message ? createFileDiagnostic(file, 0, 0, message, arg0, arg1, arg2, arg3) : createDiagnosticForFileFromMessageChain(file, message));
+      addErrorOrSuggestion(isError, "message" in message ? createFileDiagnostic(file, 0, 0, message, ...args) : createDiagnosticForFileFromMessageChain(file, message));
       return;
     }
-    addErrorOrSuggestion(isError, "message" in message ? createDiagnosticForNode(location, message, arg0, arg1, arg2, arg3) : createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(location), location, message));
+    addErrorOrSuggestion(isError, "message" in message ? createDiagnosticForNode(location, message, ...args) : createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(location), location, message));
   }
-  function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, arg0, arg1, arg2, arg3) {
-    const diagnostic = error(location, message, arg0, arg1, arg2, arg3);
+  function errorAndMaybeSuggestAwait(location, maybeMissingAwait, message, ...args) {
+    const diagnostic = error(location, message, ...args);
     if (maybeMissingAwait) {
       const related = createDiagnosticForNode(location, Diagnostics.Did_you_forget_to_use_await);
       addRelatedInfo(diagnostic, related);
@@ -50020,7 +49923,7 @@ function createTypeChecker(host) {
     return void 0;
   }
   function markExportAsReferenced(node) {
-    if (compilerOptions.verbatimModuleSyntax) {
+    if (!canCollectSymbolAliasAccessabilityData) {
       return;
     }
     const symbol = getSymbolOfDeclaration(node);
@@ -50033,7 +49936,7 @@ function createTypeChecker(host) {
     }
   }
   function markAliasSymbolAsReferenced(symbol) {
-    Debug.assert(!compilerOptions.verbatimModuleSyntax);
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
     const links = getSymbolLinks(symbol);
     if (!links.referenced) {
       links.referenced = true;
@@ -50164,6 +50067,9 @@ function createTypeChecker(host) {
         }
       }
       symbol = getMergedSymbol(getSymbol2(getExportsOfSymbol(namespace), right.escapedText, meaning));
+      if (!symbol && namespace.flags & 2097152 /* Alias */) {
+        symbol = getMergedSymbol(getSymbol2(getExportsOfSymbol(resolveAlias(namespace)), right.escapedText, meaning));
+      }
       if (!symbol) {
         if (!ignoreErrors) {
           const namespaceName = getFullyQualifiedName(namespace);
@@ -51913,8 +51819,11 @@ function createTypeChecker(host) {
         }
         return typeToTypeNodeHelper(type2, context);
       }
+      function isMappedTypeHomomorphic(type2) {
+        return !!getHomomorphicTypeVariable(type2);
+      }
       function isHomomorphicMappedTypeWithNonHomomorphicInstantiation(type2) {
-        return isMappedTypeWithKeyofConstraintDeclaration(type2) && !(getModifiersTypeFromMappedType(type2).flags & 262144 /* TypeParameter */);
+        return !!type2.target && isMappedTypeHomomorphic(type2.target) && !isMappedTypeHomomorphic(type2);
       }
       function createMappedTypeNodeFromType(type2) {
         Debug.assert(!!(type2.flags & 524288 /* Object */));
@@ -58318,7 +58227,7 @@ function createTypeChecker(host) {
     const typeVariable = getHomomorphicTypeVariable(type);
     if (typeVariable && !type.declaration.nameType) {
       const constraint = getConstraintOfTypeParameter(typeVariable);
-      if (constraint && isArrayType(constraint)) {
+      if (constraint && everyType(constraint, isArrayOrTupleType)) {
         return instantiateType(type, prependTypeMapping(typeVariable, constraint, type.mapper));
       }
     }
@@ -61085,31 +60994,21 @@ function createTypeChecker(host) {
     }
     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;
         }
       }
@@ -61121,6 +61020,11 @@ function createTypeChecker(host) {
   }
   function createTemplateLiteralType(texts, types) {
     const type = createType(134217728 /* TemplateLiteral */);
+    type.objectFlags = getPropagatingFlagsOfTypes(
+      types,
+      /*excludeKinds*/
+      98304 /* Nullable */
+    );
     type.texts = texts;
     type.types = types;
     return type;
@@ -61420,6 +61324,9 @@ function createTypeChecker(host) {
     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) {
@@ -61435,7 +61342,7 @@ function createTypeChecker(host) {
     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);
       }
@@ -61447,7 +61354,7 @@ function createTypeChecker(host) {
       }
       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;
@@ -62461,6 +62368,9 @@ function createTypeChecker(host) {
       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;
@@ -62589,7 +62499,7 @@ function createTypeChecker(host) {
     ) : 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);
@@ -62794,7 +62704,13 @@ function createTypeChecker(host) {
     return hasContextSensitiveParameters(node) || hasContextSensitiveReturnExpression(node);
   }
   function hasContextSensitiveReturnExpression(node) {
-    return !node.typeParameters && !getEffectiveReturnTypeNode(node) && !!node.body && node.body.kind !== 239 /* Block */ && isContextSensitive(node.body);
+    if (node.typeParameters || getEffectiveReturnTypeNode(node) || !node.body) {
+      return false;
+    }
+    if (node.body.kind !== 239 /* Block */) {
+      return isContextSensitive(node.body);
+    }
+    return !!forEachReturnStatement(node.body, (statement) => !!statement.expression && isContextSensitive(statement.expression));
   }
   function isContextSensitiveFunctionOrObjectLiteralMethod(func) {
     return (isFunctionExpressionOrArrowFunction(func) || isObjectLiteralMethod(func)) && isContextSensitiveFunctionLikeDeclaration(func);
@@ -63463,7 +63379,12 @@ function createTypeChecker(host) {
     const paramCount = sourceRestType || targetRestType ? Math.min(sourceCount, targetCount) : Math.max(sourceCount, targetCount);
     const restIndex = sourceRestType || targetRestType ? paramCount - 1 : -1;
     for (let i = 0; i < paramCount; i++) {
-      const sourceType = i === restIndex ? getRestTypeAtPosition(source, i) : tryGetTypeAtPosition(source, i);
+      const sourceType = i === restIndex ? getRestTypeAtPosition(
+        source,
+        i,
+        /*readonly*/
+        true
+      ) : tryGetTypeAtPosition(source, i);
       const targetType = i === restIndex ? getRestTypeAtPosition(target, i) : tryGetTypeAtPosition(target, i);
       if (sourceType && targetType) {
         const sourceSig = checkMode & 3 /* Callback */ ? void 0 : getSingleCallSignature(getNonNullableType(sourceType));
@@ -63729,7 +63650,7 @@ function createTypeChecker(host) {
   }
   function getNormalizedType(type, writing) {
     while (true) {
-      const t = isFreshLiteralType(type) ? type.regularType : getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) : type;
+      const t = isFreshLiteralType(type) ? type.regularType : isGenericTupleType(type) ? getNormalizedTupleType(type, writing) : getObjectFlags(type) & 4 /* Reference */ ? type.node ? createTypeReference(type.target, getTypeArguments(type)) : getSingleBaseForNonAugmentingSubtype(type) || type : type.flags & 3145728 /* UnionOrIntersection */ ? getNormalizedUnionOrIntersectionType(type, writing) : type.flags & 33554432 /* Substitution */ ? writing ? type.baseType : getSubstitutionIntersection(type) : type.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(type, writing) : type;
       if (t === type)
         return t;
       type = t;
@@ -63748,6 +63669,11 @@ function createTypeChecker(host) {
     }
     return type;
   }
+  function getNormalizedTupleType(type, writing) {
+    const elements = getTypeArguments(type);
+    const normalizedElements = sameMap(elements, (t) => t.flags & 25165824 /* Simplifiable */ ? getSimplifiedType(t, writing) : t);
+    return elements !== normalizedElements ? createNormalizedTupleType(type.target, normalizedElements) : type;
+  }
   function checkTypeRelatedTo(source, target, relation, errorNode, headMessage, containingMessageChain, errorOutputContainer) {
     var _a2;
     let errorInfo;
@@ -63837,10 +63763,10 @@ function createTypeChecker(host) {
         relatedInfo: relatedInfo == null ? void 0 : relatedInfo.slice()
       };
     }
-    function reportIncompatibleError(message, arg0, arg1, arg2, arg3) {
+    function reportIncompatibleError(message, ...args) {
       overrideNextErrorInfo++;
       lastSkippedInfo = void 0;
-      (incompatibleStack || (incompatibleStack = [])).push([message, arg0, arg1, arg2, arg3]);
+      (incompatibleStack || (incompatibleStack = [])).push([message, ...args]);
     }
     function reportIncompatibleStack() {
       const stack = incompatibleStack || [];
@@ -63932,13 +63858,13 @@ function createTypeChecker(host) {
         );
       }
     }
-    function reportError(message, arg0, arg1, arg2, arg3) {
+    function reportError(message, ...args) {
       Debug.assert(!!errorNode);
       if (incompatibleStack)
         reportIncompatibleStack();
       if (message.elidedInCompatabilityPyramid)
         return;
-      errorInfo = chainDiagnosticMessages(errorInfo, message, arg0, arg1, arg2, arg3);
+      errorInfo = chainDiagnosticMessages(errorInfo, message, ...args);
     }
     function associateRelatedInfo(info) {
       Debug.assert(!!errorInfo);
@@ -65225,7 +65151,7 @@ function createTypeChecker(host) {
           if (varianceResult !== void 0) {
             return varianceResult;
           }
-        } else if (isReadonlyArrayType(target2) ? isArrayOrTupleType(source2) : isArrayType(target2) && isTupleType(source2) && !source2.target.readonly) {
+        } else if (isReadonlyArrayType(target2) ? everyType(source2, isArrayOrTupleType) : isArrayType(target2) && everyType(source2, (t) => isTupleType(t) && !t.target.readonly)) {
           if (relation !== identityRelation) {
             return isRelatedTo(getIndexTypeOfType(source2, numberType) || anyType, getIndexTypeOfType(target2, numberType) || anyType, 3 /* Both */, reportErrors2);
           } else {
@@ -66108,22 +66034,7 @@ function createTypeChecker(host) {
     if (match === -1) {
       return defaultValue;
     }
-    let nextMatch = discriminable.indexOf(
-      /*searchElement*/
-      true,
-      match + 1
-    );
-    while (nextMatch !== -1) {
-      if (!isTypeIdenticalTo(target.types[match], target.types[nextMatch])) {
-        return defaultValue;
-      }
-      nextMatch = discriminable.indexOf(
-        /*searchElement*/
-        true,
-        nextMatch + 1
-      );
-    }
-    return target.types[match];
+    return getUnionType(target.types.filter((_, index) => discriminable[index]));
   }
   function isWeakType(type) {
     if (type.flags & 524288 /* Object */) {
@@ -66324,7 +66235,7 @@ function createTypeChecker(host) {
         return type.symbol;
       }
       if (isTupleType(type)) {
-        return type.target;
+        return type;
       }
     }
     if (type.flags & 262144 /* TypeParameter */) {
@@ -67097,8 +67008,8 @@ function createTypeChecker(host) {
     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;
@@ -67723,7 +67634,11 @@ function createTypeChecker(host) {
         return true;
       }
       if (constraintType.flags & 262144 /* TypeParameter */) {
-        inferWithPriority(getIndexType(source), constraintType, 32 /* MappedTypeConstraint */);
+        inferWithPriority(getIndexType(
+          source,
+          /*indexFlags*/
+          !!source.pattern ? 2 /* NoIndexSignatures */ : 0 /* None */
+        ), constraintType, 32 /* MappedTypeConstraint */);
         const extendedConstraint = getConstraintOfType(constraintType);
         if (extendedConstraint && inferToMappedType(source, target, extendedConstraint)) {
           return true;
@@ -68196,36 +68111,34 @@ function createTypeChecker(host) {
     return type.flags & 8192 /* UniqueESSymbol */ ? type.escapedName : type.flags & 384 /* StringOrNumberLiteral */ ? escapeLeadingUnderscores("" + type.value) : void 0;
   }
   function tryGetElementAccessExpressionName(node) {
-    if (isStringOrNumericLiteralLike(node.argumentExpression)) {
-      return escapeLeadingUnderscores(node.argumentExpression.text);
+    return isStringOrNumericLiteralLike(node.argumentExpression) ? escapeLeadingUnderscores(node.argumentExpression.text) : isEntityNameExpression(node.argumentExpression) ? tryGetNameFromEntityNameExpression(node.argumentExpression) : void 0;
+  }
+  function tryGetNameFromEntityNameExpression(node) {
+    const symbol = resolveEntityName(
+      node,
+      111551 /* Value */,
+      /*ignoreErrors*/
+      true
+    );
+    if (!symbol || !(isConstVariable(symbol) || symbol.flags & 8 /* EnumMember */))
+      return void 0;
+    const declaration = symbol.valueDeclaration;
+    if (declaration === void 0)
+      return void 0;
+    const type = tryGetTypeFromEffectiveTypeNode(declaration);
+    if (type) {
+      const name = tryGetNameFromType(type);
+      if (name !== void 0) {
+        return name;
+      }
     }
-    if (isEntityNameExpression(node.argumentExpression)) {
-      const symbol = resolveEntityName(
-        node.argumentExpression,
-        111551 /* Value */,
-        /*ignoreErrors*/
-        true
-      );
-      if (!symbol || !(isConstVariable(symbol) || symbol.flags & 8 /* EnumMember */))
-        return void 0;
-      const declaration = symbol.valueDeclaration;
-      if (declaration === void 0)
-        return void 0;
-      const type = tryGetTypeFromEffectiveTypeNode(declaration);
-      if (type) {
-        const name = tryGetNameFromType(type);
-        if (name !== void 0) {
-          return name;
-        }
+    if (hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node)) {
+      const initializer = getEffectiveInitializer(declaration);
+      if (initializer) {
+        return tryGetNameFromType(getTypeOfExpression(initializer));
       }
-      if (hasOnlyExpressionInitializer(declaration) && isBlockScopedNameDeclaredBeforeUse(declaration, node.argumentExpression)) {
-        const initializer = getEffectiveInitializer(declaration);
-        if (initializer) {
-          return tryGetNameFromType(getTypeOfExpression(initializer));
-        }
-        if (isEnumMember(declaration)) {
-          return getTextOfPropertyName(declaration.name);
-        }
+      if (isEnumMember(declaration)) {
+        return getTextOfPropertyName(declaration.name);
       }
     }
     return void 0;
@@ -70143,7 +70056,7 @@ function createTypeChecker(host) {
     });
   }
   function markAliasReferenced(symbol, location) {
-    if (compilerOptions.verbatimModuleSyntax) {
+    if (!canCollectSymbolAliasAccessabilityData) {
       return;
     }
     if (isNonLocalAlias(
@@ -71281,30 +71194,52 @@ function createTypeChecker(host) {
     }
     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;
@@ -71413,7 +71348,11 @@ function createTypeChecker(host) {
     if (instantiatedType && !(contextFlags && contextFlags & 2 /* NoConstraints */ && instantiatedType.flags & 8650752 /* TypeVariable */)) {
       const apparentType = mapType(
         instantiatedType,
-        getApparentType,
+        // When obtaining apparent type of *contextual* type we don't want to get apparent type of mapped types.
+        // That would evaluate mapped types with array or tuple type constraints too eagerly
+        // and thus it would prevent `getTypeOfPropertyOfContextualType` from obtaining per-position contextual type for elements of array literal expressions.
+        // Apparent type of other mapped types is already the mapped type itself so we can just avoid calling `getApparentType` here for all mapped types.
+        (t) => getObjectFlags(t) & 32 /* Mapped */ ? t : getApparentType(t),
         /*noReductions*/
         true
       );
@@ -71491,9 +71430,9 @@ function createTypeChecker(host) {
       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);
@@ -72678,7 +72617,7 @@ function createTypeChecker(host) {
       }
       if (jsxFactorySym) {
         jsxFactorySym.isReferenced = 67108863 /* All */;
-        if (!compilerOptions.verbatimModuleSyntax && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
+        if (canCollectSymbolAliasAccessabilityData && jsxFactorySym.flags & 2097152 /* Alias */ && !getTypeOnlyAliasDeclaration(jsxFactorySym)) {
           markAliasSymbolAsReferenced(jsxFactorySym);
         }
       }
@@ -73905,7 +73844,7 @@ function createTypeChecker(host) {
           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));
@@ -74252,16 +74191,16 @@ function createTypeChecker(host) {
     }
     return { start: start2, length: length2, sourceFile };
   }
-  function getDiagnosticForCallNode(node, message, arg0, arg1, arg2, arg3) {
+  function getDiagnosticForCallNode(node, message, ...args) {
     if (isCallExpression(node)) {
       const { sourceFile, start: start2, length: length2 } = getDiagnosticSpanForCallNode(node);
       if ("message" in message) {
-        return createFileDiagnostic(sourceFile, start2, length2, message, arg0, arg1, arg2, arg3);
+        return createFileDiagnostic(sourceFile, start2, length2, message, ...args);
       }
       return createDiagnosticForFileFromMessageChain(sourceFile, message);
     } else {
       if ("message" in message) {
-        return createDiagnosticForNode(node, message, arg0, arg1, arg2, arg3);
+        return createDiagnosticForNode(node, message, ...args);
       }
       return createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(node), node, message);
     }
@@ -74349,11 +74288,8 @@ function createTypeChecker(host) {
       }
       const parameter = (_a2 = closestSignature == null ? void 0 : closestSignature.declaration) == null ? void 0 : _a2.parameters[closestSignature.thisParameter ? args.length + 1 : args.length];
       if (parameter) {
-        const parameterError = createDiagnosticForNode(
-          parameter,
-          isBindingPattern(parameter.name) ? Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided : isRestParameter(parameter) ? Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided : Diagnostics.An_argument_for_0_was_not_provided,
-          !parameter.name ? args.length : !isBindingPattern(parameter.name) ? idText(getFirstIdentifier(parameter.name)) : void 0
-        );
+        const messageAndArgs = isBindingPattern(parameter.name) ? [Diagnostics.An_argument_matching_this_binding_pattern_was_not_provided] : isRestParameter(parameter) ? [Diagnostics.Arguments_for_the_rest_parameter_0_were_not_provided, idText(getFirstIdentifier(parameter.name))] : [Diagnostics.An_argument_for_0_was_not_provided, !parameter.name ? args.length : idText(getFirstIdentifier(parameter.name))];
+        const parameterError = createDiagnosticForNode(parameter, ...messageAndArgs);
         return addRelatedInfo(diagnostic, parameterError);
       }
       return diagnostic;
@@ -75958,12 +75894,12 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
-  function getRestTypeAtPosition(source, pos) {
+  function getRestTypeAtPosition(source, pos, readonly = false) {
     const parameterCount = getParameterCount(source);
     const minArgumentCount = getMinArgumentCount(source);
     const restType = getEffectiveRestType(source);
     if (restType && pos >= parameterCount - 1) {
-      return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType));
+      return pos === parameterCount - 1 ? restType : createArrayType(getIndexedAccessType(restType, numberType), readonly);
     }
     const types = [];
     const flags = [];
@@ -75981,13 +75917,7 @@ function createTypeChecker(host) {
         names.push(name);
       }
     }
-    return createTupleType(
-      types,
-      flags,
-      /*readonly*/
-      false,
-      length(names) === length(types) ? names : void 0
-    );
+    return createTupleType(types, flags, readonly, length(names) === length(types) ? names : void 0);
   }
   function getParameterCount(signature) {
     const length2 = signature.parameters.length;
@@ -79693,9 +79623,9 @@ function createTypeChecker(host) {
       }
     }
   }
-  function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, arg0) {
+  function getAwaitedTypeOfPromise(type, errorNode, diagnosticMessage, ...args) {
     const promisedType = getPromisedTypeOfPromise(type, errorNode);
-    return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, arg0);
+    return promisedType && getAwaitedType(promisedType, errorNode, diagnosticMessage, ...args);
   }
   function getPromisedTypeOfPromise(type, errorNode, thisTypeForErrorOut) {
     if (isTypeAny(type)) {
@@ -79758,8 +79688,8 @@ function createTypeChecker(host) {
     }
     return typeAsPromise.promisedTypeOfPromise = getUnionType(map(onfulfilledParameterSignatures, getTypeOfFirstParameterOfSignature), 2 /* Subtype */);
   }
-  function checkAwaitedType(type, withAlias, errorNode, diagnosticMessage, arg0) {
-    const awaitedType = withAlias ? getAwaitedType(type, errorNode, diagnosticMessage, arg0) : getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0);
+  function checkAwaitedType(type, withAlias, errorNode, diagnosticMessage, ...args) {
+    const awaitedType = withAlias ? getAwaitedType(type, errorNode, diagnosticMessage, ...args) : getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, ...args);
     return awaitedType || errorType;
   }
   function isThenableType(type) {
@@ -79815,11 +79745,11 @@ function createTypeChecker(host) {
     Debug.assert(isAwaitedTypeInstantiation(type) || getPromisedTypeOfPromise(type) === void 0, "type provided should not be a non-generic 'promise'-like.");
     return type;
   }
-  function getAwaitedType(type, errorNode, diagnosticMessage, arg0) {
-    const awaitedType = getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0);
+  function getAwaitedType(type, errorNode, diagnosticMessage, ...args) {
+    const awaitedType = getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, ...args);
     return awaitedType && createAwaitedTypeIfNeeded(awaitedType);
   }
-  function getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, arg0) {
+  function getAwaitedTypeNoAlias(type, errorNode, diagnosticMessage, ...args) {
     if (isTypeAny(type)) {
       return type;
     }
@@ -79837,7 +79767,7 @@ function createTypeChecker(host) {
         }
         return void 0;
       }
-      const mapper = errorNode ? (constituentType) => getAwaitedTypeNoAlias(constituentType, errorNode, diagnosticMessage, arg0) : getAwaitedTypeNoAlias;
+      const mapper = errorNode ? (constituentType) => getAwaitedTypeNoAlias(constituentType, errorNode, diagnosticMessage, ...args) : getAwaitedTypeNoAlias;
       awaitedTypeStack.push(type.id);
       const mapped = mapType(type, mapper);
       awaitedTypeStack.pop();
@@ -79861,7 +79791,7 @@ function createTypeChecker(host) {
         return void 0;
       }
       awaitedTypeStack.push(type.id);
-      const awaitedType = getAwaitedTypeNoAlias(promisedType, errorNode, diagnosticMessage, arg0);
+      const awaitedType = getAwaitedTypeNoAlias(promisedType, errorNode, diagnosticMessage, ...args);
       awaitedTypeStack.pop();
       if (!awaitedType) {
         return void 0;
@@ -79875,7 +79805,7 @@ function createTypeChecker(host) {
         if (thisTypeForErrorOut.value) {
           chain = chainDiagnosticMessages(chain, Diagnostics.The_this_context_of_type_0_is_not_assignable_to_method_s_this_of_type_1, typeToString(type), typeToString(thisTypeForErrorOut.value));
         }
-        chain = chainDiagnosticMessages(chain, diagnosticMessage, arg0);
+        chain = chainDiagnosticMessages(chain, diagnosticMessage, ...args);
         diagnostics.add(createDiagnosticForNodeFromMessageChain(getSourceFileOfNode(errorNode), errorNode, chain));
       }
       return void 0;
@@ -80053,7 +79983,7 @@ function createTypeChecker(host) {
       true
     );
     if (rootSymbol && rootSymbol.flags & 2097152 /* Alias */) {
-      if (!compilerOptions.verbatimModuleSyntax && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
+      if (canCollectSymbolAliasAccessabilityData && symbolIsValue(rootSymbol) && !isConstEnumOrConstEnumOnlyModule(resolveAlias(rootSymbol)) && !getTypeOnlyAliasDeclaration(rootSymbol)) {
         markAliasSymbolAsReferenced(rootSymbol);
       } else if (forDecoratorMetadata && getIsolatedModules(compilerOptions) && getEmitModuleKind(compilerOptions) >= 5 /* ES2015 */ && !symbolIsValue(rootSymbol) && !some(rootSymbol.declarations, isTypeOnlyImportOrExportDeclaration)) {
         const diag2 = error(typeName, Diagnostics.A_type_referenced_in_a_decorated_signature_must_be_imported_with_import_type_or_a_namespace_import_when_isolatedModules_and_emitDecoratorMetadata_are_enabled);
@@ -80462,9 +80392,8 @@ function createTypeChecker(host) {
           const sourceFile = getSourceFileOfNode(parent2);
           const range = isJSDocTemplateTag(parent2) ? rangeOfNode(parent2) : rangeOfTypeParameters(sourceFile, parent2.typeParameters);
           const only = parent2.typeParameters.length === 1;
-          const message = only ? Diagnostics._0_is_declared_but_its_value_is_never_read : Diagnostics.All_type_parameters_are_unused;
-          const arg0 = only ? name : void 0;
-          addDiagnostic(typeParameter, 1 /* Parameter */, createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, message, arg0));
+          const messageAndArg = only ? [Diagnostics._0_is_declared_but_its_value_is_never_read, name] : [Diagnostics.All_type_parameters_are_unused];
+          addDiagnostic(typeParameter, 1 /* Parameter */, createFileDiagnostic(sourceFile, range.pos, range.end - range.pos, ...messageAndArg));
         }
       } else {
         addDiagnostic(typeParameter, 1 /* Parameter */, createDiagnosticForNode(typeParameter, Diagnostics._0_is_declared_but_its_value_is_never_read, name));
@@ -82022,7 +81951,7 @@ function createTypeChecker(host) {
             forEachKey(catchClause.locals, (caughtName) => {
               const blockLocal = blockLocals.get(caughtName);
               if ((blockLocal == null ? void 0 : blockLocal.valueDeclaration) && (blockLocal.flags & 2 /* BlockScopedVariable */) !== 0) {
-                grammarErrorOnNode(blockLocal.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, caughtName);
+                grammarErrorOnNode(blockLocal.valueDeclaration, Diagnostics.Cannot_redeclare_identifier_0_in_catch_clause, unescapeLeadingUnderscores(caughtName));
               }
             });
           }
@@ -83618,6 +83547,9 @@ function createTypeChecker(host) {
     ) && !getSymbolLinks(getSymbolOfDeclaration(statement)).constEnumReferenced;
   }
   function checkImportsForTypeOnlyConversion(sourceFile) {
+    if (!canCollectSymbolAliasAccessabilityData) {
+      return;
+    }
     for (const statement of sourceFile.statements) {
       if (canConvertImportDeclarationToTypeOnly(statement) || canConvertImportEqualsDeclarationToTypeOnly(statement)) {
         error(
@@ -83703,14 +83635,14 @@ function createTypeChecker(host) {
         markAliasReferenced(sym, id);
         if (getAllSymbolFlags(sym) & 111551 /* Value */) {
           checkExpressionCached(id);
-          if (!isIllegalExportDefaultInCJS && compilerOptions.verbatimModuleSyntax && getTypeOnlyAliasDeclaration(sym, 111551 /* Value */)) {
+          if (!isIllegalExportDefaultInCJS && !(node.flags & 16777216 /* Ambient */) && compilerOptions.verbatimModuleSyntax && getTypeOnlyAliasDeclaration(sym, 111551 /* Value */)) {
             error(
               id,
               node.isExportEquals ? Diagnostics.An_export_declaration_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration : Diagnostics.An_export_default_must_reference_a_real_value_when_verbatimModuleSyntax_is_enabled_but_0_resolves_to_a_type_only_declaration,
               idText(id)
             );
           }
-        } else if (!isIllegalExportDefaultInCJS && compilerOptions.verbatimModuleSyntax) {
+        } else if (!isIllegalExportDefaultInCJS && !(node.flags & 16777216 /* Ambient */) && compilerOptions.verbatimModuleSyntax) {
           error(
             id,
             node.isExportEquals ? Diagnostics.An_export_declaration_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type : Diagnostics.An_export_default_must_reference_a_value_when_verbatimModuleSyntax_is_enabled_but_0_only_refers_to_a_type,
@@ -85047,7 +84979,7 @@ function createTypeChecker(host) {
     return false;
   }
   function isValueAliasDeclaration(node) {
-    Debug.assert(!compilerOptions.verbatimModuleSyntax);
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
     switch (node.kind) {
       case 269 /* ImportEqualsDeclaration */:
         return isAliasResolvedToValue(getSymbolOfDeclaration(node));
@@ -85088,7 +85020,7 @@ function createTypeChecker(host) {
     return isConstEnumSymbol(s) || !!s.constEnumOnlyModule;
   }
   function isReferencedAliasDeclaration(node, checkChildren) {
-    Debug.assert(!compilerOptions.verbatimModuleSyntax);
+    Debug.assert(canCollectSymbolAliasAccessabilityData);
     if (isAliasSymbolDeclaration2(node)) {
       const symbol = getSymbolOfDeclaration(node);
       const links = symbol && getSymbolLinks(symbol);
@@ -85426,12 +85358,12 @@ function createTypeChecker(host) {
       isDeclarationWithCollidingName,
       isValueAliasDeclaration: (nodeIn) => {
         const node = getParseTreeNode(nodeIn);
-        return node ? isValueAliasDeclaration(node) : true;
+        return node && canCollectSymbolAliasAccessabilityData ? isValueAliasDeclaration(node) : true;
       },
       hasGlobalName,
       isReferencedAliasDeclaration: (nodeIn, checkChildren) => {
         const node = getParseTreeNode(nodeIn);
-        return node ? isReferencedAliasDeclaration(node, checkChildren) : true;
+        return node && canCollectSymbolAliasAccessabilityData ? isReferencedAliasDeclaration(node, checkChildren) : true;
       },
       getNodeCheckFlags: (nodeIn) => {
         const node = getParseTreeNode(nodeIn);
@@ -86566,7 +86498,7 @@ function createTypeChecker(host) {
           throw Debug.assertNever(prop, "Unexpected syntax kind:" + prop.kind);
       }
       if (!inDestructuring) {
-        const effectiveName = getPropertyNameForPropertyNameNode(name);
+        const effectiveName = getEffectivePropertyNameForPropertyNameNode(name);
         if (effectiveName === void 0) {
           continue;
         }
@@ -87035,12 +86967,12 @@ function createTypeChecker(host) {
     switch (node.keywordToken) {
       case 104 /* NewKeyword */:
         if (escapedText !== "target") {
-          return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, tokenToString(node.keywordToken), "target");
+          return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, unescapeLeadingUnderscores(node.name.escapedText), tokenToString(node.keywordToken), "target");
         }
         break;
       case 101 /* ImportKeyword */:
         if (escapedText !== "meta") {
-          return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, node.name.escapedText, tokenToString(node.keywordToken), "meta");
+          return grammarErrorOnNode(node.name, Diagnostics._0_is_not_a_valid_meta_property_for_keyword_1_Did_you_mean_2, unescapeLeadingUnderscores(node.name.escapedText), tokenToString(node.keywordToken), "meta");
         }
         break;
     }
@@ -87048,35 +86980,35 @@ function createTypeChecker(host) {
   function hasParseDiagnostics(sourceFile) {
     return sourceFile.parseDiagnostics.length > 0;
   }
-  function grammarErrorOnFirstToken(node, message, arg0, arg1, arg2) {
+  function grammarErrorOnFirstToken(node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
     if (!hasParseDiagnostics(sourceFile)) {
       const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
-      diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, arg0, arg1, arg2));
+      diagnostics.add(createFileDiagnostic(sourceFile, span.start, span.length, message, ...args));
       return true;
     }
     return false;
   }
-  function grammarErrorAtPos(nodeForSourceFile, start2, length2, message, arg0, arg1, arg2) {
+  function grammarErrorAtPos(nodeForSourceFile, start2, length2, message, ...args) {
     const sourceFile = getSourceFileOfNode(nodeForSourceFile);
     if (!hasParseDiagnostics(sourceFile)) {
-      diagnostics.add(createFileDiagnostic(sourceFile, start2, length2, message, arg0, arg1, arg2));
+      diagnostics.add(createFileDiagnostic(sourceFile, start2, length2, message, ...args));
       return true;
     }
     return false;
   }
-  function grammarErrorOnNodeSkippedOn(key, node, message, arg0, arg1, arg2) {
+  function grammarErrorOnNodeSkippedOn(key, node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
     if (!hasParseDiagnostics(sourceFile)) {
-      errorSkippedOn(key, node, message, arg0, arg1, arg2);
+      errorSkippedOn(key, node, message, ...args);
       return true;
     }
     return false;
   }
-  function grammarErrorOnNode(node, message, arg0, arg1, arg2) {
+  function grammarErrorOnNode(node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
     if (!hasParseDiagnostics(sourceFile)) {
-      diagnostics.add(createDiagnosticForNode(node, message, arg0, arg1, arg2));
+      diagnostics.add(createDiagnosticForNode(node, message, ...args));
       return true;
     }
     return false;
@@ -87221,7 +87153,7 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function grammarErrorAfterFirstToken(node, message, arg0, arg1, arg2) {
+  function grammarErrorAfterFirstToken(node, message, ...args) {
     const sourceFile = getSourceFileOfNode(node);
     if (!hasParseDiagnostics(sourceFile)) {
       const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
@@ -87231,9 +87163,7 @@ function createTypeChecker(host) {
         /*length*/
         0,
         message,
-        arg0,
-        arg1,
-        arg2
+        ...args
       ));
       return true;
     }
@@ -87379,6 +87309,10 @@ function createTypeChecker(host) {
     }
     return void 0;
   }
+  function getEffectivePropertyNameForPropertyNameNode(node) {
+    const name = getPropertyNameForPropertyNameNode(node);
+    return name ? name : isComputedPropertyName(node) && isEntityNameExpression(node.expression) ? tryGetNameFromEntityNameExpression(node.expression) : void 0;
+  }
 }
 function isNotAccessor(declaration) {
   return !isAccessor(declaration);
@@ -111731,8 +111665,7 @@ function emitFiles(resolver, host, targetSourceFile, { scriptTransformers, decla
   }
 }
 function createBuildInfo(program, bundle) {
-  const version2 = version;
-  return { bundle, program, version: version2 };
+  return { bundle, program, version };
 }
 function getBuildInfoText(buildInfo) {
   return JSON.stringify(buildInfo);
@@ -111820,10 +111753,10 @@ function emitUsingBuildInfo(config, host, getCommandLine, customTransformers) {
     /*separateBeginAndEnd*/
     true
   );
-  ts_performance_exports.mark("beforeEmit");
+  mark("beforeEmit");
   const result = emitUsingBuildInfoWorker(config, host, getCommandLine, customTransformers);
-  ts_performance_exports.mark("afterEmit");
-  ts_performance_exports.measure("Emit", "beforeEmit", "afterEmit");
+  mark("afterEmit");
+  measure("Emit", "beforeEmit", "afterEmit");
   (_b = tracing) == null ? void 0 : _b.pop();
   return result;
 }
@@ -115837,12 +115770,12 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     return cache[nodeId] || (cache[nodeId] = generateNameForNode(node, privateName, flags != null ? flags : 0 /* None */, formatGeneratedNamePart(prefix, generateName), formatGeneratedNamePart(suffix)));
   }
   function isUniqueName(name, privateName) {
-    return isFileLevelUniqueName2(name, privateName) && !isReservedName(name, privateName) && !generatedNames.has(name);
+    return isFileLevelUniqueNameInCurrentFile(name, privateName) && !isReservedName(name, privateName) && !generatedNames.has(name);
   }
   function isReservedName(name, privateName) {
     return privateName ? !!(reservedPrivateNames == null ? void 0 : reservedPrivateNames.has(name)) : !!(reservedNames == null ? void 0 : reservedNames.has(name));
   }
-  function isFileLevelUniqueName2(name, _isPrivate) {
+  function isFileLevelUniqueNameInCurrentFile(name, _isPrivate) {
     return currentSourceFile ? isFileLevelUniqueName(currentSourceFile, name, hasGlobalName) : true;
   }
   function isUniqueLocalName(name, container) {
@@ -115961,7 +115894,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
   function makeFileLevelOptimisticUniqueName(name) {
     return makeUniqueName2(
       name,
-      isFileLevelUniqueName2,
+      isFileLevelUniqueNameInCurrentFile,
       /*optimistic*/
       true,
       /*scoped*/
@@ -116141,7 +116074,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
       case 3 /* Unique */:
         return makeUniqueName2(
           idText(name),
-          autoGenerate.flags & 32 /* FileLevel */ ? isFileLevelUniqueName2 : isUniqueName,
+          autoGenerate.flags & 32 /* FileLevel */ ? isFileLevelUniqueNameInCurrentFile : isUniqueName,
           !!(autoGenerate.flags & 16 /* Optimistic */),
           !!(autoGenerate.flags & 8 /* ReservedInNestedScopes */),
           isPrivateIdentifier(name),
@@ -119216,12 +119149,12 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           }
         }
       }
-      function createDiagnosticForNodeArray2(nodes, message, arg0, arg1, arg2) {
+      function createDiagnosticForNodeArray2(nodes, message, ...args) {
         const start2 = nodes.pos;
-        return createFileDiagnostic(sourceFile, start2, nodes.end - start2, message, arg0, arg1, arg2);
+        return createFileDiagnostic(sourceFile, start2, nodes.end - start2, message, ...args);
       }
-      function createDiagnosticForNode2(node, message, arg0, arg1, arg2) {
-        return createDiagnosticForNodeInSourceFile(sourceFile, node, message, arg0, arg1, arg2);
+      function createDiagnosticForNode2(node, message, ...args) {
+        return createDiagnosticForNodeInSourceFile(sourceFile, node, message, ...args);
       }
     });
   }
@@ -119886,11 +119819,12 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         const unqualifiedLibName = removeSuffix(removePrefix(libName, "lib."), ".d.ts");
         const suggestion = getSpellingSuggestion(unqualifiedLibName, libs, identity);
         const diagnostic = suggestion ? Diagnostics.Cannot_find_lib_definition_for_0_Did_you_mean_1 : Diagnostics.Cannot_find_lib_definition_for_0;
+        const args = suggestion ? [libName, suggestion] : [libName];
         (fileProcessingDiagnostics || (fileProcessingDiagnostics = [])).push({
           kind: 0 /* FilePreprocessingReferencedDiagnostic */,
           reason: { kind: 7 /* LibReferenceDirective */, file: file.path, index },
           diagnostic,
-          args: [libName, suggestion]
+          args
         });
       }
     });
@@ -120355,7 +120289,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
   }
   function verifyDeprecatedCompilerOptions() {
-    function createDiagnostic(name, value, useInstead, message, arg0, arg1, arg2, arg3) {
+    function createDiagnostic(name, value, useInstead, message, ...args) {
       if (useInstead) {
         const details = chainDiagnosticMessages(
           /*details*/
@@ -120363,7 +120297,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           Diagnostics.Use_0_instead,
           useInstead
         );
-        const chain = chainDiagnosticMessages(details, message, arg0, arg1, arg2, arg3);
+        const chain = chainDiagnosticMessages(details, message, ...args);
         createDiagnosticForOption(
           /*onKey*/
           !value,
@@ -120380,10 +120314,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
           /*option2*/
           void 0,
           message,
-          arg0,
-          arg1,
-          arg2,
-          arg3
+          ...args
         );
       }
     }
@@ -120436,8 +120367,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     });
   }
   function verifyDeprecatedProjectReference(ref, parentFile, index) {
-    function createDiagnostic(_name, _value, _useInstead, message, arg0, arg1, arg2, arg3) {
-      createDiagnosticForReference(parentFile, index, message, arg0, arg1, arg2, arg3);
+    function createDiagnostic(_name, _value, _useInstead, message, ...args) {
+      createDiagnosticForReference(parentFile, index, message, ...args);
     }
     checkDeprecations("5.0", "5.5", createDiagnostic, (createDeprecatedDiagnostic) => {
       if (ref.prepend) {
@@ -120619,7 +120550,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       }
     });
   }
-  function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, arg0, arg1, arg2) {
+  function createDiagnosticForOptionPathKeyValue(key, valueIndex, message, ...args) {
     let needCompilerDiagnostic = true;
     const pathsSyntax = getOptionPathsSyntax();
     for (const pathProp of pathsSyntax) {
@@ -120627,17 +120558,17 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         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) {
@@ -120648,13 +120579,13 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         /*key2*/
         void 0,
         message,
-        arg0
+        ...args
       )) {
         needCompilerDiagnostic = false;
       }
     }
     if (needCompilerDiagnostic) {
-      programDiagnostics.add(createCompilerDiagnostic(message, arg0));
+      programDiagnostics.add(createCompilerDiagnostic(message, ...args));
     }
   }
   function getOptionsSyntaxByName(name) {
@@ -120684,7 +120615,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       option3
     );
   }
-  function createOptionValueDiagnostic(option1, message, arg0, arg1) {
+  function createOptionValueDiagnostic(option1, message, ...args) {
     createDiagnosticForOption(
       /*onKey*/
       false,
@@ -120692,29 +120623,28 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
       /*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));
       }
     }
   }
@@ -120733,13 +120663,13 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
     }
     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;
@@ -121660,16 +121590,16 @@ function convertToDiagnostics(diagnostics, newProgram) {
     return emptyArray;
   let buildInfoDirectory;
   return diagnostics.map((diagnostic) => {
-    const result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPath3);
+    const result = convertToDiagnosticRelatedInformation(diagnostic, newProgram, toPathInBuildInfoDirectory);
     result.reportsUnnecessary = diagnostic.reportsUnnecessary;
     result.reportsDeprecated = diagnostic.reportDeprecated;
     result.source = diagnostic.source;
     result.skippedOn = diagnostic.skippedOn;
     const { relatedInformation } = diagnostic;
-    result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, newProgram, toPath3)) : [] : void 0;
+    result.relatedInformation = relatedInformation ? relatedInformation.length ? relatedInformation.map((r) => convertToDiagnosticRelatedInformation(r, newProgram, toPathInBuildInfoDirectory)) : [] : void 0;
     return result;
   });
-  function toPath3(path) {
+  function toPathInBuildInfoDirectory(path) {
     buildInfoDirectory != null ? buildInfoDirectory : buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(getTsBuildInfoEmitOutputFilePath(newProgram.getCompilerOptions()), newProgram.getCurrentDirectory()));
     return toPath(path, buildInfoDirectory, newProgram.getCanonicalFileName);
   }
@@ -122577,7 +122507,7 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
   const buildInfoDirectory = getDirectoryPath(getNormalizedAbsolutePath(buildInfoPath, host.getCurrentDirectory()));
   const getCanonicalFileName = createGetCanonicalFileName(host.useCaseSensitiveFileNames());
   let state;
-  const filePaths = (_a2 = program.fileNames) == null ? void 0 : _a2.map(toPath3);
+  const filePaths = (_a2 = program.fileNames) == null ? void 0 : _a2.map(toPathInBuildInfoDirectory);
   let filePathsSetList;
   const latestChangedDtsFile = program.latestChangedDtsFile ? toAbsolutePath(program.latestChangedDtsFile) : void 0;
   if (isProgramBundleEmitBuildInfo(program)) {
@@ -122658,7 +122588,7 @@ function createBuilderProgramUsingProgramBuildInfo(buildInfo, buildInfoPath, hos
     close: noop,
     hasChangedEmitSignature: returnFalse
   };
-  function toPath3(path) {
+  function toPathInBuildInfoDirectory(path) {
     return toPath(path, buildInfoDirectory, getCanonicalFileName);
   }
   function toAbsolutePath(path) {
@@ -123704,15 +123634,13 @@ function getErrorSummaryText(errorCount, filesInError, newLine, host) {
   const nonNilFiles = filesInError.filter((fileInError) => fileInError !== void 0);
   const distinctFileNamesWithLines = nonNilFiles.map((fileInError) => `${fileInError.fileName}:${fileInError.line}`).filter((value, index, self) => self.indexOf(value) === index);
   const firstFileReference = nonNilFiles[0] && prettyPathForFileError(nonNilFiles[0], host.getCurrentDirectory());
-  const d = errorCount === 1 ? createCompilerDiagnostic(
-    filesInError[0] !== void 0 ? Diagnostics.Found_1_error_in_1 : Diagnostics.Found_1_error,
-    errorCount,
-    firstFileReference
-  ) : createCompilerDiagnostic(
-    distinctFileNamesWithLines.length === 0 ? Diagnostics.Found_0_errors : distinctFileNamesWithLines.length === 1 ? Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1 : Diagnostics.Found_0_errors_in_1_files,
-    errorCount,
-    distinctFileNamesWithLines.length === 1 ? firstFileReference : distinctFileNamesWithLines.length
-  );
+  let messageAndArgs;
+  if (errorCount === 1) {
+    messageAndArgs = filesInError[0] !== void 0 ? [Diagnostics.Found_1_error_in_0, firstFileReference] : [Diagnostics.Found_1_error];
+  } else {
+    messageAndArgs = distinctFileNamesWithLines.length === 0 ? [Diagnostics.Found_0_errors, errorCount] : distinctFileNamesWithLines.length === 1 ? [Diagnostics.Found_0_errors_in_the_same_file_starting_at_Colon_1, errorCount, firstFileReference] : [Diagnostics.Found_0_errors_in_1_files, errorCount, distinctFileNamesWithLines.length];
+  }
+  const d = createCompilerDiagnostic(...messageAndArgs);
   const suffix = distinctFileNamesWithLines.length > 1 ? createTabularErrorsDisplay(nonNilFiles, host) : "";
   return `${newLine}${flattenDiagnosticMessageText(d.messageText, newLine)}${newLine}${newLine}${suffix}`;
 }
@@ -123922,15 +123850,15 @@ function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) {
         toFileName(referencedResolvedRef.sourceFile.fileName, fileNameConvertor),
         options.outFile ? "--outFile" : "--out"
       );
-    case 8 /* AutomaticTypeDirectiveFile */:
+    case 8 /* AutomaticTypeDirectiveFile */: {
+      const messageAndArgs = options.types ? reason.packageId ? [Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1, reason.typeReference, packageIdToString(reason.packageId)] : [Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions, reason.typeReference] : reason.packageId ? [Diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1, reason.typeReference, packageIdToString(reason.packageId)] : [Diagnostics.Entry_point_for_implicit_type_library_0, reason.typeReference];
       return chainDiagnosticMessages(
         /*details*/
         void 0,
-        options.types ? reason.packageId ? Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions_with_packageId_1 : Diagnostics.Entry_point_of_type_library_0_specified_in_compilerOptions : reason.packageId ? Diagnostics.Entry_point_for_implicit_type_library_0_with_packageId_1 : Diagnostics.Entry_point_for_implicit_type_library_0,
-        reason.typeReference,
-        reason.packageId && packageIdToString(reason.packageId)
+        ...messageAndArgs
       );
-    case 6 /* LibFile */:
+    }
+    case 6 /* LibFile */: {
       if (reason.index !== void 0)
         return chainDiagnosticMessages(
           /*details*/
@@ -123939,12 +123867,13 @@ function fileIncludeReasonToDiagnostics(program, reason, fileNameConvertor) {
           options.lib[reason.index]
         );
       const target = forEachEntry(targetOptionDeclaration.type, (value, key) => value === getEmitScriptTarget(options) ? key : void 0);
+      const messageAndArgs = target ? [Diagnostics.Default_library_for_target_0, target] : [Diagnostics.Default_library];
       return chainDiagnosticMessages(
         /*details*/
         void 0,
-        target ? Diagnostics.Default_library_for_target_0 : Diagnostics.Default_library,
-        target
+        ...messageAndArgs
       );
+    }
     default:
       Debug.assertNever(reason);
   }
@@ -128929,9 +128858,6 @@ function isStringAndEmptyAnonymousObjectIntersection(type) {
   const { types, checker } = type;
   return types.length === 2 && (areIntersectedTypesAvoidingStringReduction(checker, types[0], types[1]) || areIntersectedTypesAvoidingStringReduction(checker, types[1], types[0]));
 }
-function isPunctuation(kind) {
-  return 18 /* FirstPunctuation */ <= kind && kind <= 78 /* LastPunctuation */;
-}
 function isInsideTemplateLiteral(node, position, sourceFile) {
   return isTemplateLiteralKind(node.kind) && (node.getStart(sourceFile) < position && position < node.end) || !!node.isUnterminated && position === node.end;
 }
@@ -134530,6 +134456,234 @@ function cleanText(text) {
   return text.replace(/\\?(\r?\n|\r|\u2028|\u2029)/g, "");
 }
 
+// src/services/classifier2020.ts
+var TokenEncodingConsts = /* @__PURE__ */ ((TokenEncodingConsts2) => {
+  TokenEncodingConsts2[TokenEncodingConsts2["typeOffset"] = 8] = "typeOffset";
+  TokenEncodingConsts2[TokenEncodingConsts2["modifierMask"] = 255] = "modifierMask";
+  return TokenEncodingConsts2;
+})(TokenEncodingConsts || {});
+var TokenType = /* @__PURE__ */ ((TokenType2) => {
+  TokenType2[TokenType2["class"] = 0] = "class";
+  TokenType2[TokenType2["enum"] = 1] = "enum";
+  TokenType2[TokenType2["interface"] = 2] = "interface";
+  TokenType2[TokenType2["namespace"] = 3] = "namespace";
+  TokenType2[TokenType2["typeParameter"] = 4] = "typeParameter";
+  TokenType2[TokenType2["type"] = 5] = "type";
+  TokenType2[TokenType2["parameter"] = 6] = "parameter";
+  TokenType2[TokenType2["variable"] = 7] = "variable";
+  TokenType2[TokenType2["enumMember"] = 8] = "enumMember";
+  TokenType2[TokenType2["property"] = 9] = "property";
+  TokenType2[TokenType2["function"] = 10] = "function";
+  TokenType2[TokenType2["member"] = 11] = "member";
+  return TokenType2;
+})(TokenType || {});
+var TokenModifier = /* @__PURE__ */ ((TokenModifier2) => {
+  TokenModifier2[TokenModifier2["declaration"] = 0] = "declaration";
+  TokenModifier2[TokenModifier2["static"] = 1] = "static";
+  TokenModifier2[TokenModifier2["async"] = 2] = "async";
+  TokenModifier2[TokenModifier2["readonly"] = 3] = "readonly";
+  TokenModifier2[TokenModifier2["defaultLibrary"] = 4] = "defaultLibrary";
+  TokenModifier2[TokenModifier2["local"] = 5] = "local";
+  return TokenModifier2;
+})(TokenModifier || {});
+function getSemanticClassifications2(program, cancellationToken, sourceFile, span) {
+  const classifications = getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span);
+  Debug.assert(classifications.spans.length % 3 === 0);
+  const dense = classifications.spans;
+  const result = [];
+  for (let i = 0; i < dense.length; i += 3) {
+    result.push({
+      textSpan: createTextSpan(dense[i], dense[i + 1]),
+      classificationType: dense[i + 2]
+    });
+  }
+  return result;
+}
+function getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span) {
+  return {
+    spans: getSemanticTokens(program, sourceFile, span, cancellationToken),
+    endOfLineState: 0 /* None */
+  };
+}
+function getSemanticTokens(program, sourceFile, span, cancellationToken) {
+  const resultTokens = [];
+  const collector = (node, typeIdx, modifierSet) => {
+    resultTokens.push(node.getStart(sourceFile), node.getWidth(sourceFile), (typeIdx + 1 << 8 /* typeOffset */) + modifierSet);
+  };
+  if (program && sourceFile) {
+    collectTokens(program, sourceFile, span, collector, cancellationToken);
+  }
+  return resultTokens;
+}
+function collectTokens(program, sourceFile, span, collector, cancellationToken) {
+  const typeChecker = program.getTypeChecker();
+  let inJSXElement = false;
+  function visit(node) {
+    switch (node.kind) {
+      case 265 /* ModuleDeclaration */:
+      case 261 /* ClassDeclaration */:
+      case 262 /* InterfaceDeclaration */:
+      case 260 /* FunctionDeclaration */:
+      case 229 /* ClassExpression */:
+      case 216 /* FunctionExpression */:
+      case 217 /* ArrowFunction */:
+        cancellationToken.throwIfCancellationRequested();
+    }
+    if (!node || !textSpanIntersectsWith(span, node.pos, node.getFullWidth()) || node.getFullWidth() === 0) {
+      return;
+    }
+    const prevInJSXElement = inJSXElement;
+    if (isJsxElement(node) || isJsxSelfClosingElement(node)) {
+      inJSXElement = true;
+    }
+    if (isJsxExpression(node)) {
+      inJSXElement = false;
+    }
+    if (isIdentifier(node) && !inJSXElement && !inImportClause(node) && !isInfinityOrNaNString(node.escapedText)) {
+      let symbol = typeChecker.getSymbolAtLocation(node);
+      if (symbol) {
+        if (symbol.flags & 2097152 /* Alias */) {
+          symbol = typeChecker.getAliasedSymbol(symbol);
+        }
+        let typeIdx = classifySymbol2(symbol, getMeaningFromLocation(node));
+        if (typeIdx !== void 0) {
+          let modifierSet = 0;
+          if (node.parent) {
+            const parentIsDeclaration = isBindingElement(node.parent) || tokenFromDeclarationMapping.get(node.parent.kind) === typeIdx;
+            if (parentIsDeclaration && node.parent.name === node) {
+              modifierSet = 1 << 0 /* declaration */;
+            }
+          }
+          if (typeIdx === 6 /* parameter */ && isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
+            typeIdx = 9 /* property */;
+          }
+          typeIdx = reclassifyByType(typeChecker, node, typeIdx);
+          const decl = symbol.valueDeclaration;
+          if (decl) {
+            const modifiers = getCombinedModifierFlags(decl);
+            const nodeFlags = getCombinedNodeFlags(decl);
+            if (modifiers & 32 /* Static */) {
+              modifierSet |= 1 << 1 /* static */;
+            }
+            if (modifiers & 512 /* Async */) {
+              modifierSet |= 1 << 2 /* async */;
+            }
+            if (typeIdx !== 0 /* class */ && typeIdx !== 2 /* interface */) {
+              if (modifiers & 64 /* Readonly */ || nodeFlags & 2 /* Const */ || symbol.getFlags() & 8 /* EnumMember */) {
+                modifierSet |= 1 << 3 /* readonly */;
+              }
+            }
+            if ((typeIdx === 7 /* variable */ || typeIdx === 10 /* function */) && isLocalDeclaration(decl, sourceFile)) {
+              modifierSet |= 1 << 5 /* local */;
+            }
+            if (program.isSourceFileDefaultLibrary(decl.getSourceFile())) {
+              modifierSet |= 1 << 4 /* defaultLibrary */;
+            }
+          } else if (symbol.declarations && symbol.declarations.some((d) => program.isSourceFileDefaultLibrary(d.getSourceFile()))) {
+            modifierSet |= 1 << 4 /* defaultLibrary */;
+          }
+          collector(node, typeIdx, modifierSet);
+        }
+      }
+    }
+    forEachChild(node, visit);
+    inJSXElement = prevInJSXElement;
+  }
+  visit(sourceFile);
+}
+function classifySymbol2(symbol, meaning) {
+  const flags = symbol.getFlags();
+  if (flags & 32 /* Class */) {
+    return 0 /* class */;
+  } else if (flags & 384 /* Enum */) {
+    return 1 /* enum */;
+  } else if (flags & 524288 /* TypeAlias */) {
+    return 5 /* type */;
+  } else if (flags & 64 /* Interface */) {
+    if (meaning & 2 /* Type */) {
+      return 2 /* interface */;
+    }
+  } else if (flags & 262144 /* TypeParameter */) {
+    return 4 /* typeParameter */;
+  }
+  let decl = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];
+  if (decl && isBindingElement(decl)) {
+    decl = getDeclarationForBindingElement(decl);
+  }
+  return decl && tokenFromDeclarationMapping.get(decl.kind);
+}
+function reclassifyByType(typeChecker, node, typeIdx) {
+  if (typeIdx === 7 /* variable */ || typeIdx === 9 /* property */ || typeIdx === 6 /* parameter */) {
+    const type = typeChecker.getTypeAtLocation(node);
+    if (type) {
+      const test = (condition) => {
+        return condition(type) || type.isUnion() && type.types.some(condition);
+      };
+      if (typeIdx !== 6 /* parameter */ && test((t) => t.getConstructSignatures().length > 0)) {
+        return 0 /* class */;
+      }
+      if (test((t) => t.getCallSignatures().length > 0) && !test((t) => t.getProperties().length > 0) || isExpressionInCallExpression(node)) {
+        return typeIdx === 9 /* property */ ? 11 /* member */ : 10 /* function */;
+      }
+    }
+  }
+  return typeIdx;
+}
+function isLocalDeclaration(decl, sourceFile) {
+  if (isBindingElement(decl)) {
+    decl = getDeclarationForBindingElement(decl);
+  }
+  if (isVariableDeclaration(decl)) {
+    return (!isSourceFile(decl.parent.parent.parent) || isCatchClause(decl.parent)) && decl.getSourceFile() === sourceFile;
+  } else if (isFunctionDeclaration(decl)) {
+    return !isSourceFile(decl.parent) && decl.getSourceFile() === sourceFile;
+  }
+  return false;
+}
+function getDeclarationForBindingElement(element) {
+  while (true) {
+    if (isBindingElement(element.parent.parent)) {
+      element = element.parent.parent;
+    } else {
+      return element.parent.parent;
+    }
+  }
+}
+function inImportClause(node) {
+  const parent2 = node.parent;
+  return parent2 && (isImportClause(parent2) || isImportSpecifier(parent2) || isNamespaceImport(parent2));
+}
+function isExpressionInCallExpression(node) {
+  while (isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
+    node = node.parent;
+  }
+  return isCallExpression(node.parent) && node.parent.expression === node;
+}
+function isRightSideOfQualifiedNameOrPropertyAccess2(node) {
+  return isQualifiedName(node.parent) && node.parent.right === node || isPropertyAccessExpression(node.parent) && node.parent.name === node;
+}
+var tokenFromDeclarationMapping = /* @__PURE__ */ new Map([
+  [258 /* VariableDeclaration */, 7 /* variable */],
+  [167 /* Parameter */, 6 /* parameter */],
+  [170 /* PropertyDeclaration */, 9 /* property */],
+  [265 /* ModuleDeclaration */, 3 /* namespace */],
+  [264 /* EnumDeclaration */, 1 /* enum */],
+  [303 /* EnumMember */, 8 /* enumMember */],
+  [261 /* ClassDeclaration */, 0 /* class */],
+  [172 /* MethodDeclaration */, 11 /* member */],
+  [260 /* FunctionDeclaration */, 10 /* function */],
+  [216 /* FunctionExpression */, 10 /* function */],
+  [171 /* MethodSignature */, 11 /* member */],
+  [175 /* GetAccessor */, 9 /* property */],
+  [176 /* SetAccessor */, 9 /* property */],
+  [169 /* PropertySignature */, 9 /* property */],
+  [262 /* InterfaceDeclaration */, 2 /* interface */],
+  [263 /* TypeAliasDeclaration */, 5 /* type */],
+  [166 /* TypeParameter */, 4 /* typeParameter */],
+  [300 /* PropertyAssignment */, 9 /* property */],
+  [301 /* ShorthandPropertyAssignment */, 9 /* property */]
+]);
+
 // src/services/services.ts
 var servicesVersion = "0.8";
 function createNode(kind, pos, end, parent2) {
@@ -135962,7 +136116,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     synchronizeHostData();
     const responseFormat = format || "original" /* Original */;
     if (responseFormat === "2020" /* TwentyTwenty */) {
-      return ts_classifier_exports.v2020.getSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span);
+      return getSemanticClassifications2(program, cancellationToken, getValidSourceFile(fileName), span);
     } else {
       return getSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span);
     }
@@ -135973,7 +136127,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
     if (responseFormat === "original" /* Original */) {
       return getEncodedSemanticClassifications(program.getTypeChecker(), cancellationToken, getValidSourceFile(fileName), program.getClassifiableNames(), span);
     } else {
-      return ts_classifier_exports.v2020.getEncodedSemanticClassifications(program, cancellationToken, getValidSourceFile(fileName), span);
+      return getEncodedSemanticClassifications2(program, cancellationToken, getValidSourceFile(fileName), span);
     }
   }
   function getSyntacticClassifications2(fileName, span) {
@@ -138540,234 +138694,6 @@ __export(ts_classifier_v2020_exports, {
   getSemanticClassifications: () => getSemanticClassifications2
 });
 
-// src/services/classifier2020.ts
-var TokenEncodingConsts = /* @__PURE__ */ ((TokenEncodingConsts2) => {
-  TokenEncodingConsts2[TokenEncodingConsts2["typeOffset"] = 8] = "typeOffset";
-  TokenEncodingConsts2[TokenEncodingConsts2["modifierMask"] = 255] = "modifierMask";
-  return TokenEncodingConsts2;
-})(TokenEncodingConsts || {});
-var TokenType = /* @__PURE__ */ ((TokenType2) => {
-  TokenType2[TokenType2["class"] = 0] = "class";
-  TokenType2[TokenType2["enum"] = 1] = "enum";
-  TokenType2[TokenType2["interface"] = 2] = "interface";
-  TokenType2[TokenType2["namespace"] = 3] = "namespace";
-  TokenType2[TokenType2["typeParameter"] = 4] = "typeParameter";
-  TokenType2[TokenType2["type"] = 5] = "type";
-  TokenType2[TokenType2["parameter"] = 6] = "parameter";
-  TokenType2[TokenType2["variable"] = 7] = "variable";
-  TokenType2[TokenType2["enumMember"] = 8] = "enumMember";
-  TokenType2[TokenType2["property"] = 9] = "property";
-  TokenType2[TokenType2["function"] = 10] = "function";
-  TokenType2[TokenType2["member"] = 11] = "member";
-  return TokenType2;
-})(TokenType || {});
-var TokenModifier = /* @__PURE__ */ ((TokenModifier2) => {
-  TokenModifier2[TokenModifier2["declaration"] = 0] = "declaration";
-  TokenModifier2[TokenModifier2["static"] = 1] = "static";
-  TokenModifier2[TokenModifier2["async"] = 2] = "async";
-  TokenModifier2[TokenModifier2["readonly"] = 3] = "readonly";
-  TokenModifier2[TokenModifier2["defaultLibrary"] = 4] = "defaultLibrary";
-  TokenModifier2[TokenModifier2["local"] = 5] = "local";
-  return TokenModifier2;
-})(TokenModifier || {});
-function getSemanticClassifications2(program, cancellationToken, sourceFile, span) {
-  const classifications = getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span);
-  Debug.assert(classifications.spans.length % 3 === 0);
-  const dense = classifications.spans;
-  const result = [];
-  for (let i = 0; i < dense.length; i += 3) {
-    result.push({
-      textSpan: createTextSpan(dense[i], dense[i + 1]),
-      classificationType: dense[i + 2]
-    });
-  }
-  return result;
-}
-function getEncodedSemanticClassifications2(program, cancellationToken, sourceFile, span) {
-  return {
-    spans: getSemanticTokens(program, sourceFile, span, cancellationToken),
-    endOfLineState: 0 /* None */
-  };
-}
-function getSemanticTokens(program, sourceFile, span, cancellationToken) {
-  const resultTokens = [];
-  const collector = (node, typeIdx, modifierSet) => {
-    resultTokens.push(node.getStart(sourceFile), node.getWidth(sourceFile), (typeIdx + 1 << 8 /* typeOffset */) + modifierSet);
-  };
-  if (program && sourceFile) {
-    collectTokens(program, sourceFile, span, collector, cancellationToken);
-  }
-  return resultTokens;
-}
-function collectTokens(program, sourceFile, span, collector, cancellationToken) {
-  const typeChecker = program.getTypeChecker();
-  let inJSXElement = false;
-  function visit(node) {
-    switch (node.kind) {
-      case 265 /* ModuleDeclaration */:
-      case 261 /* ClassDeclaration */:
-      case 262 /* InterfaceDeclaration */:
-      case 260 /* FunctionDeclaration */:
-      case 229 /* ClassExpression */:
-      case 216 /* FunctionExpression */:
-      case 217 /* ArrowFunction */:
-        cancellationToken.throwIfCancellationRequested();
-    }
-    if (!node || !textSpanIntersectsWith(span, node.pos, node.getFullWidth()) || node.getFullWidth() === 0) {
-      return;
-    }
-    const prevInJSXElement = inJSXElement;
-    if (isJsxElement(node) || isJsxSelfClosingElement(node)) {
-      inJSXElement = true;
-    }
-    if (isJsxExpression(node)) {
-      inJSXElement = false;
-    }
-    if (isIdentifier(node) && !inJSXElement && !inImportClause(node) && !isInfinityOrNaNString(node.escapedText)) {
-      let symbol = typeChecker.getSymbolAtLocation(node);
-      if (symbol) {
-        if (symbol.flags & 2097152 /* Alias */) {
-          symbol = typeChecker.getAliasedSymbol(symbol);
-        }
-        let typeIdx = classifySymbol2(symbol, getMeaningFromLocation(node));
-        if (typeIdx !== void 0) {
-          let modifierSet = 0;
-          if (node.parent) {
-            const parentIsDeclaration = isBindingElement(node.parent) || tokenFromDeclarationMapping.get(node.parent.kind) === typeIdx;
-            if (parentIsDeclaration && node.parent.name === node) {
-              modifierSet = 1 << 0 /* declaration */;
-            }
-          }
-          if (typeIdx === 6 /* parameter */ && isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
-            typeIdx = 9 /* property */;
-          }
-          typeIdx = reclassifyByType(typeChecker, node, typeIdx);
-          const decl = symbol.valueDeclaration;
-          if (decl) {
-            const modifiers = getCombinedModifierFlags(decl);
-            const nodeFlags = getCombinedNodeFlags(decl);
-            if (modifiers & 32 /* Static */) {
-              modifierSet |= 1 << 1 /* static */;
-            }
-            if (modifiers & 512 /* Async */) {
-              modifierSet |= 1 << 2 /* async */;
-            }
-            if (typeIdx !== 0 /* class */ && typeIdx !== 2 /* interface */) {
-              if (modifiers & 64 /* Readonly */ || nodeFlags & 2 /* Const */ || symbol.getFlags() & 8 /* EnumMember */) {
-                modifierSet |= 1 << 3 /* readonly */;
-              }
-            }
-            if ((typeIdx === 7 /* variable */ || typeIdx === 10 /* function */) && isLocalDeclaration(decl, sourceFile)) {
-              modifierSet |= 1 << 5 /* local */;
-            }
-            if (program.isSourceFileDefaultLibrary(decl.getSourceFile())) {
-              modifierSet |= 1 << 4 /* defaultLibrary */;
-            }
-          } else if (symbol.declarations && symbol.declarations.some((d) => program.isSourceFileDefaultLibrary(d.getSourceFile()))) {
-            modifierSet |= 1 << 4 /* defaultLibrary */;
-          }
-          collector(node, typeIdx, modifierSet);
-        }
-      }
-    }
-    forEachChild(node, visit);
-    inJSXElement = prevInJSXElement;
-  }
-  visit(sourceFile);
-}
-function classifySymbol2(symbol, meaning) {
-  const flags = symbol.getFlags();
-  if (flags & 32 /* Class */) {
-    return 0 /* class */;
-  } else if (flags & 384 /* Enum */) {
-    return 1 /* enum */;
-  } else if (flags & 524288 /* TypeAlias */) {
-    return 5 /* type */;
-  } else if (flags & 64 /* Interface */) {
-    if (meaning & 2 /* Type */) {
-      return 2 /* interface */;
-    }
-  } else if (flags & 262144 /* TypeParameter */) {
-    return 4 /* typeParameter */;
-  }
-  let decl = symbol.valueDeclaration || symbol.declarations && symbol.declarations[0];
-  if (decl && isBindingElement(decl)) {
-    decl = getDeclarationForBindingElement(decl);
-  }
-  return decl && tokenFromDeclarationMapping.get(decl.kind);
-}
-function reclassifyByType(typeChecker, node, typeIdx) {
-  if (typeIdx === 7 /* variable */ || typeIdx === 9 /* property */ || typeIdx === 6 /* parameter */) {
-    const type = typeChecker.getTypeAtLocation(node);
-    if (type) {
-      const test = (condition) => {
-        return condition(type) || type.isUnion() && type.types.some(condition);
-      };
-      if (typeIdx !== 6 /* parameter */ && test((t) => t.getConstructSignatures().length > 0)) {
-        return 0 /* class */;
-      }
-      if (test((t) => t.getCallSignatures().length > 0) && !test((t) => t.getProperties().length > 0) || isExpressionInCallExpression(node)) {
-        return typeIdx === 9 /* property */ ? 11 /* member */ : 10 /* function */;
-      }
-    }
-  }
-  return typeIdx;
-}
-function isLocalDeclaration(decl, sourceFile) {
-  if (isBindingElement(decl)) {
-    decl = getDeclarationForBindingElement(decl);
-  }
-  if (isVariableDeclaration(decl)) {
-    return (!isSourceFile(decl.parent.parent.parent) || isCatchClause(decl.parent)) && decl.getSourceFile() === sourceFile;
-  } else if (isFunctionDeclaration(decl)) {
-    return !isSourceFile(decl.parent) && decl.getSourceFile() === sourceFile;
-  }
-  return false;
-}
-function getDeclarationForBindingElement(element) {
-  while (true) {
-    if (isBindingElement(element.parent.parent)) {
-      element = element.parent.parent;
-    } else {
-      return element.parent.parent;
-    }
-  }
-}
-function inImportClause(node) {
-  const parent2 = node.parent;
-  return parent2 && (isImportClause(parent2) || isImportSpecifier(parent2) || isNamespaceImport(parent2));
-}
-function isExpressionInCallExpression(node) {
-  while (isRightSideOfQualifiedNameOrPropertyAccess2(node)) {
-    node = node.parent;
-  }
-  return isCallExpression(node.parent) && node.parent.expression === node;
-}
-function isRightSideOfQualifiedNameOrPropertyAccess2(node) {
-  return isQualifiedName(node.parent) && node.parent.right === node || isPropertyAccessExpression(node.parent) && node.parent.name === node;
-}
-var tokenFromDeclarationMapping = /* @__PURE__ */ new Map([
-  [258 /* VariableDeclaration */, 7 /* variable */],
-  [167 /* Parameter */, 6 /* parameter */],
-  [170 /* PropertyDeclaration */, 9 /* property */],
-  [265 /* ModuleDeclaration */, 3 /* namespace */],
-  [264 /* EnumDeclaration */, 1 /* enum */],
-  [303 /* EnumMember */, 8 /* enumMember */],
-  [261 /* ClassDeclaration */, 0 /* class */],
-  [172 /* MethodDeclaration */, 11 /* member */],
-  [260 /* FunctionDeclaration */, 10 /* function */],
-  [216 /* FunctionExpression */, 10 /* function */],
-  [171 /* MethodSignature */, 11 /* member */],
-  [175 /* GetAccessor */, 9 /* property */],
-  [176 /* SetAccessor */, 9 /* property */],
-  [169 /* PropertySignature */, 9 /* property */],
-  [262 /* InterfaceDeclaration */, 2 /* interface */],
-  [263 /* TypeAliasDeclaration */, 5 /* type */],
-  [166 /* TypeParameter */, 4 /* typeParameter */],
-  [300 /* PropertyAssignment */, 9 /* property */],
-  [301 /* ShorthandPropertyAssignment */, 9 /* property */]
-]);
-
 // src/services/_namespaces/ts.codefix.ts
 var ts_codefix_exports = {};
 __export(ts_codefix_exports, {
@@ -168069,8 +167995,8 @@ var SmartIndenter;
 })(SmartIndenter || (SmartIndenter = {}));
 
 // src/server/_namespaces/ts.ts
-var ts_exports3 = {};
-__export(ts_exports3, {
+var ts_exports2 = {};
+__export(ts_exports2, {
   ANONYMOUS: () => ANONYMOUS,
   AccessFlags: () => AccessFlags,
   AssertionLevel: () => AssertionLevel,
@@ -168373,8 +168299,8 @@ __export(ts_exports3, {
   convertCompilerOptionsFromJson: () => convertCompilerOptionsFromJson,
   convertJsonOption: () => convertJsonOption,
   convertToBase64: () => convertToBase64,
+  convertToJson: () => convertToJson,
   convertToObject: () => convertToObject,
-  convertToObjectWorker: () => convertToObjectWorker,
   convertToOptionsWithAbsolutePaths: () => convertToOptionsWithAbsolutePaths,
   convertToRelativePath: () => convertToRelativePath,
   convertToTSConfig: () => convertToTSConfig,
@@ -169520,6 +169446,7 @@ __export(ts_exports3, {
   isJsxText: () => isJsxText,
   isJumpStatementTarget: () => isJumpStatementTarget,
   isKeyword: () => isKeyword,
+  isKeywordOrPunctuation: () => isKeywordOrPunctuation,
   isKnownSymbol: () => isKnownSymbol,
   isLabelName: () => isLabelName,
   isLabelOfLabeledStatement: () => isLabelOfLabeledStatement,
@@ -172982,7 +172909,7 @@ var Project3 = class {
         serverHost: this.projectService.host,
         session: this.projectService.session
       };
-      const pluginModule = pluginModuleFactory({ typescript: ts_exports3 });
+      const pluginModule = pluginModuleFactory({ typescript: ts_exports2 });
       const newLS = pluginModule.create(info);
       for (const k of Object.keys(this.languageService)) {
         if (!(k in newLS)) {
@@ -182338,8 +182265,8 @@ start(initializeNodeSystem(), require("os").platform());
   convertCompilerOptionsFromJson,
   convertJsonOption,
   convertToBase64,
+  convertToJson,
   convertToObject,
-  convertToObjectWorker,
   convertToOptionsWithAbsolutePaths,
   convertToRelativePath,
   convertToTSConfig,
@@ -183485,6 +183412,7 @@ start(initializeNodeSystem(), require("os").platform());
   isJsxText,
   isJumpStatementTarget,
   isKeyword,
+  isKeywordOrPunctuation,
   isKnownSymbol,
   isLabelName,
   isLabelOfLabeledStatement,