@typescript-deploys/pr-build 5.7.0-pr-59767-2 → 5.7.0-pr-59860-2

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-insiders.20240826`;
+var version = `${versionMajorMinor}.0-insiders.20240904`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -426,7 +426,10 @@ function deduplicateSorted(array, comparer) {
   for (let i = 1; i < array.length; i++) {
     const next = array[i];
     switch (comparer(next, last2)) {
+      // equality comparison
       case true:
+      // relational comparison
+      // falls through
       case 0 /* EqualTo */:
         continue;
       case -1 /* LessThan */:
@@ -1079,7 +1082,7 @@ function findBestPatternMatch(values, getPattern, candidate) {
   for (let i = 0; i < values.length; i++) {
     const v = values[i];
     const pattern = getPattern(v);
-    if (isPatternMatch(pattern, candidate) && pattern.prefix.length > longestMatchPrefixLength) {
+    if (pattern.prefix.length > longestMatchPrefixLength && isPatternMatch(pattern, candidate)) {
       longestMatchPrefixLength = pattern.prefix.length;
       matchedValue = v;
     }
@@ -3285,10 +3288,11 @@ var SyntaxKind = /* @__PURE__ */ ((SyntaxKind4) => {
   SyntaxKind4[SyntaxKind4["JSDocImportTag"] = 351] = "JSDocImportTag";
   SyntaxKind4[SyntaxKind4["SyntaxList"] = 352] = "SyntaxList";
   SyntaxKind4[SyntaxKind4["NotEmittedStatement"] = 353] = "NotEmittedStatement";
-  SyntaxKind4[SyntaxKind4["PartiallyEmittedExpression"] = 354] = "PartiallyEmittedExpression";
-  SyntaxKind4[SyntaxKind4["CommaListExpression"] = 355] = "CommaListExpression";
-  SyntaxKind4[SyntaxKind4["SyntheticReferenceExpression"] = 356] = "SyntheticReferenceExpression";
-  SyntaxKind4[SyntaxKind4["Count"] = 357] = "Count";
+  SyntaxKind4[SyntaxKind4["NotEmittedTypeElement"] = 354] = "NotEmittedTypeElement";
+  SyntaxKind4[SyntaxKind4["PartiallyEmittedExpression"] = 355] = "PartiallyEmittedExpression";
+  SyntaxKind4[SyntaxKind4["CommaListExpression"] = 356] = "CommaListExpression";
+  SyntaxKind4[SyntaxKind4["SyntheticReferenceExpression"] = 357] = "SyntheticReferenceExpression";
+  SyntaxKind4[SyntaxKind4["Count"] = 358] = "Count";
   SyntaxKind4[SyntaxKind4["FirstAssignment"] = 64 /* EqualsToken */] = "FirstAssignment";
   SyntaxKind4[SyntaxKind4["LastAssignment"] = 79 /* CaretEqualsToken */] = "LastAssignment";
   SyntaxKind4[SyntaxKind4["FirstCompoundAssignment"] = 65 /* PlusEqualsToken */] = "FirstCompoundAssignment";
@@ -4609,6 +4613,7 @@ function createSystemWatchFunctions({
         return generateWatchFileOptions(4 /* UseFsEvents */, 2 /* DynamicPriority */, options);
       case "UseFsEventsOnParentDirectory":
         useNonPollingWatchers2 = true;
+      // fall through
       default:
         return useNonPollingWatchers2 ? (
           // Use notifications from FS to watch with falling back to fs.watchFile
@@ -7269,7 +7274,6 @@ var Diagnostics = {
   Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0: diag(6418, 3 /* Message */, "Searching_all_ancestor_node_modules_directories_for_fallback_extensions_Colon_0_6418", "Searching all ancestor node_modules directories for fallback extensions: {0}."),
   Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors: diag(6419, 3 /* Message */, "Project_0_is_out_of_date_because_buildinfo_file_1_indicates_that_program_needs_to_report_errors_6419", "Project '{0}' is out of date because buildinfo file '{1}' indicates that program needs to report errors."),
   Project_0_is_out_of_date_because_1: diag(6420, 3 /* Message */, "Project_0_is_out_of_date_because_1_6420", "Project '{0}' is out of date because {1}."),
-  Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files: diag(6421, 3 /* Message */, "Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_i_6421", "Rewrite '.ts', '.tsx', '.mts', and '.cts' file extensions in relative import paths to their JavaScript equivalent in output files."),
   The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1: diag(6500, 3 /* Message */, "The_expected_type_comes_from_property_0_which_is_declared_here_on_type_1_6500", "The expected type comes from property '{0}' which is declared here on type '{1}'"),
   The_expected_type_comes_from_this_index_signature: diag(6501, 3 /* Message */, "The_expected_type_comes_from_this_index_signature_6501", "The expected type comes from this index signature."),
   The_expected_type_comes_from_the_return_type_of_this_signature: diag(6502, 3 /* Message */, "The_expected_type_comes_from_the_return_type_of_this_signature_6502", "The expected type comes from the return type of this signature."),
@@ -8136,6 +8140,7 @@ function computeLineStarts(text) {
         if (text.charCodeAt(pos) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
         result.push(lineStart);
         lineStart = pos;
@@ -8240,6 +8245,7 @@ function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments, inJSDoc) {
         if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
         pos++;
         if (stopAfterLineBreak) {
@@ -8386,6 +8392,7 @@ function iterateCommentRanges(reduce, text, pos, trailing, cb, state, initial) {
           if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
             pos++;
           }
+        // falls through
         case 10 /* lineFeed */:
           pos++;
           if (trailing) {
@@ -8951,12 +8958,16 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         if (pos >= end || !isDigit(charCodeUnchecked(pos))) {
           return "\0";
         }
+      // '\01', '\011'
+      // falls through
       case 49 /* _1 */:
       case 50 /* _2 */:
       case 51 /* _3 */:
         if (pos < end && isOctalDigit(charCodeUnchecked(pos))) {
           pos++;
         }
+      // '\17', '\177'
+      // falls through
       case 52 /* _4 */:
       case 53 /* _5 */:
       case 54 /* _6 */:
@@ -9054,10 +9065,13 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         }
         tokenFlags |= 4096 /* HexEscape */;
         return String.fromCharCode(parseInt(text.substring(start2 + 2, pos), 16));
+      // when encountering a LineContinuation (i.e. a backslash and a line terminator sequence),
+      // the line terminator is interpreted to be "the empty code unit sequence".
       case 13 /* carriageReturn */:
         if (pos < end && charCodeUnchecked(pos) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
       case 8232 /* lineSeparator */:
       case 8233 /* paragraphSeparator */:
@@ -9488,6 +9502,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             tokenFlags |= 256 /* OctalSpecifier */;
             return token = checkBigIntSuffix();
           }
+        // falls through
         case 49 /* _1 */:
         case 50 /* _2 */:
         case 51 /* _3 */:
@@ -10007,6 +10022,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
                 break;
               }
             }
+          // falls through
           case 42 /* asterisk */:
           case 43 /* plus */:
           case 63 /* question */:
@@ -10037,6 +10053,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             if (isInGroup) {
               return;
             }
+          // falls through
           case 93 /* closeBracket */:
           case 125 /* closeBrace */:
             if (anyUnicodeModeOrNonAnnexB || ch === 41 /* closeParen */) {
@@ -10099,6 +10116,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             error(Diagnostics.q_is_only_available_inside_character_class, pos - 2, 2);
             break;
           }
+        // falls through
         default:
           Debug.assert(scanCharacterClassEscape() || scanDecimalEscape() || scanCharacterEscape(
             /*atomEscape*/
@@ -10236,6 +10254,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
       let start2 = pos;
       let operand;
       switch (text.slice(pos, pos + 2)) {
+        // TODO: don't use slice
         case "--":
         case "&&":
           error(Diagnostics.Expected_a_class_set_operand);
@@ -10341,6 +10360,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         }
         start2 = pos;
         switch (text.slice(pos, pos + 2)) {
+          // TODO: don't use slice
           case "--":
           case "&&":
             error(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos, 2);
@@ -10438,6 +10458,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             }
           }
           pos--;
+        // falls through
         default:
           return scanClassSetCharacter();
       }
@@ -10584,6 +10605,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
           return true;
         case 80 /* P */:
           isCharacterComplement = true;
+        // falls through
         case 112 /* p */:
           pos++;
           if (charCodeChecked(pos) === 123 /* openBrace */) {
@@ -10891,6 +10913,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         if (charCodeUnchecked(pos) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
         tokenFlags |= 1 /* PrecedingLineBreak */;
         return token = 4 /* NewLineTrivia */;
@@ -11095,28 +11118,33 @@ function isExternalModuleNameRelative(moduleName) {
 function sortAndDeduplicateDiagnostics(diagnostics) {
   return sortAndDeduplicate(diagnostics, compareDiagnostics, diagnosticsEqualityComparer);
 }
+var targetToLibMap = /* @__PURE__ */ new Map([
+  [99 /* ESNext */, "lib.esnext.full.d.ts"],
+  [10 /* ES2023 */, "lib.es2023.full.d.ts"],
+  [9 /* ES2022 */, "lib.es2022.full.d.ts"],
+  [8 /* ES2021 */, "lib.es2021.full.d.ts"],
+  [7 /* ES2020 */, "lib.es2020.full.d.ts"],
+  [6 /* ES2019 */, "lib.es2019.full.d.ts"],
+  [5 /* ES2018 */, "lib.es2018.full.d.ts"],
+  [4 /* ES2017 */, "lib.es2017.full.d.ts"],
+  [3 /* ES2016 */, "lib.es2016.full.d.ts"],
+  [2 /* ES2015 */, "lib.es6.d.ts"]
+  // We don't use lib.es2015.full.d.ts due to breaking change.
+]);
 function getDefaultLibFileName(options) {
-  switch (getEmitScriptTarget(options)) {
+  const target = getEmitScriptTarget(options);
+  switch (target) {
     case 99 /* ESNext */:
-      return "lib.esnext.full.d.ts";
     case 10 /* ES2023 */:
-      return "lib.es2023.full.d.ts";
     case 9 /* ES2022 */:
-      return "lib.es2022.full.d.ts";
     case 8 /* ES2021 */:
-      return "lib.es2021.full.d.ts";
     case 7 /* ES2020 */:
-      return "lib.es2020.full.d.ts";
     case 6 /* ES2019 */:
-      return "lib.es2019.full.d.ts";
     case 5 /* ES2018 */:
-      return "lib.es2018.full.d.ts";
     case 4 /* ES2017 */:
-      return "lib.es2017.full.d.ts";
     case 3 /* ES2016 */:
-      return "lib.es2016.full.d.ts";
     case 2 /* ES2015 */:
-      return "lib.es6.d.ts";
+      return targetToLibMap.get(target);
     default:
       return "lib.d.ts";
   }
@@ -11916,7 +11944,7 @@ function isModifierLike(node) {
 }
 function isTypeElement(node) {
   const kind = node.kind;
-  return kind === 180 /* ConstructSignature */ || kind === 179 /* CallSignature */ || kind === 171 /* PropertySignature */ || kind === 173 /* MethodSignature */ || kind === 181 /* IndexSignature */ || kind === 177 /* GetAccessor */ || kind === 178 /* SetAccessor */;
+  return kind === 180 /* ConstructSignature */ || kind === 179 /* CallSignature */ || kind === 171 /* PropertySignature */ || kind === 173 /* MethodSignature */ || kind === 181 /* IndexSignature */ || kind === 177 /* GetAccessor */ || kind === 178 /* SetAccessor */ || kind === 354 /* NotEmittedTypeElement */;
 }
 function isObjectLiteralElementLike(node) {
   const kind = node.kind;
@@ -11975,7 +12003,9 @@ function isObjectBindingOrAssignmentElement(node) {
   switch (node.kind) {
     case 208 /* BindingElement */:
     case 303 /* PropertyAssignment */:
+    // AssignmentProperty
     case 304 /* ShorthandPropertyAssignment */:
+    // AssignmentProperty
     case 305 /* SpreadAssignment */:
       return true;
   }
@@ -11993,11 +12023,17 @@ function isArrayBindingOrAssignmentElement(node) {
   switch (node.kind) {
     case 208 /* BindingElement */:
     case 232 /* OmittedExpression */:
+    // Elision
     case 230 /* SpreadElement */:
+    // AssignmentRestElement
     case 209 /* ArrayLiteralExpression */:
+    // ArrayAssignmentPattern
     case 210 /* ObjectLiteralExpression */:
+    // ObjectAssignmentPattern
     case 80 /* Identifier */:
+    // DestructuringAssignmentTarget
     case 211 /* PropertyAccessExpression */:
+    // DestructuringAssignmentTarget
     case 212 /* ElementAccessExpression */:
       return true;
   }
@@ -12058,6 +12094,7 @@ function isLeftHandSideExpressionKind(kind) {
     case 218 /* FunctionExpression */:
     case 80 /* Identifier */:
     case 81 /* PrivateIdentifier */:
+    // technically this is only an Expression if it's in a `#field in expr` BinaryExpression
     case 14 /* RegularExpressionLiteral */:
     case 9 /* NumericLiteral */:
     case 10 /* BigIntLiteral */:
@@ -12073,6 +12110,7 @@ function isLeftHandSideExpressionKind(kind) {
     case 233 /* ExpressionWithTypeArguments */:
     case 236 /* MetaProperty */:
     case 102 /* ImportKeyword */:
+    // technically this is only an Expression if it's in a CallExpression
     case 282 /* MissingDeclaration */:
       return true;
     default:
@@ -12119,8 +12157,8 @@ function isExpressionKind(kind) {
     case 230 /* SpreadElement */:
     case 234 /* AsExpression */:
     case 232 /* OmittedExpression */:
-    case 355 /* CommaListExpression */:
-    case 354 /* PartiallyEmittedExpression */:
+    case 356 /* CommaListExpression */:
+    case 355 /* PartiallyEmittedExpression */:
     case 238 /* SatisfiesExpression */:
       return true;
     default:
@@ -13739,6 +13777,8 @@ function getErrorSpanForNode(sourceFile, node) {
       }
       return getSpanOfTokenAtPosition(sourceFile, pos2);
     }
+    // This list is a work in progress. Add missing node kinds to improve their error
+    // spans.
     case 260 /* VariableDeclaration */:
     case 208 /* BindingElement */:
     case 263 /* ClassDeclaration */:
@@ -13910,6 +13950,8 @@ function isPartOfTypeNode(node) {
       return isPartOfTypeExpressionWithTypeArguments(node);
     case 168 /* TypeParameter */:
       return node.parent.kind === 200 /* MappedType */ || node.parent.kind === 195 /* InferType */;
+    // Identifiers and qualified names may be type nodes, depending on their context. Climb
+    // above them to find the lowest container
     case 80 /* Identifier */:
       if (node.parent.kind === 166 /* QualifiedName */ && node.parent.right === node) {
         node = node.parent;
@@ -13917,6 +13959,7 @@ function isPartOfTypeNode(node) {
         node = node.parent;
       }
       Debug.assert(node.kind === 80 /* Identifier */ || node.kind === 166 /* QualifiedName */ || node.kind === 211 /* PropertyAccessExpression */, "'node' was expected to be a qualified name, identifier or property access in 'isPartOfTypeNode'.");
+    // falls through
     case 166 /* QualifiedName */:
     case 211 /* PropertyAccessExpression */:
     case 110 /* ThisKeyword */: {
@@ -14182,6 +14225,7 @@ function getThisContainer(node, includeArrowFunctions, includeClassComputedPrope
         if (!includeArrowFunctions) {
           continue;
         }
+      // falls through
       case 262 /* FunctionDeclaration */:
       case 218 /* FunctionExpression */:
       case 267 /* ModuleDeclaration */:
@@ -14204,6 +14248,8 @@ function getThisContainer(node, includeArrowFunctions, includeClassComputedPrope
 }
 function isThisContainerOrFunctionBlock(node) {
   switch (node.kind) {
+    // Arrow functions use the same scope, but may do so in a "delayed" manner
+    // For example, `const getThis = () => this` may be before a super() call in a derived constructor
     case 219 /* ArrowFunction */:
     case 262 /* FunctionDeclaration */:
     case 218 /* FunctionExpression */:
@@ -14270,6 +14316,7 @@ function getSuperContainer(node, stopOnFunctions) {
         if (!stopOnFunctions) {
           continue;
         }
+      // falls through
       case 172 /* PropertyDeclaration */:
       case 171 /* PropertySignature */:
       case 174 /* MethodDeclaration */:
@@ -14323,6 +14370,7 @@ function getEntityNameFromTypeNode(node) {
       return node.typeName;
     case 233 /* ExpressionWithTypeArguments */:
       return isEntityNameExpression(node.expression) ? node.expression : void 0;
+    // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s.
     case 80 /* Identifier */:
     case 166 /* QualifiedName */:
       return node;
@@ -14487,6 +14535,7 @@ function isExpressionNode(node) {
       if (node.parent.kind === 186 /* TypeQuery */ || isJSDocLinkLike(node.parent) || isJSDocNameReference(node.parent) || isJSDocMemberName(node.parent) || isJSXTagName(node)) {
         return true;
       }
+    // falls through
     case 9 /* NumericLiteral */:
     case 10 /* BigIntLiteral */:
     case 11 /* StringLiteral */:
@@ -15491,6 +15540,7 @@ function getFunctionFlags(node) {
       if (node.asteriskToken) {
         flags |= 1 /* Generator */;
       }
+    // falls through
     case 219 /* ArrowFunction */:
       if (hasSyntacticModifier(node, 1024 /* Async */)) {
         flags |= 2 /* Async */;
@@ -15725,7 +15775,7 @@ function getOperator(expression) {
 }
 function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
   switch (nodeKind) {
-    case 355 /* CommaListExpression */:
+    case 356 /* CommaListExpression */:
       return 0 /* Comma */;
     case 230 /* SpreadElement */:
       return 1 /* Spread */;
@@ -15757,6 +15807,7 @@ function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
         default:
           return getBinaryOperatorPrecedence(operatorKind);
       }
+    // TODO: Should prefix `++` and `--` be moved to the `Update` precedence?
     case 216 /* TypeAssertionExpression */:
     case 235 /* NonNullExpression */:
     case 224 /* PrefixUnaryExpression */:
@@ -17255,11 +17306,12 @@ function getLeftmostExpression(node, stopAtCallExpressions) {
         if (stopAtCallExpressions) {
           return node;
         }
+      // falls through
       case 234 /* AsExpression */:
       case 212 /* ElementAccessExpression */:
       case 211 /* PropertyAccessExpression */:
       case 235 /* NonNullExpression */:
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
       case 238 /* SatisfiesExpression */:
         node = node.expression;
         continue;
@@ -17646,12 +17698,6 @@ function createComputedCompilerOptions(options) {
   return options;
 }
 var computedOptions = createComputedCompilerOptions({
-  allowImportingTsExtensions: {
-    dependencies: ["rewriteRelativeImportExtensions"],
-    computeValue: (compilerOptions) => {
-      return !!(compilerOptions.allowImportingTsExtensions || compilerOptions.rewriteRelativeImportExtensions);
-    }
-  },
   target: {
     dependencies: ["module"],
     computeValue: (compilerOptions) => {
@@ -17865,7 +17911,6 @@ var computedOptions = createComputedCompilerOptions({
     }
   }
 });
-var getAllowImportingTsExtensions = computedOptions.allowImportingTsExtensions.computeValue;
 var getEmitScriptTarget = computedOptions.target.computeValue;
 var getEmitModuleKind = computedOptions.module.computeValue;
 var getEmitModuleResolutionKind = computedOptions.moduleResolution.computeValue;
@@ -18406,8 +18451,33 @@ function tryParsePattern(pattern) {
     suffix: pattern.substr(indexOfStar + 1)
   };
 }
+var parsedPatternsCache = /* @__PURE__ */ new WeakMap();
 function tryParsePatterns(paths) {
-  return mapDefined(getOwnKeys(paths), (path) => tryParsePattern(path));
+  let result = parsedPatternsCache.get(paths);
+  if (result !== void 0) {
+    return result;
+  }
+  let matchableStringSet;
+  let patterns;
+  const pathList = getOwnKeys(paths);
+  for (const path of pathList) {
+    const patternOrStr = tryParsePattern(path);
+    if (patternOrStr === void 0) {
+      continue;
+    } else if (typeof patternOrStr === "string") {
+      (matchableStringSet ?? (matchableStringSet = /* @__PURE__ */ new Set())).add(patternOrStr);
+    } else {
+      (patterns ?? (patterns = [])).push(patternOrStr);
+    }
+  }
+  parsedPatternsCache.set(
+    paths,
+    result = {
+      matchableStringSet,
+      patterns
+    }
+  );
+  return result;
 }
 function positionIsSynthesized(pos) {
   return !(pos >= 0);
@@ -18432,15 +18502,13 @@ var emptyFileSystemEntries = {
   files: emptyArray,
   directories: emptyArray
 };
-function matchPatternOrExact(patternOrStrings, candidate) {
-  const patterns = [];
-  for (const patternOrString of patternOrStrings) {
-    if (patternOrString === candidate) {
-      return candidate;
-    }
-    if (!isString(patternOrString)) {
-      patterns.push(patternOrString);
-    }
+function matchPatternOrExact(parsedPatterns, candidate) {
+  const { matchableStringSet, patterns } = parsedPatterns;
+  if (matchableStringSet == null ? void 0 : matchableStringSet.has(candidate)) {
+    return candidate;
+  }
+  if (patterns === void 0 || patterns.length === 0) {
+    return void 0;
   }
   return findBestPatternMatch(patterns, (_) => _, candidate);
 }
@@ -18517,6 +18585,7 @@ function isJsonEqual(a, b) {
 function parsePseudoBigInt(stringValue) {
   let log2Base;
   switch (stringValue.charCodeAt(1)) {
+    // "x" in "0x123"
     case 98 /* b */:
     case 66 /* B */:
       log2Base = 1;
@@ -18754,7 +18823,7 @@ function getContainingNodeArray(node) {
       return parent.types;
     case 189 /* TupleType */:
     case 209 /* ArrayLiteralExpression */:
-    case 355 /* CommaListExpression */:
+    case 356 /* CommaListExpression */:
     case 275 /* NamedImports */:
     case 279 /* NamedExports */:
       return parent.elements;
@@ -19187,6 +19256,7 @@ function createNameResolver({
         switch (location.kind) {
           case 307 /* SourceFile */:
             if (!isExternalOrCommonJsModule(location)) break;
+          // falls through
           case 267 /* ModuleDeclaration */:
             const moduleExports = ((_a = getSymbolOfDeclaration(location)) == null ? void 0 : _a.exports) || emptySymbols;
             if (location.kind === 307 /* SourceFile */ || isModuleDeclaration(location) && location.flags & 33554432 /* Ambient */ && !isGlobalScopeAugmentation(location)) {
@@ -19270,6 +19340,14 @@ function createNameResolver({
               }
             }
             break;
+          // It is not legal to reference a class's own type parameters from a computed property name that
+          // belongs to the class. For example:
+          //
+          //   function foo<T>() { return '' }
+          //   class C<T> { // <-- Class's own type parameter T
+          //       [foo<T>()]() { } // <-- Reference to T from class's own computed property
+          //   }
+          //
           case 167 /* ComputedPropertyName */:
             grandparent = location.parent.parent;
             if (isClassLike(grandparent) || grandparent.kind === 264 /* InterfaceDeclaration */) {
@@ -19285,6 +19363,7 @@ function createNameResolver({
             if (getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */) {
               break;
             }
+          // falls through
           case 174 /* MethodDeclaration */:
           case 176 /* Constructor */:
           case 177 /* GetAccessor */:
@@ -19929,6 +20008,7 @@ function createParenthesizerRules(factory2) {
   function parenthesizeConstituentTypeOfUnionType(type) {
     switch (type.kind) {
       case 192 /* UnionType */:
+      // Not strictly necessary, but a union containing a union should have been flattened
       case 193 /* IntersectionType */:
         return factory2.createParenthesizedType(type);
     }
@@ -20699,6 +20779,7 @@ function createNodeFactory(flags, baseFactory2) {
     createSyntheticExpression,
     createSyntaxList,
     createNotEmittedStatement,
+    createNotEmittedTypeElement,
     createPartiallyEmittedExpression,
     updatePartiallyEmittedExpression,
     createCommaListExpression,
@@ -23725,7 +23806,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function createPartiallyEmittedExpression(expression, original) {
-    const node = createBaseNode(354 /* PartiallyEmittedExpression */);
+    const node = createBaseNode(355 /* PartiallyEmittedExpression */);
     node.expression = expression;
     node.original = original;
     node.transformFlags |= propagateChildFlags(node.expression) | 1 /* ContainsTypeScript */;
@@ -23735,6 +23816,9 @@ function createNodeFactory(flags, baseFactory2) {
   function updatePartiallyEmittedExpression(node, expression) {
     return node.expression !== expression ? update(createPartiallyEmittedExpression(expression, node.original), node) : node;
   }
+  function createNotEmittedTypeElement() {
+    return createBaseNode(354 /* NotEmittedTypeElement */);
+  }
   function flattenCommaElements(node) {
     if (nodeIsSynthesized(node) && !isParseTreeNode(node) && !node.original && !node.emitNode && !node.id) {
       if (isCommaListExpression(node)) {
@@ -23747,7 +23831,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node;
   }
   function createCommaListExpression(elements) {
-    const node = createBaseNode(355 /* CommaListExpression */);
+    const node = createBaseNode(356 /* CommaListExpression */);
     node.elements = createNodeArray(sameFlatMap(elements, flattenCommaElements));
     node.transformFlags |= propagateChildrenFlags(node.elements);
     return node;
@@ -23756,7 +23840,7 @@ function createNodeFactory(flags, baseFactory2) {
     return node.elements !== elements ? update(createCommaListExpression(elements), node) : node;
   }
   function createSyntheticReferenceExpression(expression, thisArg) {
-    const node = createBaseNode(356 /* SyntheticReferenceExpression */);
+    const node = createBaseNode(357 /* SyntheticReferenceExpression */);
     node.expression = expression;
     node.thisArg = thisArg;
     node.transformFlags |= propagateChildFlags(node.expression) | propagateChildFlags(node.thisArg);
@@ -24003,7 +24087,7 @@ function createNodeFactory(flags, baseFactory2) {
         return updateNonNullExpression(outerExpression, expression);
       case 233 /* ExpressionWithTypeArguments */:
         return updateExpressionWithTypeArguments(outerExpression, expression, outerExpression.typeArguments);
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return updatePartiallyEmittedExpression(outerExpression, expression);
     }
   }
@@ -24548,7 +24632,7 @@ function getTransformFlagsSubtreeExclusions(kind) {
     case 216 /* TypeAssertionExpression */:
     case 238 /* SatisfiesExpression */:
     case 234 /* AsExpression */:
-    case 354 /* PartiallyEmittedExpression */:
+    case 355 /* PartiallyEmittedExpression */:
     case 217 /* ParenthesizedExpression */:
     case 108 /* SuperKeyword */:
       return -2147483648 /* OuterExpressionExcludes */;
@@ -26189,10 +26273,10 @@ function isMetaProperty(node) {
   return node.kind === 236 /* MetaProperty */;
 }
 function isPartiallyEmittedExpression(node) {
-  return node.kind === 354 /* PartiallyEmittedExpression */;
+  return node.kind === 355 /* PartiallyEmittedExpression */;
 }
 function isCommaListExpression(node) {
-  return node.kind === 355 /* CommaListExpression */;
+  return node.kind === 356 /* CommaListExpression */;
 }
 function isTemplateSpan(node) {
   return node.kind === 239 /* TemplateSpan */;
@@ -26321,7 +26405,7 @@ function isNotEmittedStatement(node) {
   return node.kind === 353 /* NotEmittedStatement */;
 }
 function isSyntheticReference(node) {
-  return node.kind === 356 /* SyntheticReferenceExpression */;
+  return node.kind === 357 /* SyntheticReferenceExpression */;
 }
 function isExternalModuleReference(node) {
   return node.kind === 283 /* ExternalModuleReference */;
@@ -26902,7 +26986,7 @@ function isOuterExpression(node, kinds = 31 /* All */) {
       return (kinds & 16 /* ExpressionsWithTypeArguments */) !== 0;
     case 235 /* NonNullExpression */:
       return (kinds & 4 /* NonNullAssertions */) !== 0;
-    case 354 /* PartiallyEmittedExpression */:
+    case 355 /* PartiallyEmittedExpression */:
       return (kinds & 8 /* PartiallyEmittedExpressions */) !== 0;
   }
   return false;
@@ -27342,10 +27426,13 @@ var BinaryExpressionState;
     switch (currentState) {
       case enter:
         if (machine.onLeft) return left;
+      // falls through
       case left:
         if (machine.onOperator) return operator;
+      // falls through
       case operator:
         if (machine.onRight) return right;
+      // falls through
       case right:
         return exit;
       case exit:
@@ -27973,7 +28060,7 @@ var forEachChildTable = {
   [282 /* MissingDeclaration */]: function forEachChildInMissingDeclaration(node, cbNode, cbNodes) {
     return visitNodes(cbNode, cbNodes, node.modifiers);
   },
-  [355 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) {
+  [356 /* CommaListExpression */]: function forEachChildInCommaListExpression(node, cbNode, cbNodes) {
     return visitNodes(cbNode, cbNodes, node.elements);
   },
   [284 /* JsxElement */]: function forEachChildInJsxElement(node, cbNode, cbNodes) {
@@ -28069,7 +28156,7 @@ var forEachChildTable = {
   [331 /* JSDocDeprecatedTag */]: forEachChildInJSDocTag,
   [337 /* JSDocOverrideTag */]: forEachChildInJSDocTag,
   [351 /* JSDocImportTag */]: forEachChildInJSDocImportTag,
-  [354 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
+  [355 /* PartiallyEmittedExpression */]: forEachChildInPartiallyEmittedExpression
 };
 function forEachChildInCallOrConstructSignature(node, cbNode, cbNodes) {
   return visitNodes(cbNode, cbNodes, node.typeParameters) || visitNodes(cbNode, cbNodes, node.parameters) || visitNode2(cbNode, node.type);
@@ -28424,6 +28511,7 @@ var Parser;
               expression2 = parseLiteralNode();
               break;
             }
+          // falls through
           default:
             expression2 = parseObjectLiteralExpression();
             break;
@@ -29345,6 +29433,7 @@ var Parser;
           case 25 /* DotToken */:
             return true;
         }
+      // falls through
       case 11 /* ArgumentExpressions */:
         return token() === 26 /* DotDotDotToken */ || isStartOfExpression();
       case 16 /* Parameters */:
@@ -29378,6 +29467,7 @@ var Parser;
         return true;
       case 26 /* Count */:
         return Debug.fail("ParsingContext.Count used as a context");
+      // Not a real context, only a marker.
       default:
         Debug.assertNever(parsingContext2, "Non-exhaustive case in 'isListElement'.");
     }
@@ -29694,6 +29784,7 @@ var Parser;
       case 3 /* SwitchClauseStatements */:
         return parseErrorAtCurrentToken(Diagnostics.Statement_expected);
       case 18 /* RestProperties */:
+      // fallthrough
       case 4 /* TypeMembers */:
         return parseErrorAtCurrentToken(Diagnostics.Property_or_signature_expected);
       case 5 /* ClassMembers */:
@@ -29741,6 +29832,7 @@ var Parser;
         return parseErrorAtCurrentToken(Diagnostics.Identifier_expected);
       case 26 /* Count */:
         return Debug.fail("ParsingContext.Count used as a context");
+      // Not a real context, only a marker.
       default:
         Debug.assertNever(context);
     }
@@ -30665,10 +30757,12 @@ var Parser;
         return tryParse(parseKeywordAndNoDot) || parseTypeReference();
       case 67 /* AsteriskEqualsToken */:
         scanner.reScanAsteriskEqualsToken();
+      // falls through
       case 42 /* AsteriskToken */:
         return parseJSDocAllType();
       case 61 /* QuestionQuestionToken */:
         scanner.reScanQuestionToken();
+      // falls through
       case 58 /* QuestionToken */:
         return parseJSDocUnknownOrNullableType();
       case 100 /* FunctionKeyword */:
@@ -31546,6 +31640,7 @@ var Parser;
         if (isAwaitExpression2()) {
           return parseAwaitExpression();
         }
+      // falls through
       default:
         return parseUpdateExpression();
     }
@@ -31565,6 +31660,8 @@ var Parser;
         if (languageVariant !== 1 /* JSX */) {
           return false;
         }
+      // We are in JSX context and the token is part of JSXElement.
+      // falls through
       default:
         return true;
     }
@@ -32138,10 +32235,16 @@ var Parser;
   }
   function canFollowTypeArgumentsInExpression() {
     switch (token()) {
+      // These tokens can follow a type argument list in a call expression.
       case 21 /* OpenParenToken */:
+      // foo<x>(
       case 15 /* NoSubstitutionTemplateLiteral */:
+      // foo<T> `...`
       case 16 /* TemplateHead */:
         return true;
+      // A type argument list followed by `<` never makes sense, and a type argument list followed
+      // by `>` is ambiguous with a (re-scanned) `>>` operator, so we disqualify both. Also, in
+      // this context, `+` and `-` are unary operators, not binary operators.
       case 30 /* LessThanToken */:
       case 32 /* GreaterThanToken */:
       case 40 /* PlusToken */:
@@ -32159,6 +32262,7 @@ var Parser;
             false
           );
         }
+      // falls through
       case 9 /* NumericLiteral */:
       case 10 /* BigIntLiteral */:
       case 11 /* StringLiteral */:
@@ -32662,6 +32766,27 @@ var Parser;
           return isUsingDeclaration();
         case 135 /* AwaitKeyword */:
           return isAwaitUsingDeclaration();
+        // 'declare', 'module', 'namespace', 'interface'* and 'type' are all legal JavaScript identifiers;
+        // however, an identifier cannot be followed by another identifier on the same line. This is what we
+        // count on to parse out the respective declarations. For instance, we exploit this to say that
+        //
+        //    namespace n
+        //
+        // can be none other than the beginning of a namespace declaration, but need to respect that JavaScript sees
+        //
+        //    namespace
+        //    n
+        //
+        // as the identifier 'namespace' on one line followed by the identifier 'n' on another.
+        // We need to look one token ahead to see if it permissible to try parsing a declaration.
+        //
+        // *Note*: 'interface' is actually a strict mode reserved word. So while
+        //
+        //   "use strict"
+        //   interface
+        //   I {}
+        //
+        // could be legal, it would add complexity for very little gain.
         case 120 /* InterfaceKeyword */:
         case 156 /* TypeKeyword */:
           return nextTokenIsIdentifierOnSameLine();
@@ -32734,6 +32859,9 @@ var Parser;
       case 111 /* ThrowKeyword */:
       case 113 /* TryKeyword */:
       case 89 /* DebuggerKeyword */:
+      // 'catch' and 'finally' do not actually indicate that the code is part of a statement,
+      // however, we say they are here so that we may gracefully parse them and error later.
+      // falls through
       case 85 /* CatchKeyword */:
       case 98 /* FinallyKeyword */:
         return true;
@@ -32872,6 +33000,8 @@ var Parser;
       case 111 /* ThrowKeyword */:
         return parseThrowStatement();
       case 113 /* TryKeyword */:
+      // Include 'catch' and 'finally' for error recovery.
+      // falls through
       case 85 /* CatchKeyword */:
       case 98 /* FinallyKeyword */:
         return parseTryStatement();
@@ -33290,10 +33420,15 @@ var Parser;
       }
       switch (token()) {
         case 21 /* OpenParenToken */:
+        // Method declaration
         case 30 /* LessThanToken */:
+        // Generic Method declaration
         case 54 /* ExclamationToken */:
+        // Non-null assertion on property name
         case 59 /* ColonToken */:
+        // Type Annotation for declaration
         case 64 /* EqualsToken */:
+        // Initializer for declaration
         case 58 /* QuestionToken */:
           return true;
         default:
@@ -34200,6 +34335,7 @@ var Parser;
                   linkEnd = scanner.getTokenEnd();
                   break;
                 }
+              // fallthrough if it's not a {@link sequence
               default:
                 state = 2 /* SavingComments */;
                 pushComment(scanner.getTokenText());
@@ -34458,6 +34594,8 @@ var Parser;
                   indent2 += 1;
                   break;
                 }
+              // record the * as a comment
+              // falls through
               default:
                 if (state !== 3 /* SavingBackticks */) {
                   state = 2 /* SavingComments */;
@@ -35538,6 +35676,7 @@ function processPragmasIntoFields(context, reportDiagnostic) {
       case "jsximportsource":
       case "jsxruntime":
         return;
+      // Accessed directly
       default:
         Debug.fail("Unhandled pragma kind");
     }
@@ -36659,15 +36798,6 @@ var commandOptionsWithoutBuild = [
     defaultValueDescription: false,
     transpileOptionValue: void 0
   },
-  {
-    name: "rewriteRelativeImportExtensions",
-    type: "boolean",
-    affectsSemanticDiagnostics: true,
-    affectsBuildInfo: true,
-    category: Diagnostics.Modules,
-    description: Diagnostics.Rewrite_ts_tsx_mts_and_cts_file_extensions_in_relative_import_paths_to_their_JavaScript_equivalent_in_output_files,
-    defaultValueDescription: false
-  },
   {
     name: "resolvePackageJsonExports",
     type: "boolean",
@@ -37400,6 +37530,7 @@ function parseOptionValue(args, i, diagnostics, opt, options, errors) {
         case "listOrElement":
           Debug.fail("listOrElement not supported here");
           break;
+        // If not a primitive, the possible types are specified in what is effectively a map of options.
         default:
           options[opt.name] = parseCustomTypeOption(opt, args[i], errors);
           i++;
@@ -37733,6 +37864,7 @@ function convertToJson(sourceFile, rootExpression, errors, returnValue, jsonConv
         return false;
       case 106 /* NullKeyword */:
         return null;
+      // eslint-disable-line no-restricted-syntax
       case 11 /* StringLiteral */:
         if (!isDoubleQuotedString(valueExpression)) {
           errors.push(createDiagnosticForNodeInSourceFile(sourceFile, valueExpression, Diagnostics.String_literal_with_double_quotes_expected));
@@ -38197,8 +38329,6 @@ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, exis
       validatedFilesSpecBeforeSubstitution,
       validatedIncludeSpecsBeforeSubstitution,
       validatedExcludeSpecsBeforeSubstitution,
-      pathPatterns: void 0,
-      // Initialized on first use
       isDefaultIncludeSpec
     };
   }
@@ -39823,8 +39953,7 @@ function tryLoadModuleUsingOptionalResolutionSettings(extensions, moduleName, co
   }
 }
 function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state) {
-  var _a;
-  const { baseUrl, paths, configFile } = state.compilerOptions;
+  const { baseUrl, paths } = state.compilerOptions;
   if (paths && !pathIsRelative(moduleName)) {
     if (state.traceEnabled) {
       if (baseUrl) {
@@ -39833,7 +39962,7 @@ function tryLoadModuleUsingPathsIfEligible(extensions, moduleName, loader, state
       trace(state.host, Diagnostics.paths_option_is_specified_looking_for_a_pattern_to_match_module_name_0, moduleName);
     }
     const baseDirectory = getPathsBasePath(state.compilerOptions, state.host);
-    const pathPatterns = (configFile == null ? void 0 : configFile.configFileSpecs) ? (_a = configFile.configFileSpecs).pathPatterns || (_a.pathPatterns = tryParsePatterns(paths)) : void 0;
+    const pathPatterns = tryParsePatterns(paths);
     return tryLoadModuleUsingPaths(
       extensions,
       moduleName,
@@ -40505,17 +40634,8 @@ function loadNodeModuleFromDirectoryWorker(extensions, candidate, onlyRecordFail
     if (state.traceEnabled) {
       trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, moduleName);
     }
-    const result = tryLoadModuleUsingPaths(
-      extensions,
-      moduleName,
-      candidate,
-      versionPaths.paths,
-      /*pathPatterns*/
-      void 0,
-      loader,
-      onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex,
-      state
-    );
+    const pathPatterns = tryParsePatterns(versionPaths.paths);
+    const result = tryLoadModuleUsingPaths(extensions, moduleName, candidate, versionPaths.paths, pathPatterns, loader, onlyRecordFailuresForPackageFile || onlyRecordFailuresForIndex, state);
     if (result) {
       return removeIgnoredPackageId(result.value);
     }
@@ -41107,17 +41227,8 @@ function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, node
       trace(state.host, Diagnostics.package_json_has_a_typesVersions_entry_0_that_matches_compiler_version_1_looking_for_a_pattern_to_match_module_name_2, versionPaths.version, version, rest);
     }
     const packageDirectoryExists = nodeModulesDirectoryExists && directoryProbablyExists(packageDirectory, state.host);
-    const fromPaths = tryLoadModuleUsingPaths(
-      extensions,
-      rest,
-      packageDirectory,
-      versionPaths.paths,
-      /*pathPatterns*/
-      void 0,
-      loader,
-      !packageDirectoryExists,
-      state
-    );
+    const pathPatterns = tryParsePatterns(versionPaths.paths);
+    const fromPaths = tryLoadModuleUsingPaths(extensions, rest, packageDirectory, versionPaths.paths, pathPatterns, loader, !packageDirectoryExists, state);
     if (fromPaths) {
       return fromPaths.value;
     }
@@ -41125,7 +41236,6 @@ function loadModuleFromSpecificNodeModulesDirectory(extensions, moduleName, node
   return loader(extensions, candidate, !nodeModulesDirectoryExists, state);
 }
 function tryLoadModuleUsingPaths(extensions, moduleName, baseDirectory, paths, pathPatterns, loader, onlyRecordFailures, state) {
-  pathPatterns || (pathPatterns = tryParsePatterns(paths));
   const matchedPattern = matchPatternOrExact(pathPatterns, moduleName);
   if (matchedPattern) {
     const matchedStar = isString(matchedPattern) ? void 0 : matchedText(matchedPattern, moduleName);
@@ -41301,7 +41411,7 @@ function resolveFromTypeRoot(moduleName, state) {
   }
 }
 function shouldAllowImportingTsExtension(compilerOptions, fromFileName) {
-  return getAllowImportingTsExtensions(compilerOptions) || fromFileName && isDeclarationFileName(fromFileName);
+  return !!compilerOptions.allowImportingTsExtensions || fromFileName && isDeclarationFileName(fromFileName);
 }
 function loadModuleFromGlobalCache(moduleName, projectName, compilerOptions, host, globalCache, packageJsonInfoCache) {
   const traceEnabled = isTraceEnabled(compilerOptions, host);
@@ -41386,20 +41496,24 @@ function getModuleInstanceStateCached(node, visited = /* @__PURE__ */ new Map())
 }
 function getModuleInstanceStateWorker(node, visited) {
   switch (node.kind) {
+    // 1. interface declarations, type alias declarations
     case 264 /* InterfaceDeclaration */:
     case 265 /* TypeAliasDeclaration */:
       return 0 /* NonInstantiated */;
+    // 2. const enum declarations
     case 266 /* EnumDeclaration */:
       if (isEnumConst(node)) {
         return 2 /* ConstEnumOnly */;
       }
       break;
+    // 3. non-exported import declarations
     case 272 /* ImportDeclaration */:
     case 271 /* ImportEqualsDeclaration */:
       if (!hasSyntacticModifier(node, 32 /* Export */)) {
         return 0 /* NonInstantiated */;
       }
       break;
+    // 4. Export alias declarations pointing at only uninstantiated modules or things uninstantiated modules contain
     case 278 /* ExportDeclaration */:
       const exportDeclaration = node;
       if (!exportDeclaration.moduleSpecifier && exportDeclaration.exportClause && exportDeclaration.exportClause.kind === 279 /* NamedExports */) {
@@ -41416,6 +41530,7 @@ function getModuleInstanceStateWorker(node, visited) {
         return state;
       }
       break;
+    // 5. other uninstantiated module declarations.
     case 268 /* ModuleBlock */: {
       let state = 0 /* NonInstantiated */;
       forEachChild(node, (n) => {
@@ -42014,6 +42129,7 @@ function createBinder() {
       case 351 /* JSDocImportTag */:
         bindJSDocImportTag(node);
         break;
+      // In source files and blocks, bind functions first to match hoisting that occurs at runtime
       case 307 /* SourceFile */: {
         bindEachFunctionsFirst(node.statements);
         bind(node.endOfFileToken);
@@ -42034,6 +42150,7 @@ function createBinder() {
       case 303 /* PropertyAssignment */:
       case 230 /* SpreadElement */:
         inAssignmentPattern = saveInAssignmentPattern;
+      // falls through
       default:
         bindEachChild(node);
         break;
@@ -42055,6 +42172,7 @@ function createBinder() {
         if (isJSDocTypeAssertion(expr)) {
           return false;
         }
+      // fallthrough
       case 235 /* NonNullExpression */:
         return isNarrowingExpression(expr.expression);
       case 226 /* BinaryExpression */:
@@ -42886,6 +43004,10 @@ function createBinder() {
   }
   function declareSymbolAndAddToSymbolTable(node, symbolFlags, symbolExcludes) {
     switch (container.kind) {
+      // Modules, source files, and classes need specialized handling for how their
+      // members are declared (for example, a member of a class will go into a specific
+      // symbol table depending on if it is static or not). We defer to specialized
+      // handlers to take care of declaring these child members.
       case 267 /* ModuleDeclaration */:
         return declareModuleMember(node, symbolFlags, symbolExcludes);
       case 307 /* SourceFile */:
@@ -43027,6 +43149,7 @@ function createBinder() {
           declareModuleMember(node, symbolFlags, symbolExcludes);
           break;
         }
+      // falls through
       default:
         Debug.assertNode(blockScopeContainer, canHaveLocals);
         if (!blockScopeContainer.locals) {
@@ -43347,6 +43470,7 @@ function createBinder() {
   }
   function bindWorker(node) {
     switch (node.kind) {
+      /* Strict mode checks */
       case 80 /* Identifier */:
         if (node.flags & 4096 /* IdentifierIsInJSDocNamespace */) {
           let parentNode = node.parent;
@@ -43356,6 +43480,7 @@ function createBinder() {
           bindBlockScopedDeclaration(parentNode, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
           break;
         }
+      // falls through
       case 110 /* ThisKeyword */:
         if (currentFlow && (isExpression(node) || parent.kind === 304 /* ShorthandPropertyAssignment */)) {
           node.flowNode = currentFlow;
@@ -43444,6 +43569,7 @@ function createBinder() {
         return;
       case 182 /* TypePredicate */:
         break;
+      // Binding the children will handle everything
       case 168 /* TypeParameter */:
         return bindTypeParameter(node);
       case 169 /* Parameter */:
@@ -43508,6 +43634,7 @@ function createBinder() {
             return bindObjectDefinePrototypeProperty(node);
           case 0 /* None */:
             break;
+          // Nothing to do
           default:
             return Debug.fail("Unknown call expression assignment declaration kind");
         }
@@ -43515,6 +43642,7 @@ function createBinder() {
           bindCallExpression(node);
         }
         break;
+      // Members of classes, interfaces, and modules
       case 231 /* ClassExpression */:
       case 263 /* ClassDeclaration */:
         inStrictMode = true;
@@ -43527,10 +43655,12 @@ function createBinder() {
         return bindEnumDeclaration(node);
       case 267 /* ModuleDeclaration */:
         return bindModuleDeclaration(node);
+      // Jsx-attributes
       case 292 /* JsxAttributes */:
         return bindJsxAttributes(node);
       case 291 /* JsxAttribute */:
         return bindJsxAttribute(node, 4 /* Property */, 0 /* PropertyExcludes */);
+      // Imports and exports
       case 271 /* ImportEqualsDeclaration */:
       case 274 /* NamespaceImport */:
       case 276 /* ImportSpecifier */:
@@ -43551,6 +43681,7 @@ function createBinder() {
         if (!isFunctionLikeOrClassStaticBlockDeclaration(node.parent)) {
           return;
         }
+      // falls through
       case 268 /* ModuleBlock */:
         return updateStrictModeStatementList(node.statements);
       case 341 /* JSDocParameterTag */:
@@ -43560,6 +43691,7 @@ function createBinder() {
         if (node.parent.kind !== 322 /* JSDocTypeLiteral */) {
           break;
         }
+      // falls through
       case 348 /* JSDocPropertyTag */:
         const propTag = node;
         const flags = propTag.isBracketed || propTag.typeExpression && propTag.typeExpression.type.kind === 316 /* JSDocOptionalType */ ? 4 /* Property */ | 16777216 /* Optional */ : 4 /* Property */;
@@ -43772,6 +43904,7 @@ function createBinder() {
           declareSymbolAndAddToSymbolTable(node, 1 /* FunctionScopedVariable */, 111550 /* FunctionScopedVariableExcludes */);
         }
         break;
+      // Namespaces are not allowed in javascript files, so do nothing here
       case 267 /* ModuleDeclaration */:
         break;
       default:
@@ -44268,6 +44401,7 @@ function getContainerFlags(node) {
       if (isObjectLiteralOrClassExpressionMethodOrAccessor(node)) {
         return 1 /* IsContainer */ | 4 /* IsControlFlowContainer */ | 32 /* HasLocals */ | 8 /* IsFunctionLike */ | 128 /* IsObjectLiteralOrClassExpressionMethodOrAccessor */;
       }
+    // falls through
     case 176 /* Constructor */:
     case 262 /* FunctionDeclaration */:
     case 173 /* MethodSignature */:
@@ -47321,6 +47455,7 @@ function createTypeChecker(host) {
         if (isEntityNameExpression(node.expression)) {
           return node.expression;
         }
+      // falls through
       default:
         return void 0;
     }
@@ -49176,6 +49311,7 @@ function createTypeChecker(host) {
           if (!isExternalOrCommonJsModule(location)) {
             break;
           }
+        // falls through
         case 267 /* ModuleDeclaration */:
           const sym = getSymbolOfDeclaration(location);
           if (result = callback(
@@ -50598,6 +50734,9 @@ function createTypeChecker(host) {
       }
       function createTypeNodesFromResolvedType(resolvedType) {
         if (checkTruncationLength(context)) {
+          if (context.flags & 1 /* NoTruncation */) {
+            return [addSyntheticTrailingComment(factory.createNotEmittedTypeElement(), 3 /* MultiLineCommentTrivia */, "elided")];
+          }
           return [factory.createPropertySignature(
             /*modifiers*/
             void 0,
@@ -50635,15 +50774,20 @@ function createTypeChecker(host) {
             }
           }
           if (checkTruncationLength(context) && i + 2 < properties.length - 1) {
-            typeElements.push(factory.createPropertySignature(
-              /*modifiers*/
-              void 0,
-              `... ${properties.length - i} more ...`,
-              /*questionToken*/
-              void 0,
-              /*type*/
-              void 0
-            ));
+            if (context.flags & 1 /* NoTruncation */) {
+              const typeElement = typeElements.pop();
+              typeElements.push(addSyntheticTrailingComment(typeElement, 3 /* MultiLineCommentTrivia */, `... ${properties.length - i} more elided ...`));
+            } else {
+              typeElements.push(factory.createPropertySignature(
+                /*modifiers*/
+                void 0,
+                `... ${properties.length - i} more ...`,
+                /*questionToken*/
+                void 0,
+                /*type*/
+                void 0
+              ));
+            }
             addPropertyToElementList(properties[properties.length - 1], context, typeElements);
             break;
           }
@@ -50661,7 +50805,7 @@ function createTypeChecker(host) {
           void 0
         );
       }
-      return factory.createKeywordTypeNode(133 /* AnyKeyword */);
+      return addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "elided");
     }
     function shouldUsePlaceholderForProperty(propertySymbol, context) {
       var _a;
@@ -50797,15 +50941,17 @@ function createTypeChecker(host) {
       if (some(types)) {
         if (checkTruncationLength(context)) {
           if (!isBareList) {
-            return [factory.createTypeReferenceNode(
-              "...",
-              /*typeArguments*/
-              void 0
-            )];
+            return [
+              context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, "elided") : factory.createTypeReferenceNode(
+                "...",
+                /*typeArguments*/
+                void 0
+              )
+            ];
           } else if (types.length > 2) {
             return [
               typeToTypeNodeHelper(types[0], context),
-              factory.createTypeReferenceNode(
+              context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, `... ${types.length - 2} more elided ...`) : factory.createTypeReferenceNode(
                 `... ${types.length - 2} more ...`,
                 /*typeArguments*/
                 void 0
@@ -50821,11 +50967,13 @@ function createTypeChecker(host) {
         for (const type of types) {
           i++;
           if (checkTruncationLength(context) && i + 2 < types.length - 1) {
-            result.push(factory.createTypeReferenceNode(
-              `... ${types.length - i} more ...`,
-              /*typeArguments*/
-              void 0
-            ));
+            result.push(
+              context.flags & 1 /* NoTruncation */ ? addSyntheticLeadingComment(factory.createKeywordTypeNode(133 /* AnyKeyword */), 3 /* MultiLineCommentTrivia */, `... ${types.length - i} more elided ...`) : factory.createTypeReferenceNode(
+                `... ${types.length - i} more ...`,
+                /*typeArguments*/
+                void 0
+              )
+            );
             const typeNode2 = typeToTypeNodeHelper(types[types.length - 1], context);
             if (typeNode2) {
               result.push(typeNode2);
@@ -53420,6 +53568,7 @@ function createTypeChecker(host) {
               );
               break;
             }
+          // else fall through and treat commonjs require just like import=
           case 271 /* ImportEqualsDeclaration */:
             if (target.escapedName === "export=" /* ExportEquals */ && some(target.declarations, (d) => isSourceFile(d) && isJsonSourceFile(d))) {
               serializeMaybeAliasAssignment(symbol);
@@ -54192,6 +54341,7 @@ function createTypeChecker(host) {
           if (isBindingPattern(node.name) && !node.name.elements.length) {
             return false;
           }
+        // falls through
         case 267 /* ModuleDeclaration */:
         case 263 /* ClassDeclaration */:
         case 264 /* InterfaceDeclaration */:
@@ -54216,6 +54366,8 @@ function createTypeChecker(host) {
           if (hasEffectiveModifier(node, 2 /* Private */ | 4 /* Protected */)) {
             return false;
           }
+        // Public properties/methods are visible if its parents are visible, so:
+        // falls through
         case 176 /* Constructor */:
         case 180 /* ConstructSignature */:
         case 179 /* CallSignature */:
@@ -54233,14 +54385,20 @@ function createTypeChecker(host) {
         case 196 /* ParenthesizedType */:
         case 202 /* NamedTupleMember */:
           return isDeclarationVisible(node.parent);
+        // Default binding, import specifier and namespace import is visible
+        // only on demand so by default it is not visible
         case 273 /* ImportClause */:
         case 274 /* NamespaceImport */:
         case 276 /* ImportSpecifier */:
           return false;
+        // Type parameters are always visible
         case 168 /* TypeParameter */:
+        // Source file and namespace export are always visible
+        // falls through
         case 307 /* SourceFile */:
         case 270 /* NamespaceExportDeclaration */:
           return true;
+        // Export assignments do not create name bindings outside the module
         case 277 /* ExportAssignment */:
           return false;
         default:
@@ -56185,11 +56343,20 @@ function createTypeChecker(host) {
     return type;
   }
   function isLateBindableName(node) {
+    return isLateBindableAST(node) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(node.argumentExpression));
+  }
+  function isLateBindableIndexSignature(node) {
+    return isLateBindableAST(node) && isTypeUsableAsIndexSignature(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(node.argumentExpression));
+  }
+  function isLateBindableAST(node) {
     if (!isComputedPropertyName(node) && !isElementAccessExpression(node)) {
       return false;
     }
     const expr = isComputedPropertyName(node) ? node.expression : node.argumentExpression;
-    return isEntityNameExpression(expr) && isTypeUsableAsPropertyName(isComputedPropertyName(node) ? checkComputedPropertyName(node) : checkExpressionCached(expr));
+    return isEntityNameExpression(expr);
+  }
+  function isTypeUsableAsIndexSignature(type) {
+    return isTypeAssignableTo(type, stringNumberSymbolType);
   }
   function isLateBoundName(name) {
     return name.charCodeAt(0) === 95 /* _ */ && name.charCodeAt(1) === 95 /* _ */ && name.charCodeAt(2) === 64 /* at */;
@@ -56198,6 +56365,10 @@ function createTypeChecker(host) {
     const name = getNameOfDeclaration(node);
     return !!name && isLateBindableName(name);
   }
+  function hasLateBindableIndexSignature(node) {
+    const name = getNameOfDeclaration(node);
+    return !!name && isLateBindableIndexSignature(name);
+  }
   function hasBindableName(node) {
     return !hasDynamicName(node) || hasLateBindableName(node);
   }
@@ -56251,6 +56422,24 @@ function createTypeChecker(host) {
     }
     return links.resolvedSymbol;
   }
+  function lateBindIndexSignature(parent, earlySymbols, lateSymbols, decl) {
+    let indexSymbol = lateSymbols.get("__index" /* Index */);
+    if (!indexSymbol) {
+      const early = earlySymbols == null ? void 0 : earlySymbols.get("__index" /* Index */);
+      if (!early) {
+        indexSymbol = createSymbol(0 /* None */, "__index" /* Index */, 4096 /* Late */);
+      } else {
+        indexSymbol = cloneSymbol(early);
+        indexSymbol.links.checkFlags |= 4096 /* Late */;
+      }
+      lateSymbols.set("__index" /* Index */, indexSymbol);
+    }
+    if (!indexSymbol.declarations) {
+      indexSymbol.declarations = [decl];
+    } else if (!decl.symbol.isReplaceableByMethod) {
+      indexSymbol.declarations.push(decl);
+    }
+  }
   function getResolvedMembersOrExportsOfSymbol(symbol, resolutionKind) {
     const links = getSymbolLinks(symbol);
     if (!links[resolutionKind]) {
@@ -56265,6 +56454,8 @@ function createTypeChecker(host) {
             if (isStatic2 === hasStaticModifier(member)) {
               if (hasLateBindableName(member)) {
                 lateBindMember(symbol, earlySymbols, lateSymbols, member);
+              } else if (hasLateBindableIndexSignature(member)) {
+                lateBindIndexSignature(symbol, earlySymbols, lateSymbols, member);
               }
             }
           }
@@ -58528,7 +58719,7 @@ function createTypeChecker(host) {
     return signature.isolatedSignatureType;
   }
   function getIndexSymbol(symbol) {
-    return symbol.members ? getIndexSymbolFromSymbolTable(symbol.members) : void 0;
+    return symbol.members ? getIndexSymbolFromSymbolTable(getMembersOfSymbol(symbol)) : void 0;
   }
   function getIndexSymbolFromSymbolTable(symbolTable) {
     return symbolTable.get("__index" /* Index */);
@@ -58544,15 +58735,25 @@ function createTypeChecker(host) {
     if (indexSymbol.declarations) {
       const indexInfos = [];
       for (const declaration of indexSymbol.declarations) {
-        if (declaration.parameters.length === 1) {
-          const parameter = declaration.parameters[0];
-          if (parameter.type) {
-            forEachType(getTypeFromTypeNode(parameter.type), (keyType) => {
-              if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) {
-                indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 8 /* Readonly */), declaration));
-              }
-            });
+        if (isIndexSignatureDeclaration(declaration)) {
+          if (declaration.parameters.length === 1) {
+            const parameter = declaration.parameters[0];
+            if (parameter.type) {
+              forEachType(getTypeFromTypeNode(parameter.type), (keyType) => {
+                if (isValidIndexKeyType(keyType) && !findIndexInfo(indexInfos, keyType)) {
+                  indexInfos.push(createIndexInfo(keyType, declaration.type ? getTypeFromTypeNode(declaration.type) : anyType, hasEffectiveModifier(declaration, 8 /* Readonly */), declaration));
+                }
+              });
+            }
           }
+        } else if (hasLateBindableIndexSignature(declaration)) {
+          const declName = isBinaryExpression(declaration) ? declaration.left : declaration.name;
+          const keyType = isElementAccessExpression(declName) ? checkExpressionCached(declName.argumentExpression) : checkComputedPropertyName(declName);
+          forEachType(keyType, (keyType2) => {
+            if (isValidIndexKeyType(keyType2) && !findIndexInfo(indexInfos, keyType2)) {
+              indexInfos.push(createIndexInfo(keyType2, getTypeOfVariableOrParameterOrProperty(declaration.symbol), hasEffectiveModifier(declaration, 8 /* Readonly */)));
+            }
+          });
         }
       }
       return indexInfos;
@@ -61790,6 +61991,9 @@ function createTypeChecker(host) {
         return getTypeFromTemplateTypeNode(node);
       case 205 /* ImportType */:
         return getTypeFromImportTypeNode(node);
+      // This function assumes that an identifier, qualified name, or property access expression is a type expression
+      // Callers should first ensure this by calling `isPartOfTypeNode`
+      // TODO(rbuckton): These aren't valid TypeNodes, but we treat them as such because of `isPartOfTypeNode`, which returns `true` for things that aren't `TypeNode`s.
       case 80 /* Identifier */:
       case 166 /* QualifiedName */:
       case 211 /* PropertyAccessExpression */:
@@ -62037,6 +62241,7 @@ function createTypeChecker(host) {
           return !!tp.isThisType;
         case 80 /* Identifier */:
           return !tp.isThisType && isPartOfTypeNode(node2) && maybeTypeParameterReference(node2) && getTypeFromTypeNodeWorker(node2) === tp;
+        // use worker because we're looking for === equality
         case 186 /* TypeQuery */:
           const entityName = node2.exprName;
           const firstIdentifier = getFirstIdentifier(entityName);
@@ -62456,6 +62661,7 @@ function createTypeChecker(host) {
         if (!isConstAssertion(node)) {
           break;
         }
+      // fallthrough
       case 294 /* JsxExpression */:
       case 217 /* ParenthesizedExpression */:
         return elaborateError(node.expression, source, target, relation, headMessage, containingMessageChain, errorOutputContainer);
@@ -63551,7 +63757,7 @@ function createTypeChecker(host) {
       const [sourceType, targetType] = getTypeNamesForErrorDisplay(source2, target2);
       let generalizedSource = source2;
       let generalizedSourceType = sourceType;
-      if (isLiteralType(source2) && !typeCouldHaveTopLevelSingletonTypes(target2)) {
+      if (!(target2.flags & 131072 /* Never */) && isLiteralType(source2) && !typeCouldHaveTopLevelSingletonTypes(target2)) {
         generalizedSource = getBaseTypeOfLiteralType(source2);
         Debug.assert(!isTypeAssignableTo(generalizedSource, target2), "generalized source shouldn't be assignable");
         generalizedSourceType = getTypeNameForErrorDisplay(generalizedSource);
@@ -67775,6 +67981,7 @@ function createTypeChecker(host) {
         if (isCallExpression(node.parent)) {
           return Diagnostics.Cannot_find_name_0_Did_you_mean_to_write_this_in_an_async_function;
         }
+      // falls through
       default:
         if (node.parent.kind === 304 /* ShorthandPropertyAssignment */) {
           return Diagnostics.No_value_exists_in_scope_for_the_shorthand_property_0_Either_declare_one_or_provide_an_initializer;
@@ -67808,6 +68015,7 @@ function createTypeChecker(host) {
           const symbol = getResolvedSymbol(node);
           return symbol !== unknownSymbol ? `${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}|${getSymbolId(symbol)}` : void 0;
         }
+      // falls through
       case 110 /* ThisKeyword */:
         return `0|${flowContainer ? getNodeId(flowContainer) : "-1"}|${getTypeId(declaredType)}|${getTypeId(initialType)}`;
       case 235 /* NonNullExpression */:
@@ -69361,6 +69569,9 @@ function createTypeChecker(host) {
           break;
         case 28 /* CommaToken */:
           return narrowType(type, expr.right, assumeTrue);
+        // Ordinarily we won't see && and || expressions in control flow analysis because the Binder breaks those
+        // expressions down to individual conditional control flows. However, we may encounter them when analyzing
+        // aliased conditional expressions.
         case 56 /* AmpersandAmpersandToken */:
           return assumeTrue ? narrowType(
             narrowType(
@@ -69804,6 +70015,7 @@ function createTypeChecker(host) {
               }
             }
           }
+        // falls through
         case 110 /* ThisKeyword */:
         case 108 /* SuperKeyword */:
         case 211 /* PropertyAccessExpression */:
@@ -77622,6 +77834,7 @@ function createTypeChecker(host) {
                 hasError = true;
                 break;
               }
+            // fallthrough
             case 7 /* ES2022 */:
             case 99 /* ESNext */:
             case 200 /* Preserve */:
@@ -77629,6 +77842,7 @@ function createTypeChecker(host) {
               if (languageVersion >= 4 /* ES2017 */) {
                 break;
               }
+            // fallthrough
             default:
               span ?? (span = getSpanOfTokenAtPosition(sourceFile, node.pos));
               const message = isAwaitExpression(node) ? Diagnostics.Top_level_await_expressions_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher : Diagnostics.Top_level_await_using_statements_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher;
@@ -78046,9 +78260,13 @@ function createTypeChecker(host) {
             return true;
         }
         return false;
+      // Some forms listed here for clarity
       case 222 /* VoidExpression */:
+      // Explicit opt-out
       case 216 /* TypeAssertionExpression */:
+      // Not SEF, but can produce useful type warnings
       case 234 /* AsExpression */:
+      // Not SEF, but can produce useful type warnings
       default:
         return false;
     }
@@ -79294,6 +79512,7 @@ function createTypeChecker(host) {
         if (node.expression.kind === 102 /* ImportKeyword */) {
           return checkImportCallExpression(node);
         }
+      // falls through
       case 214 /* NewExpression */:
         return checkCallExpression(node, checkMode);
       case 215 /* TaggedTemplateExpression */:
@@ -79382,7 +79601,7 @@ function createTypeChecker(host) {
       const modifiers = getTypeParameterModifiers(typeParameter) & (8192 /* In */ | 16384 /* Out */);
       if (modifiers) {
         const symbol = getSymbolOfDeclaration(node.parent);
-        if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (4 /* Reference */ | 16 /* Anonymous */ | 32 /* Mapped */))) {
+        if (isTypeAliasDeclaration(node.parent) && !(getObjectFlags(getDeclaredTypeOfSymbol(symbol)) & (16 /* Anonymous */ | 32 /* Mapped */))) {
           error(node, Diagnostics.Variance_annotations_are_only_supported_in_type_aliases_for_object_function_constructor_and_mapped_types);
         } else if (modifiers === 8192 /* In */ || modifiers === 16384 /* Out */) {
           (_a = tracing) == null ? void 0 : _a.push(tracing.Phase.CheckTypes, "checkTypeParameterDeferred", { parent: getTypeId(getDeclaredTypeOfSymbol(symbol)), id: getTypeId(typeParameter) });
@@ -79663,6 +79882,7 @@ function createTypeChecker(host) {
             if (useDefineForClassFields) {
               break;
             }
+          // fall through
           case "prototype":
             const message = Diagnostics.Static_property_0_conflicts_with_built_in_property_Function_0_of_constructor_function_1;
             const className = getNameOfSymbolAsWritten(getSymbolOfDeclaration(node));
@@ -79709,15 +79929,17 @@ function createTypeChecker(host) {
     if (indexSymbol == null ? void 0 : indexSymbol.declarations) {
       const indexSignatureMap = /* @__PURE__ */ new Map();
       for (const declaration of indexSymbol.declarations) {
-        if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
-          forEachType(getTypeFromTypeNode(declaration.parameters[0].type), (type) => {
-            const entry = indexSignatureMap.get(getTypeId(type));
-            if (entry) {
-              entry.declarations.push(declaration);
-            } else {
-              indexSignatureMap.set(getTypeId(type), { type, declarations: [declaration] });
-            }
-          });
+        if (isIndexSignatureDeclaration(declaration)) {
+          if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
+            forEachType(getTypeFromTypeNode(declaration.parameters[0].type), (type) => {
+              const entry = indexSignatureMap.get(getTypeId(type));
+              if (entry) {
+                entry.declarations.push(declaration);
+              } else {
+                indexSignatureMap.set(getTypeId(type), { type, declarations: [declaration] });
+              }
+            });
+          }
         }
       }
       indexSignatureMap.forEach((entry) => {
@@ -80406,6 +80628,8 @@ function createTypeChecker(host) {
       switch (d.kind) {
         case 264 /* InterfaceDeclaration */:
         case 265 /* TypeAliasDeclaration */:
+        // A jsdoc typedef and callback are, by definition, type aliases.
+        // falls through
         case 346 /* JSDocTypedefTag */:
         case 338 /* JSDocCallbackTag */:
         case 340 /* JSDocEnumTag */:
@@ -80426,6 +80650,8 @@ function createTypeChecker(host) {
             return 1 /* ExportValue */;
           }
           d = expression;
+        // The below options all declare an Alias, which is allowed to merge with other values within the importing module.
+        // falls through
         case 271 /* ImportEqualsDeclaration */:
         case 274 /* NamespaceImport */:
         case 273 /* ImportClause */:
@@ -80439,6 +80665,7 @@ function createTypeChecker(host) {
         case 208 /* BindingElement */:
         case 262 /* FunctionDeclaration */:
         case 276 /* ImportSpecifier */:
+        // https://github.com/Microsoft/TypeScript/pull/7591
         case 80 /* Identifier */:
           return 1 /* ExportValue */;
         case 173 /* MethodSignature */:
@@ -80787,6 +81014,7 @@ function createTypeChecker(host) {
           headMessage = Diagnostics.Decorator_function_return_type_0_is_not_assignable_to_type_1;
           break;
         }
+      // falls through
       case 169 /* Parameter */:
         headMessage = Diagnostics.Decorator_function_return_type_is_0_but_is_expected_to_be_void_or_any;
         break;
@@ -84008,6 +84236,7 @@ function createTypeChecker(host) {
         break;
       case 271 /* ImportEqualsDeclaration */:
         if (isInternalModuleImportEqualsDeclaration(node)) break;
+      // falls through
       case 272 /* ImportDeclaration */:
         grammarErrorOnFirstToken(node, Diagnostics.Imports_are_not_permitted_in_module_augmentations_Consider_moving_them_to_the_enclosing_external_module);
         break;
@@ -84020,6 +84249,7 @@ function createTypeChecker(host) {
           }
           break;
         }
+      // falls through
       case 263 /* ClassDeclaration */:
       case 266 /* EnumDeclaration */:
       case 262 /* FunctionDeclaration */:
@@ -84696,6 +84926,7 @@ function createTypeChecker(host) {
         return checkJSDocPropertyTag(node);
       case 317 /* JSDocFunctionType */:
         checkJSDocFunctionType(node);
+      // falls through
       case 315 /* JSDocNonNullableType */:
       case 314 /* JSDocNullableType */:
       case 312 /* JSDocAllType */:
@@ -85119,6 +85350,7 @@ function createTypeChecker(host) {
         switch (location.kind) {
           case 307 /* SourceFile */:
             if (!isExternalModule(location)) break;
+          // falls through
           case 267 /* ModuleDeclaration */:
             copyLocallyVisibleExportSymbols(getSymbolOfDeclaration(location).exports, meaning & 2623475 /* ModuleMember */);
             break;
@@ -85130,6 +85362,9 @@ function createTypeChecker(host) {
             if (className) {
               copySymbol(location.symbol, meaning);
             }
+          // this fall-through is necessary because we would like to handle
+          // type parameter inside class expression similar to how we handle it in classDeclaration and interface Declaration.
+          // falls through
           case 263 /* ClassDeclaration */:
           case 264 /* InterfaceDeclaration */:
             if (!isStaticSymbol) {
@@ -85238,6 +85473,7 @@ function createTypeChecker(host) {
         if (isPropertyAccessExpression(entityName.parent) && getLeftmostAccessExpression(entityName.parent) === entityName) {
           return void 0;
         }
+      // falls through
       case 4 /* ThisProperty */:
       case 2 /* ModuleExports */:
         return getSymbolOfDeclaration(entityName.parent.parent);
@@ -85531,6 +85767,7 @@ function createTypeChecker(host) {
         if (!isThisInTypeQuery(node)) {
           return getSymbolOfNameOrPropertyAccessExpression(node);
         }
+      // falls through
       case 110 /* ThisKeyword */:
         const container = getThisContainer(
           node,
@@ -85548,6 +85785,7 @@ function createTypeChecker(host) {
         if (isInExpressionContext(node)) {
           return checkExpression(node).symbol;
         }
+      // falls through
       case 197 /* ThisType */:
         return getTypeFromThisTypeNode(node).symbol;
       case 108 /* SuperKeyword */:
@@ -85570,6 +85808,7 @@ function createTypeChecker(host) {
         if (isCallExpression(parent) && isBindableObjectDefinePropertyCall(parent) && parent.arguments[1] === node) {
           return getSymbolOfDeclaration(parent);
         }
+      // falls through
       case 9 /* NumericLiteral */:
         const objectType = isElementAccessExpression(parent) ? parent.argumentExpression === node ? getTypeOfExpression(parent.expression) : void 0 : isLiteralTypeNode(parent) && isIndexedAccessTypeNode(grandParent) ? getTypeFromTypeNode(grandParent.objectType) : void 0;
         return objectType && getPropertyOfType(objectType, escapeLeadingUnderscores(node.text));
@@ -85599,6 +85838,7 @@ function createTypeChecker(host) {
           const symbol = getIntrinsicTagSymbol(node.parent);
           return symbol === unknownSymbol ? void 0 : symbol;
         }
+      // falls through
       default:
         return void 0;
     }
@@ -86607,7 +86847,29 @@ function createTypeChecker(host) {
         return !sym.exports ? [] : nodeBuilder.symbolTableToDeclarationStatements(sym.exports, node, flags, internalFlags, tracker);
       },
       isImportRequiredByAugmentation,
-      isDefinitelyReferenceToGlobalSymbolObject
+      isDefinitelyReferenceToGlobalSymbolObject,
+      createLateBoundIndexSignatures: (cls, enclosing, flags, internalFlags, tracker) => {
+        const sym = cls.symbol;
+        const staticInfos = getIndexInfosOfType(getTypeOfSymbol(sym));
+        const instanceIndexSymbol = getIndexSymbol(sym);
+        const instanceInfos = instanceIndexSymbol && getIndexInfosOfIndexSymbol(instanceIndexSymbol);
+        let result;
+        for (const infoList of [staticInfos, instanceInfos]) {
+          if (!length(infoList)) continue;
+          result || (result = []);
+          for (const info of infoList) {
+            if (info.declaration) continue;
+            const node = nodeBuilder.indexInfoToIndexSignatureDeclaration(info, enclosing, flags, internalFlags, tracker);
+            if (node && infoList === staticInfos) {
+              (node.modifiers || (node.modifiers = factory.createNodeArray())).unshift(factory.createModifier(126 /* StaticKeyword */));
+            }
+            if (node) {
+              result.push(node);
+            }
+          }
+        }
+        return result;
+      }
     };
     function isImportRequiredByAugmentation(node) {
       const file = getSourceFileOfNode(node);
@@ -87693,6 +87955,7 @@ function createTypeChecker(host) {
                   );
                   break;
                 }
+              // fallthrough
               case 7 /* ES2022 */:
               case 99 /* ESNext */:
               case 200 /* Preserve */:
@@ -87700,6 +87963,7 @@ function createTypeChecker(host) {
                 if (languageVersion >= 4 /* ES2017 */) {
                   break;
                 }
+              // fallthrough
               default:
                 diagnostics.add(
                   createDiagnosticForNode(forInOrOfStatement.awaitModifier, Diagnostics.Top_level_for_await_loops_are_only_allowed_when_the_module_option_is_set_to_es2022_esnext_system_node16_nodenext_or_preserve_and_the_target_option_is_set_to_es2017_or_higher)
@@ -89876,13 +90140,13 @@ var visitEachChildTable = {
     );
   },
   // Transformation nodes
-  [354 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
+  [355 /* PartiallyEmittedExpression */]: function visitEachChildOfPartiallyEmittedExpression(node, visitor, context, _nodesVisitor, nodeVisitor, _tokenVisitor) {
     return context.factory.updatePartiallyEmittedExpression(
       node,
       Debug.checkDefined(nodeVisitor(node.expression, visitor, isExpression))
     );
   },
-  [355 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
+  [356 /* CommaListExpression */]: function visitEachChildOfCommaListExpression(node, visitor, context, nodesVisitor, _nodeVisitor, _tokenVisitor) {
     return context.factory.updateCommaListExpression(
       node,
       nodesVisitor(node.elements, visitor, isExpression)
@@ -91806,6 +92070,8 @@ function transformTypeScript(context) {
       case 148 /* ReadonlyKeyword */:
       case 103 /* InKeyword */:
       case 147 /* OutKeyword */:
+      // TypeScript accessibility and readonly modifiers are elided
+      // falls through
       case 188 /* ArrayType */:
       case 189 /* TupleType */:
       case 190 /* OptionalType */:
@@ -91834,6 +92100,8 @@ function transformTypeScript(context) {
       case 199 /* IndexedAccessType */:
       case 200 /* MappedType */:
       case 201 /* LiteralType */:
+      // TypeScript type nodes are elided.
+      // falls through
       case 181 /* IndexSignature */:
         return void 0;
       case 265 /* TypeAliasDeclaration */:
@@ -93041,17 +93309,10 @@ function transformTypeScript(context) {
       /*modifiers*/
       void 0,
       importClause,
-      rewriteModuleSpecifier(node.moduleSpecifier),
+      node.moduleSpecifier,
       node.attributes
     ) : void 0;
   }
-  function rewriteModuleSpecifier(node) {
-    if (!node || !compilerOptions.rewriteRelativeImportExtensions || !isStringLiteral(node) || !pathIsRelative(node.text) || isDeclarationFileName(node.text)) {
-      return node;
-    }
-    const updatedText = changeExtension(node.text, getOutputExtension(node.text, compilerOptions));
-    return updatedText !== node.text ? setOriginalNode(setTextRange(factory2.createStringLiteral(updatedText, node.singleQuote), node), node) : node;
-  }
   function visitImportClause(node) {
     Debug.assert(!node.isTypeOnly);
     const name = shouldEmitAliasDeclaration(node) ? node.name : void 0;
@@ -93084,14 +93345,7 @@ function transformTypeScript(context) {
       return void 0;
     }
     if (!node.exportClause || isNamespaceExport(node.exportClause)) {
-      return factory2.updateExportDeclaration(
-        node,
-        node.modifiers,
-        node.isTypeOnly,
-        node.exportClause,
-        rewriteModuleSpecifier(node.moduleSpecifier),
-        node.attributes
-      );
+      return node;
     }
     const allowEmpty = !!compilerOptions.verbatimModuleSyntax;
     const exportClause = visitNode(
@@ -93105,7 +93359,7 @@ function transformTypeScript(context) {
       void 0,
       node.isTypeOnly,
       exportClause,
-      rewriteModuleSpecifier(node.moduleSpecifier),
+      node.moduleSpecifier,
       node.attributes
     ) : void 0;
   }
@@ -93130,24 +93384,8 @@ function transformTypeScript(context) {
       return void 0;
     }
     if (isExternalModuleImportEqualsDeclaration(node)) {
-      if (!shouldEmitAliasDeclaration(node)) {
-        return void 0;
-      }
-      const updatedModuleSpecifier = rewriteModuleSpecifier(node.moduleReference.expression);
-      if (updatedModuleSpecifier !== node.moduleReference.expression) {
-        return visitEachChild(
-          factory2.updateImportEqualsDeclaration(
-            node,
-            node.modifiers,
-            node.isTypeOnly,
-            node.name,
-            factory2.updateExternalModuleReference(node.moduleReference, updatedModuleSpecifier)
-          ),
-          visitor,
-          context
-        );
-      }
-      return visitEachChild(node, visitor, context);
+      const isReferenced = shouldEmitAliasDeclaration(node);
+      return isReferenced ? visitEachChild(node, visitor, context) : void 0;
     }
     if (!shouldEmitImportEqualsDeclaration(node)) {
       return void 0;
@@ -93546,7 +93784,7 @@ function transformClassFields(context) {
           /*discarded*/
           true
         );
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -95486,6 +95724,7 @@ function transformClassFields(context) {
         if (isArrowFunction(original) || getEmitFlags(node) & 524288 /* AsyncFunctionBody */) {
           break;
         }
+      // falls through
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 177 /* GetAccessor */:
@@ -95761,6 +96000,7 @@ function createRuntimeTypeSerializer(context) {
       case 197 /* ThisType */:
       case 205 /* ImportType */:
         break;
+      // handle JSDoc types from an invalid parse
       case 312 /* JSDocAllType */:
       case 313 /* JSDocUnknownType */:
       case 317 /* JSDocFunctionType */:
@@ -96606,6 +96846,7 @@ function transformESDecorators(context) {
         return Debug.fail("Not supported outside of a class. Use 'classElementVisitor' instead.");
       case 169 /* Parameter */:
         return visitParameterDeclaration(node);
+      // Support NamedEvaluation to ensure the correct class name for class expressions.
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(
           node,
@@ -96626,7 +96867,7 @@ function transformESDecorators(context) {
         return visitForStatement(node);
       case 244 /* ExpressionStatement */:
         return visitExpressionStatement(node);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -96638,7 +96879,7 @@ function transformESDecorators(context) {
           /*discarded*/
           false
         );
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(
           node,
           /*discarded*/
@@ -96662,6 +96903,7 @@ function transformESDecorators(context) {
       case 167 /* ComputedPropertyName */:
         return visitComputedPropertyName(node);
       case 174 /* MethodDeclaration */:
+      // object literal methods and accessors
       case 178 /* SetAccessor */:
       case 177 /* GetAccessor */:
       case 218 /* FunctionExpression */:
@@ -96724,7 +96966,7 @@ function transformESDecorators(context) {
           /*discarded*/
           true
         );
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -99306,7 +99548,7 @@ function transformES2018(context) {
         return visitObjectLiteralExpression(node);
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node, expressionResultIsUnused2);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(node, expressionResultIsUnused2);
       case 299 /* CatchClause */:
         return visitCatchClause(node);
@@ -102446,6 +102688,7 @@ function transformES2015(context) {
     switch (node.kind) {
       case 126 /* StaticKeyword */:
         return void 0;
+      // elide static keyword
       case 263 /* ClassDeclaration */:
         return visitClassDeclaration(node);
       case 231 /* ClassExpression */:
@@ -102524,7 +102767,7 @@ function transformES2015(context) {
         return visitParenthesizedExpression(node, expressionResultIsUnused2);
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node, expressionResultIsUnused2);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(node, expressionResultIsUnused2);
       case 15 /* NoSubstitutionTemplateLiteral */:
       case 16 /* TemplateHead */:
@@ -102908,12 +103151,14 @@ function transformES2015(context) {
       return false;
     }
     switch (node.kind) {
+      // stop at function boundaries
       case 219 /* ArrowFunction */:
       case 218 /* FunctionExpression */:
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 175 /* ClassStaticBlockDeclaration */:
         return false;
+      // only step into computed property names for class and object literal elements
       case 177 /* GetAccessor */:
       case 178 /* SetAccessor */:
       case 174 /* MethodDeclaration */:
@@ -103122,12 +103367,14 @@ function transformES2015(context) {
       return factory2.createPartiallyEmittedExpression(node.right, node);
     }
     switch (node.kind) {
+      // stop at function boundaries
       case 219 /* ArrowFunction */:
       case 218 /* FunctionExpression */:
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 175 /* ClassStaticBlockDeclaration */:
         return node;
+      // only step into computed property names for class and object literal elements
       case 177 /* GetAccessor */:
       case 178 /* SetAccessor */:
       case 174 /* MethodDeclaration */:
@@ -103173,12 +103420,14 @@ function transformES2015(context) {
       );
     }
     switch (node.kind) {
+      // stop at function boundaries
       case 219 /* ArrowFunction */:
       case 218 /* FunctionExpression */:
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 175 /* ClassStaticBlockDeclaration */:
         return node;
+      // only step into computed property names for class and object literal elements
       case 177 /* GetAccessor */:
       case 178 /* SetAccessor */:
       case 174 /* MethodDeclaration */:
@@ -105810,7 +106059,7 @@ function transformGenerators(context) {
     switch (node.kind) {
       case 226 /* BinaryExpression */:
         return visitBinaryExpression(node);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(node);
       case 227 /* ConditionalExpression */:
         return visitConditionalExpression(node);
@@ -108201,7 +108450,7 @@ function transformModule(context) {
         return visitExpressionStatement(node);
       case 217 /* ParenthesizedExpression */:
         return visitParenthesizedExpression(node, valueIsDiscarded);
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(node, valueIsDiscarded);
       case 213 /* CallExpression */:
         if (isImportCall(node) && host.shouldTransformImportCall(currentSourceFile)) {
@@ -109961,6 +110210,7 @@ function transformSystemModule(context) {
             if (!entry.importClause) {
               break;
             }
+          // falls through
           case 271 /* ImportEqualsDeclaration */:
             Debug.assert(importVariableName !== void 0);
             statements.push(
@@ -110595,7 +110845,7 @@ function transformSystemModule(context) {
         return visitExpressionStatement(node);
       case 217 /* ParenthesizedExpression */:
         return visitParenthesizedExpression(node, valueIsDiscarded);
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(node, valueIsDiscarded);
       case 226 /* BinaryExpression */:
         if (isDestructuringAssignment(node)) {
@@ -112194,6 +112444,7 @@ function transformDeclarations(context) {
       case 265 /* TypeAliasDeclaration */:
       case 266 /* EnumDeclaration */:
         return !resolver.isDeclarationVisible(node);
+      // The following should be doing their own visibility checks based on filtering their members
       case 260 /* VariableDeclaration */:
         return !getBindingNameVisible(node);
       case 271 /* ImportEqualsDeclaration */:
@@ -113088,7 +113339,8 @@ function transformDeclarations(context) {
             void 0
           )
         ] : void 0;
-        const memberNodes = concatenate(concatenate(privateIdentifier, parameterProperties), visitNodes2(input.members, visitDeclarationSubtree, isClassElement));
+        const lateIndexes = resolver.createLateBoundIndexSignatures(input, enclosingDeclaration, declarationEmitNodeBuilderFlags, declarationEmitInternalNodeBuilderFlags, symbolTracker);
+        const memberNodes = concatenate(concatenate(concatenate(privateIdentifier, lateIndexes), parameterProperties), visitNodes2(input.members, visitDeclarationSubtree, isClassElement));
         const members = factory2.createNodeArray(memberNodes);
         const extendsClause = getEffectiveBaseTypeNode(input);
         if (extendsClause && !isEntityNameExpression(extendsClause.expression) && extendsClause.expression.kind !== 106 /* NullKeyword */) {
@@ -113475,7 +113727,7 @@ function noEmitNotification(hint, node, callback) {
 }
 function transformNodes(resolver, host, factory2, options, nodes, transformers, allowDtsFiles) {
   var _a, _b;
-  const enabledSyntaxKindFeatures = new Array(357 /* Count */);
+  const enabledSyntaxKindFeatures = new Array(358 /* Count */);
   let lexicalEnvironmentVariableDeclarations;
   let lexicalEnvironmentFunctionDeclarations;
   let lexicalEnvironmentStatements;
@@ -114393,7 +114645,8 @@ var notImplementedResolver = {
   isBindingCapturedByNode: notImplemented,
   getDeclarationStatementsForSourceFile: notImplemented,
   isImportRequiredByAugmentation: notImplemented,
-  isDefinitelyReferenceToGlobalSymbolObject: notImplemented
+  isDefinitelyReferenceToGlobalSymbolObject: notImplemented,
+  createLateBoundIndexSignatures: notImplemented
 };
 var createPrinterWithDefaults = /* @__PURE__ */ memoize(() => createPrinter({}));
 var createPrinterWithRemoveComments = /* @__PURE__ */ memoize(() => createPrinter({ removeComments: true }));
@@ -114678,6 +114931,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         if (onEmitNode !== noEmitNotification && (!isEmitNotificationEnabled || isEmitNotificationEnabled(node))) {
           return pipelineEmitWithNotification;
         }
+      // falls through
       case 1 /* Substitution */:
         if (substituteNode !== noEmitSubstitution && (lastSubstitution = substituteNode(emitHint, node) || node) !== node) {
           if (currentParenthesizerRule) {
@@ -114685,14 +114939,17 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           }
           return pipelineEmitWithSubstitution;
         }
+      // falls through
       case 2 /* Comments */:
         if (shouldEmitComments(node)) {
           return pipelineEmitWithComments;
         }
+      // falls through
       case 3 /* SourceMaps */:
         if (shouldEmitSourceMaps(node)) {
           return pipelineEmitWithSourceMaps;
         }
+      // falls through
       case 4 /* Emit */:
         return pipelineEmitWithHint;
       default:
@@ -114744,6 +115001,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     if (hint === 4 /* Unspecified */) {
       switch (node.kind) {
+        // Pseudo-literals
         case 16 /* TemplateHead */:
         case 17 /* TemplateMiddle */:
         case 18 /* TemplateTail */:
@@ -114752,20 +115010,26 @@ function createPrinter(printerOptions = {}, handlers = {}) {
             /*jsxAttributeEscape*/
             false
           );
+        // Identifiers
         case 80 /* Identifier */:
           return emitIdentifier(node);
+        // PrivateIdentifiers
         case 81 /* PrivateIdentifier */:
           return emitPrivateIdentifier(node);
+        // Parse tree nodes
+        // Names
         case 166 /* QualifiedName */:
           return emitQualifiedName(node);
         case 167 /* ComputedPropertyName */:
           return emitComputedPropertyName(node);
+        // Signature elements
         case 168 /* TypeParameter */:
           return emitTypeParameter(node);
         case 169 /* Parameter */:
           return emitParameter(node);
         case 170 /* Decorator */:
           return emitDecorator(node);
+        // Type members
         case 171 /* PropertySignature */:
           return emitPropertySignature(node);
         case 172 /* PropertyDeclaration */:
@@ -114787,6 +115051,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitConstructSignature(node);
         case 181 /* IndexSignature */:
           return emitIndexSignature(node);
+        // Types
         case 182 /* TypePredicate */:
           return emitTypePredicate(node);
         case 183 /* TypeReference */:
@@ -114805,6 +115070,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitTupleType(node);
         case 190 /* OptionalType */:
           return emitOptionalType(node);
+        // SyntaxKind.RestType is handled below
         case 192 /* UnionType */:
           return emitUnionType(node);
         case 193 /* IntersectionType */:
@@ -114835,16 +115101,19 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitTemplateTypeSpan(node);
         case 205 /* ImportType */:
           return emitImportTypeNode(node);
+        // Binding patterns
         case 206 /* ObjectBindingPattern */:
           return emitObjectBindingPattern(node);
         case 207 /* ArrayBindingPattern */:
           return emitArrayBindingPattern(node);
         case 208 /* BindingElement */:
           return emitBindingElement(node);
+        // Misc
         case 239 /* TemplateSpan */:
           return emitTemplateSpan(node);
         case 240 /* SemicolonClassElement */:
           return emitSemicolonClassElement();
+        // Statements
         case 241 /* Block */:
           return emitBlock(node);
         case 243 /* VariableStatement */:
@@ -114886,6 +115155,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitTryStatement(node);
         case 259 /* DebuggerStatement */:
           return emitDebuggerStatement(node);
+        // Declarations
         case 260 /* VariableDeclaration */:
           return emitVariableDeclaration(node);
         case 261 /* VariableDeclarationList */:
@@ -114936,8 +115206,10 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitImportAttribute(node);
         case 282 /* MissingDeclaration */:
           return;
+        // Module references
         case 283 /* ExternalModuleReference */:
           return emitExternalModuleReference(node);
+        // JSX (non-expression)
         case 12 /* JsxText */:
           return emitJsxText(node);
         case 286 /* JsxOpeningElement */:
@@ -114956,6 +115228,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJsxExpression(node);
         case 295 /* JsxNamespacedName */:
           return emitJsxNamespacedName(node);
+        // Clauses
         case 296 /* CaseClause */:
           return emitCaseClause(node);
         case 297 /* DefaultClause */:
@@ -114964,18 +115237,22 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitHeritageClause(node);
         case 299 /* CatchClause */:
           return emitCatchClause(node);
+        // Property assignments
         case 303 /* PropertyAssignment */:
           return emitPropertyAssignment(node);
         case 304 /* ShorthandPropertyAssignment */:
           return emitShorthandPropertyAssignment(node);
         case 305 /* SpreadAssignment */:
           return emitSpreadAssignment(node);
+        // Enum
         case 306 /* EnumMember */:
           return emitEnumMember(node);
+        // Top-level nodes
         case 307 /* SourceFile */:
           return emitSourceFile(node);
         case 308 /* Bundle */:
           return Debug.fail("Bundles should be printed using printBundle");
+        // JSDoc nodes (only used in codefixes currently)
         case 309 /* JSDocTypeExpression */:
           return emitJSDocTypeExpression(node);
         case 310 /* JSDocNameReference */:
@@ -115013,6 +115290,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
         case 330 /* JSDocAuthorTag */:
         case 331 /* JSDocDeprecatedTag */:
           return;
+        // SyntaxKind.JSDocClassTag (see JSDocTag, above)
         case 333 /* JSDocPublicTag */:
         case 334 /* JSDocPrivateTag */:
         case 335 /* JSDocProtectedTag */:
@@ -115022,6 +115300,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJSDocCallbackTag(node);
         case 339 /* JSDocOverloadTag */:
           return emitJSDocOverloadTag(node);
+        // SyntaxKind.JSDocEnumTag (see below)
         case 341 /* JSDocParameterTag */:
         case 348 /* JSDocPropertyTag */:
           return emitJSDocPropertyLikeTag(node);
@@ -115040,7 +115319,10 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJSDocSeeTag(node);
         case 351 /* JSDocImportTag */:
           return emitJSDocImportTag(node);
+        // SyntaxKind.JSDocPropertyTag (see JSDocParameterTag, above)
+        // Transformation nodes
         case 353 /* NotEmittedStatement */:
+        case 354 /* NotEmittedTypeElement */:
           return;
       }
       if (isExpression(node)) {
@@ -115058,6 +115340,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     if (hint === 1 /* Expression */) {
       switch (node.kind) {
+        // Literals
         case 9 /* NumericLiteral */:
         case 10 /* BigIntLiteral */:
           return emitNumericOrBigIntLiteral(node);
@@ -115069,10 +115352,12 @@ function createPrinter(printerOptions = {}, handlers = {}) {
             /*jsxAttributeEscape*/
             false
           );
+        // Identifiers
         case 80 /* Identifier */:
           return emitIdentifier(node);
         case 81 /* PrivateIdentifier */:
           return emitPrivateIdentifier(node);
+        // Expressions
         case 209 /* ArrayLiteralExpression */:
           return emitArrayLiteralExpression(node);
         case 210 /* ObjectLiteralExpression */:
@@ -115135,21 +115420,24 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return Debug.fail("SyntheticExpression should never be printed.");
         case 282 /* MissingDeclaration */:
           return;
+        // JSX
         case 284 /* JsxElement */:
           return emitJsxElement(node);
         case 285 /* JsxSelfClosingElement */:
           return emitJsxSelfClosingElement(node);
         case 288 /* JsxFragment */:
           return emitJsxFragment(node);
+        // Synthesized list
         case 352 /* SyntaxList */:
           return Debug.fail("SyntaxList should not be printed");
+        // Transformation nodes
         case 353 /* NotEmittedStatement */:
           return;
-        case 354 /* PartiallyEmittedExpression */:
+        case 355 /* PartiallyEmittedExpression */:
           return emitPartiallyEmittedExpression(node);
-        case 355 /* CommaListExpression */:
+        case 356 /* CommaListExpression */:
           return emitCommaList(node);
-        case 356 /* SyntheticReferenceExpression */:
+        case 357 /* SyntheticReferenceExpression */:
           return Debug.fail("SyntheticReferenceExpression should not be printed");
       }
     }
@@ -121286,6 +121574,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
               diagnostics.push(createDiagnosticForNode2(node, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, "?"));
               return "skip";
             }
+          // falls through
           case 173 /* MethodSignature */:
           case 176 /* Constructor */:
           case 177 /* GetAccessor */:
@@ -121417,6 +121706,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
               diagnostics.push(createDiagnosticForNodeArray2(nodes, Diagnostics.Type_parameter_declarations_can_only_be_used_in_TypeScript_files));
               return "skip";
             }
+          // falls through
           case 243 /* VariableStatement */:
             if (nodes === parent.modifiers) {
               checkModifiers(parent.modifiers, parent.kind === 243 /* VariableStatement */);
@@ -121459,6 +121749,8 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
               if (isConstValid) {
                 continue;
               }
+            // to report error,
+            // falls through
             case 125 /* PublicKeyword */:
             case 123 /* PrivateKeyword */:
             case 124 /* ProtectedKeyword */:
@@ -121470,6 +121762,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
             case 147 /* OutKeyword */:
               diagnostics.push(createDiagnosticForNode2(modifier, Diagnostics.The_0_modifier_can_only_be_used_in_TypeScript_files, tokenToString(modifier.kind)));
               break;
+            // These are all legal modifiers.
             case 126 /* StaticKeyword */:
             case 95 /* ExportKeyword */:
             case 90 /* DefaultKeyword */:
@@ -122516,7 +122809,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         createDiagnosticForOptionName(Diagnostics.Option_verbatimModuleSyntax_cannot_be_used_when_module_is_set_to_UMD_AMD_or_System, "verbatimModuleSyntax");
       }
     }
-    if (options.allowImportingTsExtensions && !(options.noEmit || options.emitDeclarationOnly || options.rewriteRelativeImportExtensions)) {
+    if (options.allowImportingTsExtensions && !(options.noEmit || options.emitDeclarationOnly)) {
       createOptionValueDiagnostic("allowImportingTsExtensions", Diagnostics.Option_allowImportingTsExtensions_can_only_be_used_when_either_noEmit_or_emitDeclarationOnly_is_set);
     }
     const moduleResolution = getEmitModuleResolutionKind(options);
@@ -126875,6 +127168,7 @@ function getSourceFileVersionAsHashFromText(host, text) {
           if (pos && text.charCodeAt(pos - 1) === 13 /* carriageReturn */) {
             pos--;
           }
+        // falls through
         case 13 /* carriageReturn */:
           break;
         default:
@@ -128361,6 +128655,7 @@ function createBuildOrUpdateInvalidedProject(state, project, projectPath, projec
           queueReferencingProjects(state, project, projectPath, projectIndex, config, buildOrder, Debug.checkDefined(buildResult));
           step++;
           break;
+        // Should never be done
         case 3 /* Done */:
         default:
           assertType(step);
@@ -128901,6 +129196,7 @@ function queueReferencingProjects(state, project, projectPath, projectIndex, con
               status.type = 2 /* UpToDateWithUpstreamTypes */;
               break;
             }
+          // falls through
           case 15 /* UpToDateWithInputFileText */:
           case 2 /* UpToDateWithUpstreamTypes */:
             if (!(buildResult & 2 /* DeclarationOutputUnchanged */)) {
@@ -129418,6 +129714,8 @@ function reportUpToDateStatus(state, configFileName, status) {
         relName(state, configFileName)
       );
     case 16 /* ContainerOnly */:
+    // Don't report status on "solution" projects
+    // falls through
     case 13 /* ComputingUpstream */:
       break;
     default: