typescript 5.7.0-dev.20240829 → 5.7.0-dev.20240831

package/lib/typescript.js

@@ -2265,7 +2265,7 @@ module.exports = __toCommonJS(typescript_exports);
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.7";
-var version = `${versionMajorMinor}.0-dev.20240829`;
+var version = `${versionMajorMinor}.0-dev.20240831`;
 var Comparison = /* @__PURE__ */ ((Comparison3) => {
   Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
   Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -2733,7 +2733,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 */:
@@ -3618,7 +3621,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;
     }
@@ -5854,10 +5857,11 @@ var SyntaxKind = /* @__PURE__ */ ((SyntaxKind5) => {
   SyntaxKind5[SyntaxKind5["JSDocImportTag"] = 351] = "JSDocImportTag";
   SyntaxKind5[SyntaxKind5["SyntaxList"] = 352] = "SyntaxList";
   SyntaxKind5[SyntaxKind5["NotEmittedStatement"] = 353] = "NotEmittedStatement";
-  SyntaxKind5[SyntaxKind5["PartiallyEmittedExpression"] = 354] = "PartiallyEmittedExpression";
-  SyntaxKind5[SyntaxKind5["CommaListExpression"] = 355] = "CommaListExpression";
-  SyntaxKind5[SyntaxKind5["SyntheticReferenceExpression"] = 356] = "SyntheticReferenceExpression";
-  SyntaxKind5[SyntaxKind5["Count"] = 357] = "Count";
+  SyntaxKind5[SyntaxKind5["NotEmittedTypeElement"] = 354] = "NotEmittedTypeElement";
+  SyntaxKind5[SyntaxKind5["PartiallyEmittedExpression"] = 355] = "PartiallyEmittedExpression";
+  SyntaxKind5[SyntaxKind5["CommaListExpression"] = 356] = "CommaListExpression";
+  SyntaxKind5[SyntaxKind5["SyntheticReferenceExpression"] = 357] = "SyntheticReferenceExpression";
+  SyntaxKind5[SyntaxKind5["Count"] = 358] = "Count";
   SyntaxKind5[SyntaxKind5["FirstAssignment"] = 64 /* EqualsToken */] = "FirstAssignment";
   SyntaxKind5[SyntaxKind5["LastAssignment"] = 79 /* CaretEqualsToken */] = "LastAssignment";
   SyntaxKind5[SyntaxKind5["FirstCompoundAssignment"] = 65 /* PlusEqualsToken */] = "FirstCompoundAssignment";
@@ -7997,6 +8001,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
@@ -11538,6 +11543,7 @@ function computeLineStarts(text) {
         if (text.charCodeAt(pos) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
         result.push(lineStart);
         lineStart = pos;
@@ -11640,6 +11646,8 @@ function couldStartTrivia(text, pos) {
     case 12 /* formFeed */:
     case 32 /* space */:
     case 47 /* slash */:
+    // starts of normal trivia
+    // falls through
     case 60 /* lessThan */:
     case 124 /* bar */:
     case 61 /* equals */:
@@ -11663,6 +11671,7 @@ function skipTrivia(text, pos, stopAfterLineBreak, stopAtComments, inJSDoc) {
         if (text.charCodeAt(pos + 1) === 10 /* lineFeed */) {
           pos++;
         }
+      // falls through
       case 10 /* lineFeed */:
         pos++;
         if (stopAfterLineBreak) {
@@ -11809,6 +11818,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) {
@@ -12374,12 +12384,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 */:
@@ -12477,10 +12491,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 */:
@@ -12911,6 +12928,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 */:
@@ -13430,6 +13448,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
                 break;
               }
             }
+          // falls through
           case 42 /* asterisk */:
           case 43 /* plus */:
           case 63 /* question */:
@@ -13460,6 +13479,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             if (isInGroup) {
               return;
             }
+          // falls through
           case 93 /* closeBracket */:
           case 125 /* closeBrace */:
             if (anyUnicodeModeOrNonAnnexB || ch === 41 /* closeParen */) {
@@ -13522,6 +13542,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             error2(Diagnostics.q_is_only_available_inside_character_class, pos - 2, 2);
             break;
           }
+        // falls through
         default:
           Debug.assert(scanCharacterClassEscape() || scanDecimalEscape() || scanCharacterEscape(
             /*atomEscape*/
@@ -13659,6 +13680,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 "&&":
           error2(Diagnostics.Expected_a_class_set_operand);
@@ -13764,6 +13786,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
         }
         start2 = pos;
         switch (text.slice(pos, pos + 2)) {
+          // TODO: don't use slice
           case "--":
           case "&&":
             error2(Diagnostics.Operators_must_not_be_mixed_within_a_character_class_Wrap_it_in_a_nested_class_instead, pos, 2);
@@ -13861,6 +13884,7 @@ function createScanner(languageVersion, skipTrivia2, languageVariant = 0 /* Stan
             }
           }
           pos--;
+        // falls through
         default:
           return scanClassSetCharacter();
       }
@@ -14007,6 +14031,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 */) {
@@ -14314,6 +14339,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 */;
@@ -14540,6 +14566,7 @@ function getDefaultLibFileName(options) {
       return "lib.es2016.full.d.ts";
     case 2 /* ES2015 */:
       return "lib.es6.d.ts";
+    // We don't use lib.es2015.full.d.ts due to breaking change.
     default:
       return "lib.d.ts";
   }
@@ -15480,7 +15507,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 isClassOrTypeElement(node) {
   return isTypeElement(node) || isClassElement(node);
@@ -15542,7 +15569,9 @@ function isObjectBindingOrAssignmentElement(node) {
   switch (node.kind) {
     case 208 /* BindingElement */:
     case 303 /* PropertyAssignment */:
+    // AssignmentProperty
     case 304 /* ShorthandPropertyAssignment */:
+    // AssignmentProperty
     case 305 /* SpreadAssignment */:
       return true;
   }
@@ -15560,11 +15589,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;
   }
@@ -15625,6 +15660,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 */:
@@ -15640,6 +15676,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:
@@ -15696,8 +15733,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:
@@ -17436,6 +17473,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 */:
@@ -17607,6 +17646,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;
@@ -17614,6 +17655,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 */: {
@@ -17882,6 +17924,7 @@ function getThisContainer(node, includeArrowFunctions, includeClassComputedPrope
         if (!includeArrowFunctions) {
           continue;
         }
+      // falls through
       case 262 /* FunctionDeclaration */:
       case 218 /* FunctionExpression */:
       case 267 /* ModuleDeclaration */:
@@ -17904,6 +17947,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 */:
@@ -17970,6 +18015,7 @@ function getSuperContainer(node, stopOnFunctions) {
         if (!stopOnFunctions) {
           continue;
         }
+      // falls through
       case 172 /* PropertyDeclaration */:
       case 171 /* PropertySignature */:
       case 174 /* MethodDeclaration */:
@@ -18023,6 +18069,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;
@@ -18187,6 +18234,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 */:
@@ -19101,6 +19149,7 @@ function getDeclarationFromName(name) {
     case 15 /* NoSubstitutionTemplateLiteral */:
     case 9 /* NumericLiteral */:
       if (isComputedPropertyName(parent2)) return parent2.parent;
+    // falls through
     case 80 /* Identifier */:
       if (isDeclaration(parent2)) {
         return parent2.name === name ? parent2 : void 0;
@@ -19271,6 +19320,7 @@ function getFunctionFlags(node) {
       if (node.asteriskToken) {
         flags |= 1 /* Generator */;
       }
+    // falls through
     case 219 /* ArrowFunction */:
       if (hasSyntacticModifier(node, 1024 /* Async */)) {
         flags |= 2 /* Async */;
@@ -19541,7 +19591,7 @@ var OperatorPrecedence = /* @__PURE__ */ ((OperatorPrecedence2) => {
 })(OperatorPrecedence || {});
 function getOperatorPrecedence(nodeKind, operatorKind, hasArguments) {
   switch (nodeKind) {
-    case 355 /* CommaListExpression */:
+    case 356 /* CommaListExpression */:
       return 0 /* Comma */;
     case 230 /* SpreadElement */:
       return 1 /* Spread */;
@@ -19573,6 +19623,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 */:
@@ -21207,11 +21258,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;
@@ -22385,8 +22437,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);
@@ -22414,15 +22491,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);
 }
@@ -22499,6 +22574,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;
@@ -22746,7 +22822,7 @@ function getContainingNodeArray(node) {
       return parent2.types;
     case 189 /* TupleType */:
     case 209 /* ArrayLiteralExpression */:
-    case 355 /* CommaListExpression */:
+    case 356 /* CommaListExpression */:
     case 275 /* NamedImports */:
     case 279 /* NamedExports */:
       return parent2.elements;
@@ -23285,6 +23361,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)) {
@@ -23368,6 +23445,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 */) {
@@ -23383,6 +23468,7 @@ function createNameResolver({
             if (getEmitScriptTarget(compilerOptions) >= 2 /* ES2015 */) {
               break;
             }
+          // falls through
           case 174 /* MethodDeclaration */:
           case 176 /* Constructor */:
           case 177 /* GetAccessor */:
@@ -24027,6 +24113,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);
     }
@@ -24808,6 +24895,7 @@ function createNodeFactory(flags, baseFactory2) {
     createSyntheticExpression,
     createSyntaxList: createSyntaxList3,
     createNotEmittedStatement,
+    createNotEmittedTypeElement,
     createPartiallyEmittedExpression,
     updatePartiallyEmittedExpression,
     createCommaListExpression,
@@ -27834,7 +27922,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 */;
@@ -27844,6 +27932,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)) {
@@ -27856,7 +27947,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;
@@ -27865,7 +27956,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);
@@ -28112,7 +28203,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);
     }
   }
@@ -28657,7 +28748,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 */;
@@ -30366,10 +30457,10 @@ function isSyntheticExpression(node) {
   return node.kind === 237 /* SyntheticExpression */;
 }
 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 */;
@@ -30525,7 +30616,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 */;
@@ -31148,7 +31239,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;
@@ -31592,10 +31683,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:
@@ -32223,7 +32317,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) {
@@ -32319,7 +32413,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);
@@ -32689,6 +32783,7 @@ var Parser;
               expression2 = parseLiteralNode();
               break;
             }
+          // falls through
           default:
             expression2 = parseObjectLiteralExpression();
             break;
@@ -33610,6 +33705,7 @@ var Parser;
           case 25 /* DotToken */:
             return true;
         }
+      // falls through
       case 11 /* ArgumentExpressions */:
         return token() === 26 /* DotDotDotToken */ || isStartOfExpression();
       case 16 /* Parameters */:
@@ -33643,6 +33739,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'.");
     }
@@ -33959,6 +34056,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 */:
@@ -34006,6 +34104,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);
     }
@@ -34930,10 +35029,12 @@ var Parser;
         return tryParse(parseKeywordAndNoDot) || parseTypeReference();
       case 67 /* AsteriskEqualsToken */:
         scanner2.reScanAsteriskEqualsToken();
+      // falls through
       case 42 /* AsteriskToken */:
         return parseJSDocAllType();
       case 61 /* QuestionQuestionToken */:
         scanner2.reScanQuestionToken();
+      // falls through
       case 58 /* QuestionToken */:
         return parseJSDocUnknownOrNullableType();
       case 100 /* FunctionKeyword */:
@@ -35811,6 +35912,7 @@ var Parser;
         if (isAwaitExpression2()) {
           return parseAwaitExpression();
         }
+      // falls through
       default:
         return parseUpdateExpression();
     }
@@ -35830,6 +35932,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;
     }
@@ -36403,10 +36507,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 */:
@@ -36424,6 +36534,7 @@ var Parser;
             false
           );
         }
+      // falls through
       case 9 /* NumericLiteral */:
       case 10 /* BigIntLiteral */:
       case 11 /* StringLiteral */:
@@ -36927,6 +37038,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();
@@ -36999,6 +37131,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;
@@ -37137,6 +37272,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();
@@ -37555,10 +37692,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:
@@ -38465,6 +38607,7 @@ var Parser;
                   linkEnd = scanner2.getTokenEnd();
                   break;
                 }
+              // fallthrough if it's not a {@link sequence
               default:
                 state = 2 /* SavingComments */;
                 pushComment(scanner2.getTokenText());
@@ -38723,6 +38866,8 @@ var Parser;
                   indent3 += 1;
                   break;
                 }
+              // record the * as a comment
+              // falls through
               default:
                 if (state !== 3 /* SavingBackticks */) {
                   state = 2 /* SavingComments */;
@@ -39803,6 +39948,7 @@ function processPragmasIntoFields(context, reportDiagnostic) {
       case "jsximportsource":
       case "jsxruntime":
         return;
+      // Accessed directly
       default:
         Debug.fail("Unhandled pragma kind");
     }
@@ -41659,6 +41805,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++;
@@ -41999,6 +42146,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));
@@ -42478,8 +42626,6 @@ function parseJsonConfigFileContentWorker(json, sourceFile, host, basePath, exis
       validatedFilesSpecBeforeSubstitution,
       validatedIncludeSpecsBeforeSubstitution,
       validatedExcludeSpecsBeforeSubstitution,
-      pathPatterns: void 0,
-      // Initialized on first use
       isDefaultIncludeSpec
     };
   }
@@ -43207,6 +43353,7 @@ function getOptionValueWithEmptyStrings(value, option) {
       return typeof value === "boolean" ? value : "";
     case "listOrElement":
       if (!isArray(value)) return getOptionValueWithEmptyStrings(value, option.element);
+    // fall through to list
     case "list":
       const elementType = option.element;
       return isArray(value) ? mapDefined(value, (v) => getOptionValueWithEmptyStrings(v, elementType)) : "";
@@ -44183,8 +44330,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) {
@@ -44193,7 +44339,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,
@@ -44992,17 +45138,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);
     }
@@ -45594,17 +45731,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;
     }
@@ -45612,7 +45740,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);
@@ -45879,20 +46006,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 */) {
@@ -45909,6 +46040,7 @@ function getModuleInstanceStateWorker(node, visited) {
         return state;
       }
       break;
+    // 5. other uninstantiated module declarations.
     case 268 /* ModuleBlock */: {
       let state = 0 /* NonInstantiated */;
       forEachChild(node, (n) => {
@@ -46519,6 +46651,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);
@@ -46539,6 +46672,7 @@ function createBinder() {
       case 303 /* PropertyAssignment */:
       case 230 /* SpreadElement */:
         inAssignmentPattern = saveInAssignmentPattern;
+      // falls through
       default:
         bindEachChild(node);
         break;
@@ -46560,6 +46694,7 @@ function createBinder() {
         if (isJSDocTypeAssertion(expr)) {
           return false;
         }
+      // fallthrough
       case 235 /* NonNullExpression */:
         return isNarrowingExpression(expr.expression);
       case 226 /* BinaryExpression */:
@@ -47391,6 +47526,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 */:
@@ -47532,6 +47671,7 @@ function createBinder() {
           declareModuleMember(node, symbolFlags, symbolExcludes);
           break;
         }
+      // falls through
       default:
         Debug.assertNode(blockScopeContainer, canHaveLocals);
         if (!blockScopeContainer.locals) {
@@ -47852,6 +47992,7 @@ function createBinder() {
   }
   function bindWorker(node) {
     switch (node.kind) {
+      /* Strict mode checks */
       case 80 /* Identifier */:
         if (node.flags & 4096 /* IdentifierIsInJSDocNamespace */) {
           let parentNode = node.parent;
@@ -47861,6 +48002,7 @@ function createBinder() {
           bindBlockScopedDeclaration(parentNode, 524288 /* TypeAlias */, 788968 /* TypeAliasExcludes */);
           break;
         }
+      // falls through
       case 110 /* ThisKeyword */:
         if (currentFlow && (isExpression(node) || parent2.kind === 304 /* ShorthandPropertyAssignment */)) {
           node.flowNode = currentFlow;
@@ -47949,6 +48091,7 @@ function createBinder() {
         return;
       case 182 /* TypePredicate */:
         break;
+      // Binding the children will handle everything
       case 168 /* TypeParameter */:
         return bindTypeParameter(node);
       case 169 /* Parameter */:
@@ -48013,6 +48156,7 @@ function createBinder() {
             return bindObjectDefinePrototypeProperty(node);
           case 0 /* None */:
             break;
+          // Nothing to do
           default:
             return Debug.fail("Unknown call expression assignment declaration kind");
         }
@@ -48020,6 +48164,7 @@ function createBinder() {
           bindCallExpression(node);
         }
         break;
+      // Members of classes, interfaces, and modules
       case 231 /* ClassExpression */:
       case 263 /* ClassDeclaration */:
         inStrictMode = true;
@@ -48032,10 +48177,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 */:
@@ -48056,6 +48203,7 @@ function createBinder() {
         if (!isFunctionLikeOrClassStaticBlockDeclaration(node.parent)) {
           return;
         }
+      // falls through
       case 268 /* ModuleBlock */:
         return updateStrictModeStatementList(node.statements);
       case 341 /* JSDocParameterTag */:
@@ -48065,6 +48213,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 */;
@@ -48277,6 +48426,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:
@@ -48773,6 +48923,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 */:
@@ -51926,6 +52077,7 @@ function createTypeChecker(host) {
         if (isEntityNameExpression(node.expression)) {
           return node.expression;
         }
+      // falls through
       default:
         return void 0;
     }
@@ -53781,6 +53933,7 @@ function createTypeChecker(host) {
           if (!isExternalOrCommonJsModule(location)) {
             break;
           }
+        // falls through
         case 267 /* ModuleDeclaration */:
           const sym = getSymbolOfDeclaration(location);
           if (result = callback(
@@ -55203,6 +55356,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,
@@ -55240,15 +55396,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;
           }
@@ -55266,7 +55427,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;
@@ -55402,15 +55563,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
@@ -55426,11 +55589,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);
@@ -58025,6 +58190,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);
@@ -58797,6 +58963,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 */:
@@ -58821,6 +58988,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 */:
@@ -58838,14 +59007,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:
@@ -66395,6 +66570,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 */:
@@ -66642,6 +66820,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);
@@ -67061,6 +67240,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);
@@ -68156,7 +68336,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);
@@ -72380,6 +72560,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;
@@ -72413,6 +72594,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 */:
@@ -73966,6 +74148,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(
@@ -74409,6 +74594,7 @@ function createTypeChecker(host) {
               }
             }
           }
+        // falls through
         case 110 /* ThisKeyword */:
         case 108 /* SuperKeyword */:
         case 211 /* PropertyAccessExpression */:
@@ -82227,6 +82413,7 @@ function createTypeChecker(host) {
                 hasError = true;
                 break;
               }
+            // fallthrough
             case 7 /* ES2022 */:
             case 99 /* ESNext */:
             case 200 /* Preserve */:
@@ -82234,6 +82421,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;
@@ -82651,9 +82839,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;
     }
@@ -83899,6 +84091,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 */:
@@ -84268,6 +84461,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));
@@ -85011,6 +85205,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 */:
@@ -85031,6 +85227,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 */:
@@ -85044,6 +85242,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 */:
@@ -85392,6 +85591,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;
@@ -88613,6 +88813,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;
@@ -88625,6 +88826,7 @@ function createTypeChecker(host) {
           }
           break;
         }
+      // falls through
       case 263 /* ClassDeclaration */:
       case 266 /* EnumDeclaration */:
       case 262 /* FunctionDeclaration */:
@@ -89301,6 +89503,7 @@ function createTypeChecker(host) {
         return checkJSDocPropertyTag(node);
       case 317 /* JSDocFunctionType */:
         checkJSDocFunctionType(node);
+      // falls through
       case 315 /* JSDocNonNullableType */:
       case 314 /* JSDocNullableType */:
       case 312 /* JSDocAllType */:
@@ -89724,6 +89927,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;
@@ -89735,6 +89939,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) {
@@ -89843,6 +90050,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);
@@ -90136,6 +90344,7 @@ function createTypeChecker(host) {
         if (!isThisInTypeQuery(node)) {
           return getSymbolOfNameOrPropertyAccessExpression(node);
         }
+      // falls through
       case 110 /* ThisKeyword */:
         const container = getThisContainer(
           node,
@@ -90153,6 +90362,7 @@ function createTypeChecker(host) {
         if (isInExpressionContext(node)) {
           return checkExpression(node).symbol;
         }
+      // falls through
       case 197 /* ThisType */:
         return getTypeFromThisTypeNode(node).symbol;
       case 108 /* SuperKeyword */:
@@ -90175,6 +90385,7 @@ function createTypeChecker(host) {
         if (isCallExpression(parent2) && isBindableObjectDefinePropertyCall(parent2) && parent2.arguments[1] === node) {
           return getSymbolOfDeclaration(parent2);
         }
+      // falls through
       case 9 /* NumericLiteral */:
         const objectType = isElementAccessExpression(parent2) ? parent2.argumentExpression === node ? getTypeOfExpression(parent2.expression) : void 0 : isLiteralTypeNode(parent2) && isIndexedAccessTypeNode(grandParent) ? getTypeFromTypeNode(grandParent.objectType) : void 0;
         return objectType && getPropertyOfType(objectType, escapeLeadingUnderscores(node.text));
@@ -90204,6 +90415,7 @@ function createTypeChecker(host) {
           const symbol = getIntrinsicTagSymbol(node.parent);
           return symbol === unknownSymbol ? void 0 : symbol;
         }
+      // falls through
       default:
         return void 0;
     }
@@ -92298,6 +92510,7 @@ function createTypeChecker(host) {
                   );
                   break;
                 }
+              // fallthrough
               case 7 /* ES2022 */:
               case 99 /* ESNext */:
               case 200 /* Preserve */:
@@ -92305,6 +92518,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)
@@ -94481,13 +94695,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)
@@ -96593,6 +96807,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 */:
@@ -96621,6 +96837,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 */:
@@ -98303,7 +98521,7 @@ function transformClassFields(context) {
           /*discarded*/
           true
         );
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -100243,6 +100461,7 @@ function transformClassFields(context) {
         if (isArrowFunction(original) || getEmitFlags(node) & 524288 /* AsyncFunctionBody */) {
           break;
         }
+      // falls through
       case 262 /* FunctionDeclaration */:
       case 176 /* Constructor */:
       case 177 /* GetAccessor */:
@@ -100518,6 +100737,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 */:
@@ -101363,6 +101583,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,
@@ -101383,7 +101604,7 @@ function transformESDecorators(context) {
         return visitForStatement(node);
       case 244 /* ExpressionStatement */:
         return visitExpressionStatement(node);
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -101395,7 +101616,7 @@ function transformESDecorators(context) {
           /*discarded*/
           false
         );
-      case 354 /* PartiallyEmittedExpression */:
+      case 355 /* PartiallyEmittedExpression */:
         return visitPartiallyEmittedExpression(
           node,
           /*discarded*/
@@ -101419,6 +101640,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 */:
@@ -101481,7 +101703,7 @@ function transformESDecorators(context) {
           /*discarded*/
           true
         );
-      case 355 /* CommaListExpression */:
+      case 356 /* CommaListExpression */:
         return visitCommaListExpression(
           node,
           /*discarded*/
@@ -104063,7 +104285,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);
@@ -107203,6 +107425,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 */:
@@ -107281,7 +107504,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 */:
@@ -107665,12 +107888,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 */:
@@ -107879,12 +108104,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 */:
@@ -107930,12 +108157,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 */:
@@ -110567,7 +110796,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);
@@ -112958,7 +113187,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)) {
@@ -114718,6 +114947,7 @@ function transformSystemModule(context) {
             if (!entry.importClause) {
               break;
             }
+          // falls through
           case 271 /* ImportEqualsDeclaration */:
             Debug.assert(importVariableName !== void 0);
             statements.push(
@@ -115352,7 +115582,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)) {
@@ -116951,6 +117181,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 */:
@@ -118232,7 +118463,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;
@@ -119446,6 +119677,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) {
@@ -119453,14 +119685,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:
@@ -119512,6 +119747,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     if (hint === 4 /* Unspecified */) {
       switch (node.kind) {
+        // Pseudo-literals
         case 16 /* TemplateHead */:
         case 17 /* TemplateMiddle */:
         case 18 /* TemplateTail */:
@@ -119520,20 +119756,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 */:
@@ -119555,6 +119797,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitConstructSignature(node);
         case 181 /* IndexSignature */:
           return emitIndexSignature(node);
+        // Types
         case 182 /* TypePredicate */:
           return emitTypePredicate(node);
         case 183 /* TypeReference */:
@@ -119573,6 +119816,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 */:
@@ -119603,16 +119847,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 */:
@@ -119654,6 +119901,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitTryStatement(node);
         case 259 /* DebuggerStatement */:
           return emitDebuggerStatement(node);
+        // Declarations
         case 260 /* VariableDeclaration */:
           return emitVariableDeclaration(node);
         case 261 /* VariableDeclarationList */:
@@ -119704,8 +119952,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 */:
@@ -119724,6 +119974,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
           return emitJsxExpression(node);
         case 295 /* JsxNamespacedName */:
           return emitJsxNamespacedName(node);
+        // Clauses
         case 296 /* CaseClause */:
           return emitCaseClause(node);
         case 297 /* DefaultClause */:
@@ -119732,18 +119983,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 */:
@@ -119781,6 +120036,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 */:
@@ -119790,6 +120046,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);
@@ -119808,7 +120065,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)) {
@@ -119826,6 +120086,7 @@ function createPrinter(printerOptions = {}, handlers = {}) {
     }
     if (hint === 1 /* Expression */) {
       switch (node.kind) {
+        // Literals
         case 9 /* NumericLiteral */:
         case 10 /* BigIntLiteral */:
           return emitNumericOrBigIntLiteral(node);
@@ -119837,10 +120098,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 */:
@@ -119903,21 +120166,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");
       }
     }
@@ -126100,6 +126366,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 */:
@@ -126231,6 +126498,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 === parent2.modifiers) {
               checkModifiers(parent2.modifiers, parent2.kind === 243 /* VariableStatement */);
@@ -126273,6 +126541,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 */:
@@ -126284,6 +126554,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 */:
@@ -131750,6 +132021,7 @@ function getSourceFileVersionAsHashFromText(host, text) {
           if (pos && text.charCodeAt(pos - 1) === 13 /* carriageReturn */) {
             pos--;
           }
+        // falls through
         case 13 /* carriageReturn */:
           break;
         default:
@@ -133287,6 +133559,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);
@@ -133827,6 +134100,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 */)) {
@@ -134344,6 +134618,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:
@@ -136176,6 +136452,7 @@ function renderPackageNameValidationFailureWorker(typing, result, name, isScopeN
       return `'${typing}':: ${kind} name '${name}' contains non URI safe characters`;
     case 0 /* Ok */:
       return Debug.fail();
+    // Shouldn't have called this.
     default:
       Debug.assertNever(result);
   }
@@ -136552,6 +136829,7 @@ function getMeaningFromDeclaration(node) {
     case 277 /* ExportAssignment */:
     case 278 /* ExportDeclaration */:
       return 7 /* All */;
+    // An external module can be a Value
     case 307 /* SourceFile */:
       return 4 /* Namespace */ | 1 /* Value */;
   }
@@ -136860,6 +137138,7 @@ function getNodeKind(node) {
           return isFunctionExpression(right) ? "method" /* memberFunctionElement */ : "property" /* memberVariableElement */;
         case 4 /* ThisProperty */:
           return "property" /* memberVariableElement */;
+        // property
         case 5 /* Property */:
           return isFunctionExpression(right) ? "method" /* memberFunctionElement */ : "property" /* memberVariableElement */;
         case 6 /* Prototype */:
@@ -136953,6 +137232,7 @@ function isCompletedNode(n, sourceFile) {
       if (!n.arguments) {
         return true;
       }
+    // falls through
     case 213 /* CallExpression */:
     case 217 /* ParenthesizedExpression */:
     case 196 /* ParenthesizedType */:
@@ -137681,16 +137961,19 @@ function getPossibleTypeArgumentsInfo(tokenIn, sourceFile) {
         token = findPrecedingMatchingToken(token, 23 /* OpenBracketToken */, sourceFile);
         if (!token) return void 0;
         break;
+      // Valid tokens in a type name. Skip.
       case 28 /* CommaToken */:
         nTypeArguments++;
         break;
       case 39 /* EqualsGreaterThanToken */:
+      // falls through
       case 80 /* Identifier */:
       case 11 /* StringLiteral */:
       case 9 /* NumericLiteral */:
       case 10 /* BigIntLiteral */:
       case 112 /* TrueKeyword */:
       case 97 /* FalseKeyword */:
+      // falls through
       case 114 /* TypeOfKeyword */:
       case 96 /* ExtendsKeyword */:
       case 143 /* KeyOfKeyword */:
@@ -139964,6 +140247,7 @@ function canFollow(keyword1, keyword2) {
     case 126 /* StaticKeyword */:
     case 129 /* AccessorKeyword */:
       return true;
+    // Allow things like "public get", "public constructor" and "public static".
     default:
       return false;
   }
@@ -140774,6 +141058,7 @@ var DocumentHighlights;
           if (statement.kind === 251 /* ContinueStatement */) {
             return false;
           }
+        // falls through
         case 248 /* ForStatement */:
         case 249 /* ForInStatement */:
         case 250 /* ForOfStatement */:
@@ -140819,6 +141104,7 @@ var DocumentHighlights;
           return [...nodes, container];
         }
         return nodes;
+      // Syntactically invalid positions that the parser might produce anyway
       default:
         return void 0;
     }
@@ -142398,8 +142684,10 @@ function isFixablePromiseArgument(arg, checker) {
       if (functionFlags & 1 /* Generator */) {
         return false;
       }
+    // falls through
     case 219 /* ArrowFunction */:
       visitedNestedConvertibleFunctions.set(getKeyFromNode(arg), true);
+    // falls through
     case 106 /* NullKeyword */:
       return true;
     case 80 /* Identifier */:
@@ -143072,6 +143360,7 @@ function addChildrenRecursively(node) {
           Debug.assertNever(special);
       }
     }
+    // falls through
     default:
       if (hasJSDocNodes(node)) {
         forEach(node.jsDoc, (jsDoc) => {
@@ -143664,6 +143953,7 @@ function changeExport(exportingSourceFile, { wasDefault, exportNode, exportName
           changes.replaceNode(exportingSourceFile, exportNode, factory.createExportDefault(Debug.checkDefined(decl.initializer, "Initializer was previously known to be present")));
           break;
         }
+      // falls through
       case 266 /* EnumDeclaration */:
       case 265 /* TypeAliasDeclaration */:
       case 267 /* ModuleDeclaration */:
@@ -144770,6 +145060,7 @@ function getNamesToExportInCommonJS(decl) {
     case 262 /* FunctionDeclaration */:
     case 263 /* ClassDeclaration */:
       return [decl.name.text];
+    // TODO: GH#18217
     case 243 /* VariableStatement */:
       return mapDefined(decl.declarationList.declarations, (d) => isIdentifier(d.name) ? d.name.text : void 0);
     case 267 /* ModuleDeclaration */:
@@ -146232,6 +146523,7 @@ function entryToFunctionCall(entry) {
     const functionReference = entry.node;
     const parent2 = functionReference.parent;
     switch (parent2.kind) {
+      // foo(...) or super(...) or new Foo(...)
       case 213 /* CallExpression */:
       case 214 /* NewExpression */:
         const callOrNewExpression = tryCast(parent2, isCallOrNewExpression);
@@ -146239,6 +146531,7 @@ function entryToFunctionCall(entry) {
           return callOrNewExpression;
         }
         break;
+      // x.foo(...)
       case 211 /* PropertyAccessExpression */:
         const propertyAccessExpression = tryCast(parent2, isPropertyAccessExpression);
         if (propertyAccessExpression && propertyAccessExpression.parent && propertyAccessExpression.name === functionReference) {
@@ -146248,6 +146541,7 @@ function entryToFunctionCall(entry) {
           }
         }
         break;
+      // x["foo"](...)
       case 212 /* ElementAccessExpression */:
         const elementAccessExpression = tryCast(parent2, isElementAccessExpression);
         if (elementAccessExpression && elementAccessExpression.parent && elementAccessExpression.argumentExpression === functionReference) {
@@ -146266,12 +146560,14 @@ function entryToAccessExpression(entry) {
     const reference = entry.node;
     const parent2 = reference.parent;
     switch (parent2.kind) {
+      // `C.foo`
       case 211 /* PropertyAccessExpression */:
         const propertyAccessExpression = tryCast(parent2, isPropertyAccessExpression);
         if (propertyAccessExpression && propertyAccessExpression.expression === reference) {
           return propertyAccessExpression;
         }
         break;
+      // `C["foo"]`
       case 212 /* ElementAccessExpression */:
         const elementAccessExpression = tryCast(parent2, isElementAccessExpression);
         if (elementAccessExpression && elementAccessExpression.expression === reference) {
@@ -147364,11 +147660,13 @@ function getRangeToExtract2(sourceFile, span, invoked = true) {
               forEachChild(n, check);
             }
           });
+        // falls through
         case 263 /* ClassDeclaration */:
         case 262 /* FunctionDeclaration */:
           if (isSourceFile(node2.parent) && node2.parent.externalModuleIndicator === void 0) {
             (errors2 || (errors2 = [])).push(createDiagnosticForNode(node2, Messages.functionWillNotBeVisibleInTheNewScope));
           }
+        // falls through
         case 231 /* ClassExpression */:
         case 218 /* FunctionExpression */:
         case 174 /* MethodDeclaration */:
@@ -149543,6 +149841,7 @@ var SourceFileObject = class extends NodeObject {
           if (!hasSyntacticModifier(node, 31 /* ParameterPropertyModifier */)) {
             break;
           }
+        // falls through
         case 260 /* VariableDeclaration */:
         case 208 /* BindingElement */: {
           const decl = node;
@@ -149554,6 +149853,7 @@ var SourceFileObject = class extends NodeObject {
             visit(decl.initializer);
           }
         }
+        // falls through
         case 306 /* EnumMember */:
         case 172 /* PropertyDeclaration */:
         case 171 /* PropertySignature */:
@@ -149588,6 +149888,7 @@ var SourceFileObject = class extends NodeObject {
           if (getAssignmentDeclarationKind(node) !== 0 /* None */) {
             addDeclaration(node);
           }
+        // falls through
         default:
           forEachChild(node, visit);
       }
@@ -150475,6 +150776,7 @@ function createLanguageService(host, documentRegistry = createDocumentRegistry(h
       case 197 /* ThisType */:
       case 80 /* Identifier */:
         break;
+      // Cant create the text span
       default:
         return void 0;
     }
@@ -151192,6 +151494,7 @@ function getContainingObjectLiteralElementWorker(node) {
       if (node.parent.kind === 167 /* ComputedPropertyName */) {
         return isObjectLiteralElement(node.parent.parent) ? node.parent.parent : void 0;
       }
+    // falls through
     case 80 /* Identifier */:
       return isObjectLiteralElement(node.parent) && (node.parent.parent.kind === 210 /* ObjectLiteralExpression */ || node.parent.parent.kind === 292 /* JsxAttributes */) && node.parent.name === node ? node.parent : void 0;
   }
@@ -151346,6 +151649,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
           if (isFunctionBlock(node)) {
             return spanInFunctionBlock(node);
           }
+        // falls through
         case 268 /* ModuleBlock */:
           return spanInBlock(node);
         case 299 /* CatchClause */:
@@ -151394,6 +151698,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
           if (getModuleInstanceState(node) !== 1 /* Instantiated */) {
             return void 0;
           }
+        // falls through
         case 263 /* ClassDeclaration */:
         case 266 /* EnumDeclaration */:
         case 306 /* EnumMember */:
@@ -151406,9 +151711,11 @@ function spanInSourceFileAtLocation(sourceFile, position) {
         case 206 /* ObjectBindingPattern */:
         case 207 /* ArrayBindingPattern */:
           return spanInBindingPattern(node);
+        // No breakpoint in interface, type alias
         case 264 /* InterfaceDeclaration */:
         case 265 /* TypeAliasDeclaration */:
           return void 0;
+        // Tokens:
         case 27 /* SemicolonToken */:
         case 1 /* EndOfFileToken */:
           return spanInNodeIfStartsOnSameLine(findPrecedingToken(node.pos, sourceFile));
@@ -151429,6 +151736,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
         case 32 /* GreaterThanToken */:
         case 30 /* LessThanToken */:
           return spanInGreaterThanOrLessThanToken(node);
+        // Keywords:
         case 117 /* WhileKeyword */:
           return spanInWhileKeyword(node);
         case 93 /* ElseKeyword */:
@@ -151579,10 +151887,13 @@ function spanInSourceFileAtLocation(sourceFile, position) {
           if (getModuleInstanceState(block.parent) !== 1 /* Instantiated */) {
             return void 0;
           }
+        // Set on parent if on same line otherwise on first statement
+        // falls through
         case 247 /* WhileStatement */:
         case 245 /* IfStatement */:
         case 249 /* ForInStatement */:
           return spanInNodeIfStartsOnSameLine(block.parent, block.statements[0]);
+        // Set span on previous token if it starts on same line otherwise on the first statement of the block
         case 248 /* ForStatement */:
         case 250 /* ForOfStatement */:
           return spanInNodeIfStartsOnSameLine(findPrecedingToken(block.pos, sourceFile, block.parent), block.statements[0]);
@@ -151648,6 +151959,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
           if (getModuleInstanceState(node2.parent.parent) !== 1 /* Instantiated */) {
             return void 0;
           }
+        // falls through
         case 266 /* EnumDeclaration */:
         case 263 /* ClassDeclaration */:
           return textSpan(node2);
@@ -151655,6 +151967,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
           if (isFunctionBlock(node2.parent)) {
             return textSpan(node2);
           }
+        // falls through
         case 299 /* CatchClause */:
           return spanInNode(lastOrUndefined(node2.parent.statements));
         case 269 /* CaseBlock */:
@@ -151667,6 +151980,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
         case 206 /* ObjectBindingPattern */:
           const bindingPattern = node2.parent;
           return spanInNode(lastOrUndefined(bindingPattern.elements) || bindingPattern);
+        // Default to parent node
         default:
           if (isArrayLiteralOrObjectLiteralDestructuringPattern(node2.parent)) {
             const objectLiteral = node2.parent;
@@ -151716,6 +152030,7 @@ function spanInSourceFileAtLocation(sourceFile, position) {
         case 214 /* NewExpression */:
         case 217 /* ParenthesizedExpression */:
           return spanInPreviousNode(node2);
+        // Default to parent node
         default:
           return spanInNode(node2.parent);
       }
@@ -154308,6 +154623,7 @@ function convertStatement(sourceFile, statement, checker, changes, identifiers,
         }
       }
     }
+    // falls through
     default:
       return false;
   }
@@ -154407,6 +154723,8 @@ function tryChangeModuleExportsObject(object, useSitesToUnqualify) {
     switch (prop.kind) {
       case 177 /* GetAccessor */:
       case 178 /* SetAccessor */:
+      // TODO: Maybe we should handle this? See fourslash test `refactorConvertToEs6Module_export_object_shorthand.ts`.
+      // falls through
       case 304 /* ShorthandPropertyAssignment */:
       case 305 /* SpreadAssignment */:
         return void 0;
@@ -154488,6 +154806,7 @@ function convertExportsDotXEquals_replaceNode(name, exported, useSitesToUnqualif
         return exportConst();
       }
     }
+    // falls through
     case 219 /* ArrowFunction */:
       return functionExpressionToDeclaration(name, modifiers, exported, useSitesToUnqualify);
     case 231 /* ClassExpression */:
@@ -154536,6 +154855,7 @@ function convertSingleImport(name, moduleSpecifier, checker, identifiers, target
         )]);
       }
     }
+    // falls through -- object destructuring has an interesting pattern and must be a variable declaration
     case 207 /* ArrayBindingPattern */: {
       const tmp = makeUniqueName(moduleSpecifierToValidIdentifier(moduleSpecifier.text, target), identifiers);
       return convertedImports([
@@ -159612,6 +159932,7 @@ function doChange27(changes, sourceFile, start, length2, errorCode) {
           }
           return;
         }
+      // falls through
       case 247 /* WhileStatement */:
       case 248 /* ForStatement */:
         changes.delete(sourceFile, container);
@@ -160876,6 +161197,7 @@ function getDiagnostic(errorCode, token) {
     case Diagnostics.Parameter_0_implicitly_has_an_1_type.code:
     case Diagnostics.Parameter_0_implicitly_has_an_1_type_but_a_better_type_may_be_inferred_from_usage.code:
       return isSetAccessorDeclaration(getContainingFunction(token)) ? Diagnostics.Infer_type_of_0_from_usage : Diagnostics.Infer_parameter_types_from_usage;
+    // TODO: GH#18217
     case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code:
     case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type_but_a_better_type_may_be_inferred_from_usage.code:
       return Diagnostics.Infer_parameter_types_from_usage;
@@ -160914,6 +161236,7 @@ function doChange33(changes, sourceFile, token, errorCode, program, cancellation
   const importAdder = createImportAdder(sourceFile, program, preferences, host);
   errorCode = mapSuggestionDiagnostic(errorCode);
   switch (errorCode) {
+    // Variable and Property declarations
     case Diagnostics.Member_0_implicitly_has_an_1_type.code:
     case Diagnostics.Variable_0_implicitly_has_type_1_in_some_locations_where_its_type_cannot_be_determined.code:
       if (isVariableDeclaration(parent2) && markSeen(parent2) || isPropertyDeclaration(parent2) || isPropertySignature(parent2)) {
@@ -160954,12 +161277,14 @@ function doChange33(changes, sourceFile, token, errorCode, program, cancellation
   }
   let declaration;
   switch (errorCode) {
+    // Parameter declarations
     case Diagnostics.Parameter_0_implicitly_has_an_1_type.code:
       if (isSetAccessorDeclaration(containingFunction)) {
         annotateSetAccessor(changes, importAdder, sourceFile, containingFunction, program, host, cancellationToken);
         declaration = containingFunction;
         break;
       }
+    // falls through
     case Diagnostics.Rest_parameter_0_implicitly_has_an_any_type.code:
       if (markSeen(containingFunction)) {
         const param = cast(parent2, isParameter);
@@ -160967,6 +161292,7 @@ function doChange33(changes, sourceFile, token, errorCode, program, cancellation
         declaration = param;
       }
       break;
+    // Get Accessor declarations
     case Diagnostics.Property_0_implicitly_has_type_any_because_its_get_accessor_lacks_a_return_type_annotation.code:
     case Diagnostics._0_which_lacks_return_type_annotation_implicitly_has_an_1_return_type.code:
       if (isGetAccessorDeclaration(containingFunction) && isIdentifier(containingFunction.name)) {
@@ -160974,12 +161300,14 @@ function doChange33(changes, sourceFile, token, errorCode, program, cancellation
         declaration = containingFunction;
       }
       break;
+    // Set Accessor declarations
     case Diagnostics.Property_0_implicitly_has_type_any_because_its_set_accessor_lacks_a_parameter_type_annotation.code:
       if (isSetAccessorDeclaration(containingFunction)) {
         annotateSetAccessor(changes, importAdder, sourceFile, containingFunction, program, host, cancellationToken);
         declaration = containingFunction;
       }
       break;
+    // Function 'this'
     case Diagnostics.this_implicitly_has_type_any_because_it_does_not_have_a_type_annotation.code:
       if (ts_textChanges_exports.isThisTypeAnnotatable(containingFunction) && markSeen(containingFunction)) {
         annotateThis(changes, sourceFile, containingFunction, program, host, cancellationToken);
@@ -161361,6 +161689,7 @@ function inferTypeFromReferences(program, references, cancellationToken) {
           break;
         }
       }
+      // falls through
       default:
         return inferTypeFromContextualType(node, usage);
     }
@@ -161388,16 +161717,25 @@ function inferTypeFromReferences(program, references, cancellationToken) {
   }
   function inferTypeFromBinaryExpression(node, parent2, usage) {
     switch (parent2.operatorToken.kind) {
+      // ExponentiationOperator
       case 43 /* AsteriskAsteriskToken */:
+      // MultiplicativeOperator
+      // falls through
       case 42 /* AsteriskToken */:
       case 44 /* SlashToken */:
       case 45 /* PercentToken */:
+      // ShiftOperator
+      // falls through
       case 48 /* LessThanLessThanToken */:
       case 49 /* GreaterThanGreaterThanToken */:
       case 50 /* GreaterThanGreaterThanGreaterThanToken */:
+      // BitwiseOperator
+      // falls through
       case 51 /* AmpersandToken */:
       case 52 /* BarToken */:
       case 53 /* CaretToken */:
+      // CompoundAssignmentOperator
+      // falls through
       case 66 /* MinusEqualsToken */:
       case 68 /* AsteriskAsteriskEqualsToken */:
       case 67 /* AsteriskEqualsToken */:
@@ -161409,7 +161747,11 @@ function inferTypeFromReferences(program, references, cancellationToken) {
       case 71 /* LessThanLessThanEqualsToken */:
       case 73 /* GreaterThanGreaterThanGreaterThanEqualsToken */:
       case 72 /* GreaterThanGreaterThanEqualsToken */:
+      // AdditiveOperator
+      // falls through
       case 41 /* MinusToken */:
+      // RelationalOperator
+      // falls through
       case 30 /* LessThanToken */:
       case 33 /* LessThanEqualsToken */:
       case 32 /* GreaterThanToken */:
@@ -161435,6 +161777,7 @@ function inferTypeFromReferences(program, references, cancellationToken) {
           usage.isNumberOrString = true;
         }
         break;
+      //  AssignmentOperators
       case 64 /* EqualsToken */:
       case 35 /* EqualsEqualsToken */:
       case 37 /* EqualsEqualsEqualsToken */:
@@ -161450,6 +161793,7 @@ function inferTypeFromReferences(program, references, cancellationToken) {
           usage.isString = true;
         }
         break;
+      // LogicalOperator Or NullishCoalescing
       case 57 /* BarBarToken */:
       case 61 /* QuestionQuestionToken */:
         if (node === parent2.left && (node.parent.parent.kind === 260 /* VariableDeclaration */ || isAssignmentExpression(
@@ -161954,11 +162298,10 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
   const optional = !!(symbol.flags & 16777216 /* Optional */);
   const ambient = !!(enclosingDeclaration.flags & 33554432 /* Ambient */) || isAmbient;
   const quotePreference = getQuotePreference(sourceFile, preferences);
+  const flags = 1 /* NoTruncation */ | (quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0 /* None */);
   switch (kind) {
     case 171 /* PropertySignature */:
     case 172 /* PropertyDeclaration */:
-      let flags = 1 /* NoTruncation */;
-      flags |= quotePreference === 0 /* Single */ ? 268435456 /* UseSingleQuotesForStringLiteralType */ : 0;
       let typeNode = checker.typeToTypeNode(type, enclosingDeclaration, flags, 8 /* AllowUnresolvedNames */, getNoopSymbolTrackerWithResolver(context));
       if (importAdder) {
         const importableReference = tryGetAutoImportableReferenceFromTypeNode(typeNode, scriptTarget);
@@ -161982,8 +162325,7 @@ function addNewNodeForMemberSymbol(symbol, enclosingDeclaration, sourceFile, con
       let typeNode2 = checker.typeToTypeNode(
         type,
         enclosingDeclaration,
-        /*flags*/
-        void 0,
+        flags,
         /*internalFlags*/
         void 0,
         getNoopSymbolTrackerWithResolver(context)
@@ -165703,6 +166045,7 @@ function getContextualType(previousToken, position, sourceFile, checker) {
       switch (parent2.kind) {
         case 260 /* VariableDeclaration */:
           return checker.getContextualType(parent2.initializer);
+        // TODO: GH#18217
         case 226 /* BinaryExpression */:
           return checker.getTypeAtLocation(parent2.left);
         case 291 /* JsxAttribute */:
@@ -165889,6 +166232,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
           if (!binaryExpressionMayBeOpenTag(parent2)) {
             break;
           }
+        // falls through
         case 285 /* JsxSelfClosingElement */:
         case 284 /* JsxElement */:
         case 286 /* JsxOpeningElement */:
@@ -166508,6 +166852,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         case 28 /* CommaToken */:
           switch (containingNodeKind) {
             case 213 /* CallExpression */:
+            // func( a, |
             case 214 /* NewExpression */: {
               const expression = contextToken.parent.expression;
               if (getLineAndCharacterOfPosition(sourceFile, expression.end).line !== getLineAndCharacterOfPosition(sourceFile, position).line) {
@@ -166518,7 +166863,9 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
             case 226 /* BinaryExpression */:
               return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true };
             case 176 /* Constructor */:
+            // constructor( a, | /* public, protected, private keywords are allowed here, so show completion */
             case 184 /* FunctionType */:
+            // var x: (s: string, list|
             case 210 /* ObjectLiteralExpression */:
               return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
             case 209 /* ArrayLiteralExpression */:
@@ -166529,6 +166876,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         case 21 /* OpenParenToken */:
           switch (containingNodeKind) {
             case 213 /* CallExpression */:
+            // func( |
             case 214 /* NewExpression */: {
               const expression = contextToken.parent.expression;
               if (getLineAndCharacterOfPosition(sourceFile, expression.end).line !== getLineAndCharacterOfPosition(sourceFile, position).line) {
@@ -166539,6 +166887,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
             case 217 /* ParenthesizedExpression */:
               return { defaultCommitCharacters: noCommaCommitCharacters, isNewIdentifierLocation: true };
             case 176 /* Constructor */:
+            // constructor( |
             case 196 /* ParenthesizedType */:
               return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
             default:
@@ -166547,15 +166896,20 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         case 23 /* OpenBracketToken */:
           switch (containingNodeKind) {
             case 209 /* ArrayLiteralExpression */:
+            // [ |
             case 181 /* IndexSignature */:
+            // [ | : string ]
             case 189 /* TupleType */:
+            // [ | : string ]
             case 167 /* ComputedPropertyName */:
               return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true };
             default:
               return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: false };
           }
         case 144 /* ModuleKeyword */:
+        // module |
         case 145 /* NamespaceKeyword */:
+        // namespace |
         case 102 /* ImportKeyword */:
           return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
         case 25 /* DotToken */:
@@ -166568,6 +166922,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         case 19 /* OpenBraceToken */:
           switch (containingNodeKind) {
             case 263 /* ClassDeclaration */:
+            // class A { |
             case 210 /* ObjectLiteralExpression */:
               return { defaultCommitCharacters: [], isNewIdentifierLocation: true };
             default:
@@ -166576,6 +166931,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         case 64 /* EqualsToken */:
           switch (containingNodeKind) {
             case 260 /* VariableDeclaration */:
+            // const x = a|
             case 226 /* BinaryExpression */:
               return { defaultCommitCharacters: allCommitCharacters, isNewIdentifierLocation: true };
             default:
@@ -166830,6 +167186,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
       const parent2 = contextToken2.parent;
       switch (contextToken2.kind) {
         case 32 /* GreaterThanToken */:
+        // End of a type argument list
         case 31 /* LessThanSlashToken */:
         case 44 /* SlashToken */:
         case 80 /* Identifier */:
@@ -166852,6 +167209,9 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
             return parent2.parent.parent;
           }
           break;
+        // The context token is the closing } or " of an attribute, which means
+        // its parent is a JsxExpression, whose parent is a JsxAttribute,
+        // whose parent is a JsxOpeningLikeElement
         case 11 /* StringLiteral */:
           if (parent2 && (parent2.kind === 291 /* JsxAttribute */ || parent2.kind === 293 /* JsxSpreadAttribute */)) {
             return parent2.parent.parent;
@@ -166886,14 +167246,18 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         isClassLike(parent2) && !!parent2.typeParameters && parent2.typeParameters.end >= contextToken2.pos;
       case 25 /* DotToken */:
         return containingNodeKind === 207 /* ArrayBindingPattern */;
+      // var [.|
       case 59 /* ColonToken */:
         return containingNodeKind === 208 /* BindingElement */;
+      // var {x :html|
       case 23 /* OpenBracketToken */:
         return containingNodeKind === 207 /* ArrayBindingPattern */;
+      // var [x|
       case 21 /* OpenParenToken */:
         return containingNodeKind === 299 /* CatchClause */ || isFunctionLikeButNotConstructor(containingNodeKind);
       case 19 /* OpenBraceToken */:
         return containingNodeKind === 266 /* EnumDeclaration */;
+      // enum a { |
       case 30 /* LessThanToken */:
         return containingNodeKind === 263 /* ClassDeclaration */ || // class A< |
         containingNodeKind === 231 /* ClassExpression */ || // var C = class D< |
@@ -166904,6 +167268,7 @@ function getCompletionData(program, log, sourceFile, compilerOptions, position,
         return containingNodeKind === 172 /* PropertyDeclaration */ && !isClassLike(parent2.parent);
       case 26 /* DotDotDotToken */:
         return containingNodeKind === 169 /* Parameter */ || !!parent2.parent && parent2.parent.kind === 207 /* ArrayBindingPattern */;
+      // var [...z|
       case 125 /* PublicKeyword */:
       case 123 /* PrivateKeyword */:
       case 124 /* ProtectedKeyword */:
@@ -167130,6 +167495,7 @@ function tryGetObjectLikeCompletionContainer(contextToken, position, sourceFile)
     const { parent: parent2 } = contextToken;
     switch (contextToken.kind) {
       case 19 /* OpenBraceToken */:
+      // const x = { |
       case 28 /* CommaToken */:
         if (isObjectLiteralExpression(parent2) || isObjectBindingPattern(parent2)) {
           return parent2;
@@ -167407,9 +167773,11 @@ function tryGetObjectTypeDeclarationCompletionContainer(sourceFile, contextToken
     case 64 /* EqualsToken */:
       return void 0;
     case 27 /* SemicolonToken */:
+    // class c {getValue(): number; | }
     case 20 /* CloseBraceToken */:
       return isFromObjectTypeDeclaration(location) && location.parent.name === location ? location.parent.parent : tryCast(location, isObjectTypeDeclaration);
     case 19 /* OpenBraceToken */:
+    // class c { |
     case 28 /* CommaToken */:
       return tryCast(contextToken.parent, isObjectTypeDeclaration);
     default:
@@ -167915,6 +168283,7 @@ function getStringLiteralCompletionEntries(sourceFile, node, position, program,
         const argumentInfo = ts_SignatureHelp_exports.getArgumentInfoForCompletions(parent2.kind === 291 /* JsxAttribute */ ? parent2.parent : node, position, sourceFile, typeChecker);
         return argumentInfo && getStringLiteralCompletionsFromSignature(argumentInfo.invocation, node, argumentInfo, typeChecker) || fromContextualType(0 /* None */);
       }
+    // falls through (is `require("")` or `require(""` or `import("")`)
     case 272 /* ImportDeclaration */:
     case 278 /* ExportDeclaration */:
     case 283 /* ExternalModuleReference */:
@@ -168721,6 +169090,7 @@ function getImportersForExport(sourceFiles, sourceFilesSet, allDirectImports, {
             break;
           case 80 /* Identifier */:
             break;
+          // TODO: GH#23879
           case 271 /* ImportEqualsDeclaration */:
             handleNamespaceImport(
               direct,
@@ -169615,6 +169985,7 @@ function declarationIsWriteAccess(decl) {
     case 306 /* EnumMember */:
     case 281 /* ExportSpecifier */:
     case 273 /* ImportClause */:
+    // default import
     case 271 /* ImportEqualsDeclaration */:
     case 276 /* ImportSpecifier */:
     case 264 /* InterfaceDeclaration */:
@@ -170001,6 +170372,7 @@ var Core;
           Debug.assert(node.parent.name === node);
           return 2 /* Class */;
         }
+      // falls through
       default:
         return 0 /* None */;
     }
@@ -170332,6 +170704,7 @@ var Core;
         if (isJSDocMemberName(node.parent)) {
           return true;
         }
+      // falls through I guess
       case 80 /* Identifier */:
         return node.text.length === searchSymbolName.length;
       case 15 /* NoSubstitutionTemplateLiteral */:
@@ -170757,6 +171130,7 @@ var Core;
           searchSpaceNode = searchSpaceNode.parent;
           break;
         }
+      // falls through
       case 172 /* PropertyDeclaration */:
       case 171 /* PropertySignature */:
       case 176 /* Constructor */:
@@ -170769,9 +171143,12 @@ var Core;
         if (isExternalModule(searchSpaceNode) || isParameterName(thisOrSuperKeyword)) {
           return void 0;
         }
+      // falls through
       case 262 /* FunctionDeclaration */:
       case 218 /* FunctionExpression */:
         break;
+      // Computed properties in classes are not handled here because references to this are illegal,
+      // so there is no point finding references to them.
       default:
         return void 0;
     }
@@ -171111,6 +171488,7 @@ function getDefinitionAtPosition(program, sourceFile, position, searchOtherFiles
       if (!isDefaultClause(node.parent)) {
         break;
       }
+    // falls through
     case 84 /* CaseKeyword */:
       const switchStatement = findAncestor(node.parent, isSwitchStatement);
       if (switchStatement) {
@@ -171555,6 +171933,8 @@ function isDefinitionVisible(checker, declaration) {
     case 178 /* SetAccessor */:
     case 174 /* MethodDeclaration */:
       if (hasEffectiveModifier(declaration, 2 /* Private */)) return false;
+    // Public properties/methods are visible if its parents are visible, so:
+    // falls through
     case 176 /* Constructor */:
     case 303 /* PropertyAssignment */:
     case 304 /* ShorthandPropertyAssignment */:
@@ -172531,6 +172911,7 @@ function getCommentHavingNodes(declaration) {
       if (isJSDocOverloadTag(declaration.parent)) {
         return [declaration.parent.parent];
       }
+    // falls through
     default:
       return getJSDocCommentsAndTags(declaration);
   }
@@ -173868,6 +174249,7 @@ function getOutliningSpanForNode(n, sourceFile) {
             const node = findChildOfKind(tryStatement, 98 /* FinallyKeyword */, sourceFile);
             if (node) return spanForNode(node);
           }
+        // falls through
         default:
           return createOutliningSpan(createTextSpanFromNode(n, sourceFile), "code" /* Code */);
       }
@@ -177693,19 +178075,34 @@ function isBinaryOpContext(context) {
     case 193 /* IntersectionType */:
     case 238 /* SatisfiesExpression */:
       return true;
+    // equals in binding elements: function foo([[x, y] = [1, 2]])
     case 208 /* BindingElement */:
+    // equals in type X = ...
+    // falls through
     case 265 /* TypeAliasDeclaration */:
+    // equal in import a = module('a');
+    // falls through
     case 271 /* ImportEqualsDeclaration */:
+    // equal in export = 1
+    // falls through
     case 277 /* ExportAssignment */:
+    // equal in let a = 0
+    // falls through
     case 260 /* VariableDeclaration */:
+    // equal in p = 0
+    // falls through
     case 169 /* Parameter */:
     case 306 /* EnumMember */:
     case 172 /* PropertyDeclaration */:
     case 171 /* PropertySignature */:
       return context.currentTokenSpan.kind === 64 /* EqualsToken */ || context.nextTokenSpan.kind === 64 /* EqualsToken */;
+    // "in" keyword in for (let x in []) { }
     case 249 /* ForInStatement */:
+    // "in" keyword in [P in keyof T]: T[P]
+    // falls through
     case 168 /* TypeParameter */:
       return context.currentTokenSpan.kind === 103 /* InKeyword */ || context.nextTokenSpan.kind === 103 /* InKeyword */ || context.currentTokenSpan.kind === 64 /* EqualsToken */ || context.nextTokenSpan.kind === 64 /* EqualsToken */;
+    // Technically, "of" is not a binary operator, but format it the same way as "in"
     case 250 /* ForOfStatement */:
       return context.currentTokenSpan.kind === 165 /* OfKeyword */ || context.nextTokenSpan.kind === 165 /* OfKeyword */;
   }
@@ -177769,12 +178166,20 @@ function isFunctionDeclContext(context) {
     case 262 /* FunctionDeclaration */:
     case 174 /* MethodDeclaration */:
     case 173 /* MethodSignature */:
+    // case SyntaxKind.MemberFunctionDeclaration:
+    // falls through
     case 177 /* GetAccessor */:
     case 178 /* SetAccessor */:
+    // case SyntaxKind.MethodSignature:
+    // falls through
     case 179 /* CallSignature */:
     case 218 /* FunctionExpression */:
     case 176 /* Constructor */:
     case 219 /* ArrowFunction */:
+    // case SyntaxKind.ConstructorDeclaration:
+    // case SyntaxKind.SimpleArrowFunctionExpression:
+    // case SyntaxKind.ParenthesizedArrowFunctionExpression:
+    // falls through
     case 264 /* InterfaceDeclaration */:
       return true;
   }
@@ -177834,6 +178239,9 @@ function isControlDeclContext(context) {
     case 258 /* TryStatement */:
     case 246 /* DoStatement */:
     case 254 /* WithStatement */:
+    // TODO
+    // case SyntaxKind.ElseClause:
+    // falls through
     case 299 /* CatchClause */:
       return true;
     default:
@@ -178462,6 +178870,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
         if (node.asteriskToken) {
           return 42 /* AsteriskToken */;
         }
+      // falls through
       case 172 /* PropertyDeclaration */:
       case 169 /* Parameter */:
         const name = getNameOfDeclaration(node);
@@ -178474,6 +178883,10 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
     return {
       getIndentationForComment: (kind, tokenIndentation, container) => {
         switch (kind) {
+          // preceding comment to the token that closes the indentation scope inherits the indentation from the scope
+          // ..  {
+          //     // comment
+          // }
           case 20 /* CloseBraceToken */:
           case 24 /* CloseBracketToken */:
           case 22 /* CloseParenToken */:
@@ -178503,6 +178916,7 @@ function formatSpanWorker(originalRange, enclosingNode, initialIndentation, delt
     };
     function shouldAddDelta(line, kind, container) {
       switch (kind) {
+        // open and close brace, 'else' and 'while' (in do statement) tokens has indentation of the parent
         case 19 /* OpenBraceToken */:
         case 20 /* CloseBraceToken */:
         case 22 /* CloseParenToken */:
@@ -189416,9 +189830,11 @@ Dynamic files must always be opened with service's current directory or service
     const result = [];
     const processDirectory = (directory) => {
       switch (packageJsonCache.directoryHasPackageJson(directory)) {
+        // Sync and check same directory again
         case 3 /* Maybe */:
           packageJsonCache.searchDirectoryAndAncestors(directory);
           return processDirectory(directory);
+        // Check package.json
         case -1 /* True */:
           const packageJsonFileName = combinePaths(directory, "package.json");
           this.watchPackageJsonFile(packageJsonFileName, this.toPath(packageJsonFileName), project);