typescript 5.4.0-dev.20240111 → 5.4.0-dev.20240113

package/lib/typescript.js

@@ -35,7 +35,7 @@ var ts = (() => {
     "src/compiler/corePublic.ts"() {
       "use strict";
       versionMajorMinor = "5.4";
-      version = `${versionMajorMinor}.0-dev.20240111`;
+      version = `${versionMajorMinor}.0-dev.20240113`;
       Comparison = /* @__PURE__ */ ((Comparison3) => {
         Comparison3[Comparison3["LessThan"] = -1] = "LessThan";
         Comparison3[Comparison3["EqualTo"] = 0] = "EqualTo";
@@ -6206,6 +6206,7 @@ ${lanes.join("\n")}
             resolvePath: (path) => _path.resolve(path),
             fileExists,
             directoryExists,
+            getAccessibleFileSystemEntries,
             createDirectory(directoryName) {
               if (!nodeSystem.directoryExists(directoryName)) {
                 try {
@@ -12907,6 +12908,45 @@ ${lanes.join("\n")}
     const type = isJSDocParameterTag(node) ? node.typeExpression && node.typeExpression.type : node.type;
     return node.dotDotDotToken !== void 0 || !!type && type.kind === 325 /* JSDocVariadicType */;
   }
+  function hasInternalAnnotation(range, sourceFile) {
+    const comment = sourceFile.text.substring(range.pos, range.end);
+    return comment.includes("@internal");
+  }
+  function isInternalDeclaration(node, sourceFile) {
+    sourceFile ?? (sourceFile = getSourceFileOfNode(node));
+    const parseTreeNode = getParseTreeNode(node);
+    if (parseTreeNode && parseTreeNode.kind === 169 /* Parameter */) {
+      const paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode);
+      const previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : void 0;
+      const text = sourceFile.text;
+      const commentRanges = previousSibling ? concatenate(
+        // to handle
+        // ... parameters, /** @internal */
+        // public param: string
+        getTrailingCommentRanges(text, skipTrivia(
+          text,
+          previousSibling.end + 1,
+          /*stopAfterLineBreak*/
+          false,
+          /*stopAtComments*/
+          true
+        )),
+        getLeadingCommentRanges(text, node.pos)
+      ) : getTrailingCommentRanges(text, skipTrivia(
+        text,
+        node.pos,
+        /*stopAfterLineBreak*/
+        false,
+        /*stopAtComments*/
+        true
+      ));
+      return some(commentRanges) && hasInternalAnnotation(last(commentRanges), sourceFile);
+    }
+    const leadingCommentRanges = parseTreeNode && getLeadingCommentRangesOfNode(parseTreeNode, sourceFile);
+    return !!forEach(leadingCommentRanges, (range) => {
+      return hasInternalAnnotation(range, sourceFile);
+    });
+  }
   var unchangedTextChangeRange, supportedLocaleDirectories, MAX_SMI_X86;
   var init_utilitiesPublic = __esm({
     "src/compiler/utilitiesPublic.ts"() {
@@ -38002,7 +38042,7 @@ ${lanes.join("\n")}
         ["es2023.array", "lib.es2023.array.d.ts"],
         ["es2023.collection", "lib.es2023.collection.d.ts"],
         ["esnext.array", "lib.es2023.array.d.ts"],
-        ["esnext.collection", "lib.es2023.collection.d.ts"],
+        ["esnext.collection", "lib.esnext.collection.d.ts"],
         ["esnext.symbol", "lib.es2019.symbol.d.ts"],
         ["esnext.asynciterable", "lib.es2018.asynciterable.d.ts"],
         ["esnext.intl", "lib.esnext.intl.d.ts"],
@@ -38012,6 +38052,7 @@ ${lanes.join("\n")}
         ["esnext.promise", "lib.esnext.promise.d.ts"],
         ["esnext.weakref", "lib.es2021.weakref.d.ts"],
         ["esnext.decorators", "lib.esnext.decorators.d.ts"],
+        ["esnext.object", "lib.esnext.object.d.ts"],
         ["decorators", "lib.decorators.d.ts"],
         ["decorators.legacy", "lib.decorators.legacy.d.ts"]
       ];
@@ -47100,7 +47141,12 @@ ${lanes.join("\n")}
     }
     function markAsSynthetic(node) {
       setTextRangePosEnd(node, -1, -1);
-      return visitEachChild(node, markAsSynthetic, nullTransformationContext);
+      return visitEachChild(
+        node,
+        markAsSynthetic,
+        /*context*/
+        void 0
+      );
     }
     function getEmitResolver(sourceFile, cancellationToken2) {
       getDiagnostics2(sourceFile, cancellationToken2);
@@ -50376,16 +50422,12 @@ ${lanes.join("\n")}
     }
     function hasVisibleDeclarations(symbol, shouldComputeAliasToMakeVisible) {
       let aliasesToMakeVisible;
-      let bindingElementToMakeVisible;
       if (!every(filter(symbol.declarations, (d) => d.kind !== 80 /* Identifier */), getIsDeclarationVisible)) {
         return void 0;
       }
-      return { accessibility: 0 /* Accessible */, aliasesToMakeVisible, bindingElementToMakeVisible };
+      return { accessibility: 0 /* Accessible */, aliasesToMakeVisible };
       function getIsDeclarationVisible(declaration) {
         var _a, _b;
-        if (isBindingElement(declaration) && findAncestor(declaration, isParameter)) {
-          bindingElementToMakeVisible = declaration;
-        }
         if (!isDeclarationVisible(declaration)) {
           const anyImportSyntax = getAnyImportSyntax(declaration);
           if (anyImportSyntax && !hasSyntacticModifier(anyImportSyntax, 32 /* Export */) && // import clause without export
@@ -50896,7 +50938,13 @@ ${lanes.join("\n")}
           return visitAndTransformType(type, (type2) => conditionalTypeToTypeNode(type2));
         }
         if (type.flags & 33554432 /* Substitution */) {
-          return typeToTypeNodeHelper(type.baseType, context);
+          const typeNode = typeToTypeNodeHelper(type.baseType, context);
+          const noInferSymbol = isNoInferType(type) && getGlobalTypeSymbol(
+            "NoInfer",
+            /*reportErrors*/
+            false
+          );
+          return noInferSymbol ? symbolToTypeNode(noInferSymbol, context, 788968 /* Type */, [typeNode]) : typeNode;
         }
         return Debug.fail("Should be unreachable.");
         function conditionalTypeToTypeNode(type2) {
@@ -51142,7 +51190,13 @@ ${lanes.join("\n")}
             if (!nodeIsSynthesized(node) && getParseTreeNode(node) === node) {
               return node;
             }
-            return setTextRange(factory.cloneNode(visitEachChild(node, deepCloneOrReuseNode, nullTransformationContext, deepCloneOrReuseNodes)), node);
+            return setTextRange(factory.cloneNode(visitEachChild(
+              node,
+              deepCloneOrReuseNode,
+              /*context*/
+              void 0,
+              deepCloneOrReuseNodes
+            )), node);
           }
           function deepCloneOrReuseNodes(nodes, visitor, test, start, count) {
             if (nodes && nodes.length === 0) {
@@ -51864,7 +51918,8 @@ ${lanes.join("\n")}
             let visited = visitEachChild(
               node2,
               elideInitializerAndSetEmitFlags,
-              nullTransformationContext,
+              /*context*/
+              void 0,
               /*nodesVisitor*/
               void 0,
               elideInitializerAndSetEmitFlags
@@ -52642,7 +52697,12 @@ ${lanes.join("\n")}
           if (file && isTupleTypeNode(node) && getLineAndCharacterOfPosition(file, node.pos).line === getLineAndCharacterOfPosition(file, node.end).line) {
             setEmitFlags(node, 1 /* SingleLine */);
           }
-          return visitEachChild(node, visitExistingNodeTreeSymbols, nullTransformationContext);
+          return visitEachChild(
+            node,
+            visitExistingNodeTreeSymbols,
+            /*context*/
+            void 0
+          );
           function getEffectiveDotDotDotForParameter(p) {
             return p.dotDotDotToken || (p.type && isJSDocVariadicType(p.type) ? factory.createToken(26 /* DotDotDotToken */) : void 0);
           }
@@ -52742,7 +52802,7 @@ ${lanes.join("\n")}
         });
         let addingDeclare = !bundled;
         const exportEquals = symbolTable.get("export=" /* ExportEquals */);
-        if (exportEquals && symbolTable.size > 1 && exportEquals.flags & 2097152 /* Alias */) {
+        if (exportEquals && symbolTable.size > 1 && exportEquals.flags & (2097152 /* Alias */ | 1536 /* Module */)) {
           symbolTable = createSymbolTable();
           symbolTable.set("export=" /* ExportEquals */, exportEquals);
         }
@@ -53199,8 +53259,18 @@ ${lanes.join("\n")}
           );
         }
         function getNamespaceMembersForSerialization(symbol) {
-          const exports = getExportsOfSymbol(symbol);
-          return !exports ? [] : filter(arrayFrom(exports.values()), (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
+          let exports = arrayFrom(getExportsOfSymbol(symbol).values());
+          const merged = getMergedSymbol(symbol);
+          if (merged !== symbol) {
+            const membersSet = new Set(exports);
+            for (const exported of getExportsOfSymbol(merged).values()) {
+              if (!(getSymbolFlags(resolveSymbol(exported)) & 111551 /* Value */)) {
+                membersSet.add(exported);
+              }
+            }
+            exports = arrayFrom(membersSet);
+          }
+          return filter(exports, (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
         }
         function isTypeOnlyNamespace(symbol) {
           return every(getNamespaceMembersForSerialization(symbol), (m) => !(getSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
@@ -58844,8 +58914,11 @@ ${lanes.join("\n")}
     }
     function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
       const type = getDeclaredTypeOfSymbol(symbol);
-      if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
-        return getStringMappingType(symbol, typeArguments[0]);
+      if (type === intrinsicMarkerType) {
+        const typeKind = intrinsicTypeKinds.get(symbol.escapedName);
+        if (typeKind !== void 0 && typeArguments && typeArguments.length === 1) {
+          return typeKind === 4 /* NoInfer */ ? getNoInferType(typeArguments[0]) : getStringMappingType(symbol, typeArguments[0]);
+        }
       }
       const links = getSymbolLinks(symbol);
       const typeParameters = links.typeParameters;
@@ -58999,10 +59072,19 @@ ${lanes.join("\n")}
       }
       return links.resolvedJSDocType;
     }
+    function getNoInferType(type) {
+      return isNoInferTargetType(type) ? getOrCreateSubstitutionType(type, unknownType) : type;
+    }
+    function isNoInferTargetType(type) {
+      return !!(type.flags & 3145728 /* UnionOrIntersection */ && some(type.types, isNoInferTargetType) || type.flags & 33554432 /* Substitution */ && !isNoInferType(type) && isNoInferTargetType(type.baseType) || type.flags & 524288 /* Object */ && !isEmptyAnonymousObjectType(type) || type.flags & (465829888 /* Instantiable */ & ~33554432 /* Substitution */) && !isPatternLiteralType(type));
+    }
+    function isNoInferType(type) {
+      return !!(type.flags & 33554432 /* Substitution */ && type.constraint.flags & 2 /* Unknown */);
+    }
     function getSubstitutionType(baseType, constraint) {
-      if (constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */) {
-        return baseType;
-      }
+      return constraint.flags & 3 /* AnyOrUnknown */ || constraint === baseType || baseType.flags & 1 /* Any */ ? baseType : getOrCreateSubstitutionType(baseType, constraint);
+    }
+    function getOrCreateSubstitutionType(baseType, constraint) {
       const id = `${getTypeId(baseType)}>${getTypeId(constraint)}`;
       const cached = substitutionTypes.get(id);
       if (cached) {
@@ -59015,7 +59097,7 @@ ${lanes.join("\n")}
       return result;
     }
     function getSubstitutionIntersection(substitutionType) {
-      return getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
+      return isNoInferType(substitutionType) ? substitutionType.baseType : getIntersectionType([substitutionType.constraint, substitutionType.baseType]);
     }
     function isUnaryTupleTypeNode(node) {
       return node.kind === 189 /* TupleType */ && node.elements.length === 1;
@@ -60544,7 +60626,7 @@ ${lanes.join("\n")}
     }
     function getIndexType(type, indexFlags = defaultIndexFlags) {
       type = getReducedType(type);
-      return shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(type, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === defaultIndexFlags);
+      return isNoInferType(type) ? getNoInferType(getIndexType(type.baseType, indexFlags)) : shouldDeferIndexType(type, indexFlags) ? getIndexTypeForGenericType(type, indexFlags) : type.flags & 1048576 /* Union */ ? getIntersectionType(map(type.types, (t) => getIndexType(t, indexFlags))) : type.flags & 2097152 /* Intersection */ ? getUnionType(map(type.types, (t) => getIndexType(t, indexFlags))) : getObjectFlags(type) & 32 /* Mapped */ ? getIndexTypeForMappedType(type, indexFlags) : type === wildcardType ? wildcardType : type.flags & 2 /* Unknown */ ? neverType : type.flags & (1 /* Any */ | 131072 /* Never */) ? keyofConstraintType : getLiteralTypeFromProperties(type, (indexFlags & 2 /* NoIndexSignatures */ ? 128 /* StringLiteral */ : 402653316 /* StringLike */) | (indexFlags & 1 /* StringsOnly */ ? 0 : 296 /* NumberLike */ | 12288 /* ESSymbolLike */), indexFlags === defaultIndexFlags);
     }
     function getExtractStringType(type) {
       if (keyofStringsOnly) {
@@ -62287,6 +62369,9 @@ ${lanes.join("\n")}
       }
       if (flags & 33554432 /* Substitution */) {
         const newBaseType = instantiateType(type.baseType, mapper);
+        if (isNoInferType(type)) {
+          return getNoInferType(newBaseType);
+        }
         const newConstraint = instantiateType(type.constraint, mapper);
         if (newBaseType.flags & 8650752 /* TypeVariable */ && isGenericType(newConstraint)) {
           return getSubstitutionType(newBaseType, newConstraint);
@@ -67079,7 +67164,7 @@ ${lanes.join("\n")}
       let expandingFlags = 0 /* None */;
       inferFromTypes(originalSource, originalTarget);
       function inferFromTypes(source, target) {
-        if (!couldContainTypeVariables(target)) {
+        if (!couldContainTypeVariables(target) || isNoInferType(target)) {
           return;
         }
         if (source === wildcardType || source === blockedStringType) {
@@ -67128,6 +67213,9 @@ ${lanes.join("\n")}
           }
         }
         if (target.flags & (8388608 /* IndexedAccess */ | 33554432 /* Substitution */)) {
+          if (isNoInferType(target)) {
+            return;
+          }
           target = getActualTypeVariable(target);
         }
         if (target.flags & 8650752 /* TypeVariable */) {
@@ -87903,7 +87991,8 @@ ${lanes.join("\n")}
         Uppercase: 0 /* Uppercase */,
         Lowercase: 1 /* Lowercase */,
         Capitalize: 2 /* Capitalize */,
-        Uncapitalize: 3 /* Uncapitalize */
+        Uncapitalize: 3 /* Uncapitalize */,
+        NoInfer: 4 /* NoInfer */
       }));
       SymbolLinks = class {
       };
@@ -88272,7 +88361,7 @@ ${lanes.join("\n")}
       return discarded ? discardVisitor(node) : visitor(node);
     }, isExpression);
   }
-  function visitEachChild(node, visitor, context, nodesVisitor = visitNodes2, tokenVisitor, nodeVisitor = visitNode) {
+  function visitEachChild(node, visitor, context = nullTransformationContext, nodesVisitor = visitNodes2, tokenVisitor, nodeVisitor = visitNode) {
     if (node === void 0) {
       return void 0;
     }
@@ -102874,12 +102963,22 @@ ${lanes.join("\n")}
         case 172 /* PropertyDeclaration */: {
           const named = node;
           if (isComputedPropertyName(named.name)) {
-            return factory2.replacePropertyName(named, visitEachChild(named.name, elideUnusedThisCaptureWorker, nullTransformationContext));
+            return factory2.replacePropertyName(named, visitEachChild(
+              named.name,
+              elideUnusedThisCaptureWorker,
+              /*context*/
+              void 0
+            ));
           }
           return node;
         }
       }
-      return visitEachChild(node, elideUnusedThisCaptureWorker, nullTransformationContext);
+      return visitEachChild(
+        node,
+        elideUnusedThisCaptureWorker,
+        /*context*/
+        void 0
+      );
     }
     function simplifyConstructorElideUnusedThisCapture(body, original) {
       if (original.transformFlags & 16384 /* ContainsLexicalThis */ || hierarchyFacts & 65536 /* LexicalThis */ || hierarchyFacts & 131072 /* CapturedLexicalThis */) {
@@ -102915,12 +103014,22 @@ ${lanes.join("\n")}
         case 172 /* PropertyDeclaration */: {
           const named = node;
           if (isComputedPropertyName(named.name)) {
-            return factory2.replacePropertyName(named, visitEachChild(named.name, injectSuperPresenceCheckWorker, nullTransformationContext));
+            return factory2.replacePropertyName(named, visitEachChild(
+              named.name,
+              injectSuperPresenceCheckWorker,
+              /*context*/
+              void 0
+            ));
           }
           return node;
         }
       }
-      return visitEachChild(node, injectSuperPresenceCheckWorker, nullTransformationContext);
+      return visitEachChild(
+        node,
+        injectSuperPresenceCheckWorker,
+        /*context*/
+        void 0
+      );
     }
     function complicateConstructorInjectSuperPresenceCheck(body) {
       return factory2.updateBlock(body, visitNodes2(body.statements, injectSuperPresenceCheckWorker, isStatement));
@@ -111367,44 +111476,6 @@ ${lanes.join("\n")}
     );
     return result.diagnostics;
   }
-  function hasInternalAnnotation(range, currentSourceFile) {
-    const comment = currentSourceFile.text.substring(range.pos, range.end);
-    return comment.includes("@internal");
-  }
-  function isInternalDeclaration(node, currentSourceFile) {
-    const parseTreeNode = getParseTreeNode(node);
-    if (parseTreeNode && parseTreeNode.kind === 169 /* Parameter */) {
-      const paramIdx = parseTreeNode.parent.parameters.indexOf(parseTreeNode);
-      const previousSibling = paramIdx > 0 ? parseTreeNode.parent.parameters[paramIdx - 1] : void 0;
-      const text = currentSourceFile.text;
-      const commentRanges = previousSibling ? concatenate(
-        // to handle
-        // ... parameters, /** @internal */
-        // public param: string
-        getTrailingCommentRanges(text, skipTrivia(
-          text,
-          previousSibling.end + 1,
-          /*stopAfterLineBreak*/
-          false,
-          /*stopAtComments*/
-          true
-        )),
-        getLeadingCommentRanges(text, node.pos)
-      ) : getTrailingCommentRanges(text, skipTrivia(
-        text,
-        node.pos,
-        /*stopAfterLineBreak*/
-        false,
-        /*stopAtComments*/
-        true
-      ));
-      return commentRanges && commentRanges.length && hasInternalAnnotation(last(commentRanges), currentSourceFile);
-    }
-    const leadingCommentRanges = parseTreeNode && getLeadingCommentRangesOfNode(parseTreeNode, currentSourceFile);
-    return !!forEach(leadingCommentRanges, (range) => {
-      return hasInternalAnnotation(range, currentSourceFile);
-    });
-  }
   function transformDeclarations(context) {
     const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
     let getSymbolAccessibilityDiagnostic = throwDiagnostic;
@@ -111419,7 +111490,6 @@ ${lanes.join("\n")}
     let lateStatementReplacementMap;
     let suppressNewDiagnosticContexts;
     let exportedModulesFromDeclarationEmit;
-    const usedBindingElementAliases = /* @__PURE__ */ new Map();
     const { factory: factory2 } = context;
     const host = context.getEmitHost();
     const symbolTracker = {
@@ -111485,17 +111555,6 @@ ${lanes.join("\n")}
             }
           }
         }
-        if (symbolAccessibilityResult.bindingElementToMakeVisible) {
-          const bindingElement = symbolAccessibilityResult.bindingElementToMakeVisible;
-          const parameter = findAncestor(bindingElement, isParameter);
-          Debug.assert(parameter !== void 0);
-          const parent2 = getOriginalNode(parameter.parent);
-          let aliases = usedBindingElementAliases.get(parent2);
-          if (!aliases) {
-            usedBindingElementAliases.set(parent2, aliases = /* @__PURE__ */ new Map());
-          }
-          aliases.set(getOriginalNode(bindingElement), bindingElement.name);
-        }
       } else {
         const errorInfo = getSymbolAccessibilityDiagnostic(symbolAccessibilityResult);
         if (errorInfo) {
@@ -111828,7 +111887,7 @@ ${lanes.join("\n")}
       });
       return ret;
     }
-    function filterBindingPatternInitializersAndRenamings(name) {
+    function filterBindingPatternInitializers(name) {
       if (name.kind === 80 /* Identifier */) {
         return name;
       } else {
@@ -111845,180 +111904,15 @@ ${lanes.join("\n")}
         if (elem.propertyName && isComputedPropertyName(elem.propertyName) && isEntityNameExpression(elem.propertyName.expression)) {
           checkEntityNameVisibility(elem.propertyName.expression, enclosingDeclaration);
         }
-        if (elem.propertyName && isIdentifier(elem.propertyName) && isIdentifier(elem.name) && !isIdentifierANonContextualKeyword(elem.propertyName)) {
-          return factory2.updateBindingElement(
-            elem,
-            elem.dotDotDotToken,
-            /*propertyName*/
-            void 0,
-            elem.propertyName,
-            shouldPrintWithInitializer(elem) ? elem.initializer : void 0
-          );
-        }
         return factory2.updateBindingElement(
           elem,
           elem.dotDotDotToken,
           elem.propertyName,
-          filterBindingPatternInitializersAndRenamings(elem.name),
+          filterBindingPatternInitializers(elem.name),
           shouldPrintWithInitializer(elem) ? elem.initializer : void 0
         );
       }
     }
-    function ensureBindingAliasesInParameterList(input, updatedNode) {
-      const original = getOriginalNode(input);
-      const params = updatedNode.parameters;
-      const aliases = usedBindingElementAliases.get(original);
-      if (!aliases) {
-        return updatedNode;
-      }
-      usedBindingElementAliases.delete(original);
-      const newParams = map(params, addUsedBindingPatternsToParameter);
-      const newParamsNodeArray = factory2.createNodeArray(newParams, params.hasTrailingComma);
-      switch (updatedNode.kind) {
-        case 174 /* MethodDeclaration */:
-          return factory2.updateMethodDeclaration(
-            updatedNode,
-            updatedNode.modifiers,
-            updatedNode.asteriskToken,
-            updatedNode.name,
-            updatedNode.questionToken,
-            updatedNode.typeParameters,
-            newParamsNodeArray,
-            updatedNode.type,
-            updatedNode.body
-          );
-        case 176 /* Constructor */:
-          return factory2.updateConstructorDeclaration(
-            updatedNode,
-            updatedNode.modifiers,
-            newParamsNodeArray,
-            updatedNode.body
-          );
-        case 177 /* GetAccessor */:
-          return factory2.updateGetAccessorDeclaration(
-            updatedNode,
-            updatedNode.modifiers,
-            updatedNode.name,
-            newParamsNodeArray,
-            updatedNode.type,
-            updatedNode.body
-          );
-        case 178 /* SetAccessor */:
-          return factory2.updateSetAccessorDeclaration(
-            updatedNode,
-            updatedNode.modifiers,
-            updatedNode.name,
-            newParamsNodeArray,
-            updatedNode.body
-          );
-        case 219 /* ArrowFunction */:
-          return factory2.updateArrowFunction(
-            updatedNode,
-            updatedNode.modifiers,
-            updatedNode.typeParameters,
-            newParamsNodeArray,
-            updatedNode.type,
-            updatedNode.equalsGreaterThanToken,
-            updatedNode.body
-          );
-        case 262 /* FunctionDeclaration */:
-          return factory2.updateFunctionDeclaration(
-            updatedNode,
-            updatedNode.modifiers,
-            updatedNode.asteriskToken,
-            updatedNode.name,
-            updatedNode.typeParameters,
-            newParamsNodeArray,
-            updatedNode.type,
-            updatedNode.body
-          );
-        case 179 /* CallSignature */:
-          return factory2.updateCallSignature(
-            updatedNode,
-            updatedNode.typeParameters,
-            newParamsNodeArray,
-            updatedNode.type
-          );
-        case 173 /* MethodSignature */:
-          return factory2.updateMethodSignature(
-            updatedNode,
-            updatedNode.modifiers,
-            updatedNode.name,
-            updatedNode.questionToken,
-            updatedNode.typeParameters,
-            newParamsNodeArray,
-            updatedNode.type
-          );
-        case 180 /* ConstructSignature */:
-          return factory2.updateConstructSignature(
-            updatedNode,
-            updatedNode.typeParameters,
-            newParamsNodeArray,
-            updatedNode.type
-          );
-        case 184 /* FunctionType */:
-          return factory2.updateFunctionTypeNode(
-            updatedNode,
-            updatedNode.typeParameters,
-            newParamsNodeArray,
-            updatedNode.type
-          );
-        case 185 /* ConstructorType */:
-          return factory2.updateConstructorTypeNode(
-            updatedNode,
-            updatedNode.modifiers,
-            updatedNode.typeParameters,
-            newParamsNodeArray,
-            updatedNode.type
-          );
-        default:
-          Debug.assertNever(updatedNode);
-      }
-      function addUsedBindingPatternsToParameter(p) {
-        return factory2.updateParameterDeclaration(
-          p,
-          p.modifiers,
-          p.dotDotDotToken,
-          addUsedBindingPatternAliases(p.name),
-          p.questionToken,
-          p.type,
-          p.initializer
-        );
-      }
-      function addUsedBindingPatternAliases(name) {
-        if (name.kind === 80 /* Identifier */) {
-          return name;
-        } else {
-          if (name.kind === 207 /* ArrayBindingPattern */) {
-            return factory2.updateArrayBindingPattern(name, visitNodes2(name.elements, visitBindingElement, isArrayBindingElement));
-          } else {
-            return factory2.updateObjectBindingPattern(name, visitNodes2(name.elements, visitBindingElement, isBindingElement));
-          }
-        }
-        function visitBindingElement(elem) {
-          if (elem.kind === 232 /* OmittedExpression */) {
-            return elem;
-          }
-          const usedAlias = aliases.get(getOriginalNode(elem));
-          if (usedAlias && !elem.propertyName) {
-            return factory2.updateBindingElement(
-              elem,
-              elem.dotDotDotToken,
-              elem.name,
-              usedAlias,
-              elem.initializer
-            );
-          }
-          return factory2.updateBindingElement(
-            elem,
-            elem.dotDotDotToken,
-            elem.propertyName,
-            addUsedBindingPatternAliases(elem.name),
-            elem.initializer
-          );
-        }
-      }
-    }
     function ensureParameter(p, modifierMask, type) {
       let oldDiag;
       if (!suppressNewDiagnosticContexts) {
@@ -112029,7 +111923,7 @@ ${lanes.join("\n")}
         p,
         maskModifiers(factory2, p, modifierMask),
         p.dotDotDotToken,
-        filterBindingPatternInitializersAndRenamings(p.name),
+        filterBindingPatternInitializers(p.name),
         resolver.isOptionalParameter(p) ? p.questionToken || factory2.createToken(58 /* QuestionToken */) : void 0,
         ensureType(
           p,
@@ -112405,25 +112299,19 @@ ${lanes.join("\n")}
             return cleanup(factory2.updateTypeReferenceNode(node, node.typeName, node.typeArguments));
           }
           case 180 /* ConstructSignature */:
-            return cleanup(ensureBindingAliasesInParameterList(
+            return cleanup(factory2.updateConstructSignature(
               input,
-              factory2.updateConstructSignature(
-                input,
-                ensureTypeParams(input, input.typeParameters),
-                updateParamsList(input, input.parameters),
-                ensureType(input, input.type)
-              )
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type)
             ));
           case 176 /* Constructor */: {
-            const ctor = ensureBindingAliasesInParameterList(
-              input,
-              factory2.createConstructorDeclaration(
-                /*modifiers*/
-                ensureModifiers(input),
-                updateParamsList(input, input.parameters, 0 /* None */),
-                /*body*/
-                void 0
-              )
+            const ctor = factory2.createConstructorDeclaration(
+              /*modifiers*/
+              ensureModifiers(input),
+              updateParamsList(input, input.parameters, 0 /* None */),
+              /*body*/
+              void 0
             );
             return cleanup(ctor);
           }
@@ -112434,20 +112322,17 @@ ${lanes.join("\n")}
                 void 0
               );
             }
-            const sig = ensureBindingAliasesInParameterList(
-              input,
-              factory2.createMethodDeclaration(
-                ensureModifiers(input),
-                /*asteriskToken*/
-                void 0,
-                input.name,
-                input.questionToken,
-                ensureTypeParams(input, input.typeParameters),
-                updateParamsList(input, input.parameters),
-                ensureType(input, input.type),
-                /*body*/
-                void 0
-              )
+            const sig = factory2.createMethodDeclaration(
+              ensureModifiers(input),
+              /*asteriskToken*/
+              void 0,
+              input.name,
+              input.questionToken,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type),
+              /*body*/
+              void 0
             );
             return cleanup(sig);
           }
@@ -112459,17 +112344,14 @@ ${lanes.join("\n")}
               );
             }
             const accessorType = getTypeAnnotationFromAllAccessorDeclarations(input, resolver.getAllAccessorDeclarations(input));
-            return cleanup(ensureBindingAliasesInParameterList(
+            return cleanup(factory2.updateGetAccessorDeclaration(
               input,
-              factory2.updateGetAccessorDeclaration(
-                input,
-                ensureModifiers(input),
-                input.name,
-                updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-                ensureType(input, accessorType),
-                /*body*/
-                void 0
-              )
+              ensureModifiers(input),
+              input.name,
+              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
+              ensureType(input, accessorType),
+              /*body*/
+              void 0
             ));
           }
           case 178 /* SetAccessor */: {
@@ -112479,16 +112361,13 @@ ${lanes.join("\n")}
                 void 0
               );
             }
-            return cleanup(ensureBindingAliasesInParameterList(
+            return cleanup(factory2.updateSetAccessorDeclaration(
               input,
-              factory2.updateSetAccessorDeclaration(
-                input,
-                ensureModifiers(input),
-                input.name,
-                updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
-                /*body*/
-                void 0
-              )
+              ensureModifiers(input),
+              input.name,
+              updateAccessorParamsList(input, hasEffectiveModifier(input, 2 /* Private */)),
+              /*body*/
+              void 0
             ));
           }
           case 172 /* PropertyDeclaration */:
@@ -112527,29 +112406,25 @@ ${lanes.join("\n")}
                 void 0
               );
             }
-            return cleanup(ensureBindingAliasesInParameterList(
+            return cleanup(factory2.updateMethodSignature(
               input,
-              factory2.updateMethodSignature(
-                input,
-                ensureModifiers(input),
-                input.name,
-                input.questionToken,
-                ensureTypeParams(input, input.typeParameters),
-                updateParamsList(input, input.parameters),
-                ensureType(input, input.type)
-              )
+              ensureModifiers(input),
+              input.name,
+              input.questionToken,
+              ensureTypeParams(input, input.typeParameters),
+              updateParamsList(input, input.parameters),
+              ensureType(input, input.type)
             ));
           }
           case 179 /* CallSignature */: {
-            return cleanup(ensureBindingAliasesInParameterList(
-              input,
+            return cleanup(
               factory2.updateCallSignature(
                 input,
                 ensureTypeParams(input, input.typeParameters),
                 updateParamsList(input, input.parameters),
                 ensureType(input, input.type)
               )
-            ));
+            );
           }
           case 181 /* IndexSignature */: {
             return cleanup(factory2.updateIndexSignature(
@@ -112603,26 +112478,20 @@ ${lanes.join("\n")}
             return cleanup(factory2.updateConditionalTypeNode(input, checkType, extendsType, trueType, falseType));
           }
           case 184 /* FunctionType */: {
-            return cleanup(ensureBindingAliasesInParameterList(
+            return cleanup(factory2.updateFunctionTypeNode(
               input,
-              factory2.updateFunctionTypeNode(
-                input,
-                visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
-                updateParamsList(input, input.parameters),
-                Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
-              )
+              visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+              updateParamsList(input, input.parameters),
+              Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
             ));
           }
           case 185 /* ConstructorType */: {
-            return cleanup(ensureBindingAliasesInParameterList(
+            return cleanup(factory2.updateConstructorTypeNode(
               input,
-              factory2.updateConstructorTypeNode(
-                input,
-                ensureModifiers(input),
-                visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
-                updateParamsList(input, input.parameters),
-                Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
-              )
+              ensureModifiers(input),
+              visitNodes2(input.typeParameters, visitDeclarationSubtree, isTypeParameterDeclaration),
+              updateParamsList(input, input.parameters),
+              Debug.checkDefined(visitNode(input.type, visitDeclarationSubtree, isTypeNode))
             ));
           }
           case 205 /* ImportType */: {
@@ -112808,20 +112677,17 @@ ${lanes.join("\n")}
           ));
         }
         case 262 /* FunctionDeclaration */: {
-          const clean2 = cleanup(ensureBindingAliasesInParameterList(
+          const clean2 = cleanup(factory2.updateFunctionDeclaration(
             input,
-            factory2.updateFunctionDeclaration(
-              input,
-              ensureModifiers(input),
-              /*asteriskToken*/
-              void 0,
-              input.name,
-              ensureTypeParams(input, input.typeParameters),
-              updateParamsList(input, input.parameters),
-              ensureType(input, input.type),
-              /*body*/
-              void 0
-            )
+            ensureModifiers(input),
+            /*asteriskToken*/
+            void 0,
+            input.name,
+            ensureTypeParams(input, input.typeParameters),
+            updateParamsList(input, input.parameters),
+            ensureType(input, input.type),
+            /*body*/
+            void 0
           ));
           if (clean2 && resolver.isExpandoFunctionDeclaration(input) && shouldEmitFunctionProperties(input)) {
             const props = resolver.getPropertiesOfContainerFunction(input);
@@ -132964,7 +132830,14 @@ ${lanes.join("\n")}
       true,
       replaceNode
     ) : (ns) => ns && getSynthesizedDeepClones(ns);
-    const visited = visitEachChild(node, nodeClone, nullTransformationContext, nodesClone, nodeClone);
+    const visited = visitEachChild(
+      node,
+      nodeClone,
+      /*context*/
+      void 0,
+      nodesClone,
+      nodeClone
+    );
     if (visited === node) {
       const clone2 = isStringLiteral(node) ? setOriginalNode(factory.createStringLiteralFromNode(node), node) : isNumericLiteral(node) ? setOriginalNode(factory.createNumericLiteral(node.text, node.numericLiteralFlags), node) : factory.cloneNode(node);
       return setTextRange(clone2, node);
@@ -142921,7 +142794,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const oldIgnoreReturns = ignoreReturns;
         ignoreReturns = ignoreReturns || isFunctionLikeDeclaration(node) || isClassLike(node);
         const substitution = substitutions.get(getNodeId(node).toString());
-        const result = substitution ? getSynthesizedDeepClone(substitution) : visitEachChild(node, visitor, nullTransformationContext);
+        const result = substitution ? getSynthesizedDeepClone(substitution) : visitEachChild(
+          node,
+          visitor,
+          /*context*/
+          void 0
+        );
         ignoreReturns = oldIgnoreReturns;
         return result;
       }
@@ -142931,7 +142809,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     return substitutions.size ? visitor(initializer) : initializer;
     function visitor(node) {
       const substitution = substitutions.get(getNodeId(node).toString());
-      return substitution ? getSynthesizedDeepClone(substitution) : visitEachChild(node, visitor, nullTransformationContext);
+      return substitution ? getSynthesizedDeepClone(substitution) : visitEachChild(
+        node,
+        visitor,
+        /*context*/
+        void 0
+      );
     }
   }
   function getStatementsOrClassElements(scope) {
@@ -147942,7 +147825,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       case 329 /* JSDocTypeLiteral */:
         return transformJSDocTypeLiteral(node);
       default:
-        const visited = visitEachChild(node, transformJSDocType, nullTransformationContext);
+        const visited = visitEachChild(
+          node,
+          transformJSDocType,
+          /*context*/
+          void 0
+        );
         setEmitFlags(visited, 1 /* SingleLine */);
         return visited;
     }
@@ -156433,7 +156321,12 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         const typeArguments = visitNodes2(node.typeArguments, visit, isTypeNode);
         return factory.createTypeReferenceNode(qualifier, typeArguments);
       }
-      return visitEachChild(node, visit, nullTransformationContext);
+      return visitEachChild(
+        node,
+        visit,
+        /*context*/
+        void 0
+      );
     }
   }
   function replaceFirstIdentifierOfEntityName(name, newIdentifier) {
@@ -163192,6 +163085,11 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         return isArrayLiteralOrObjectLiteralDestructuringPattern(node.parent) ? getContextNode(
           findAncestor(node.parent, (node2) => isBinaryExpression(node2) || isForInOrOfStatement(node2))
         ) : node;
+      case 255 /* SwitchStatement */:
+        return {
+          start: find(node.getChildren(node.getSourceFile()), (node2) => node2.kind === 109 /* SwitchKeyword */),
+          end: node.caseBlock
+        };
       default:
         return node;
     }
@@ -163486,6 +163384,9 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       start += 1;
       end -= 1;
     }
+    if ((endNode2 == null ? void 0 : endNode2.kind) === 269 /* CaseBlock */) {
+      end = endNode2.getFullStart();
+    }
     return createTextSpanFromBounds(start, end);
   }
   function getTextSpanOfEntry(entry) {
@@ -165096,9 +164997,20 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
         void 0
       )] : void 0;
     }
-    if (node.kind === 107 /* ReturnKeyword */) {
-      const functionDeclaration = findAncestor(node.parent, (n) => isClassStaticBlockDeclaration(n) ? "quit" : isFunctionLikeDeclaration(n));
-      return functionDeclaration ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : void 0;
+    switch (node.kind) {
+      case 107 /* ReturnKeyword */:
+        const functionDeclaration = findAncestor(node.parent, (n) => isClassStaticBlockDeclaration(n) ? "quit" : isFunctionLikeDeclaration(n));
+        return functionDeclaration ? [createDefinitionFromSignatureDeclaration(typeChecker, functionDeclaration)] : void 0;
+      case 90 /* DefaultKeyword */:
+        if (!isDefaultClause(node.parent)) {
+          break;
+        }
+      case 84 /* CaseKeyword */:
+        const switchStatement = findAncestor(node.parent, isSwitchStatement);
+        if (switchStatement) {
+          return [createDefinitionInfoFromSwitch(switchStatement, sourceFile)];
+        }
+        break;
     }
     if (node.kind === 135 /* AwaitKeyword */) {
       const functionDeclaration = findAncestor(node, (n) => isFunctionLikeDeclaration(n));
@@ -165495,6 +165407,23 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
       failedAliasResolution
     };
   }
+  function createDefinitionInfoFromSwitch(statement, sourceFile) {
+    const keyword = ts_FindAllReferences_exports.getContextNode(statement);
+    const textSpan = createTextSpanFromNode(isContextWithStartAndEndNode(keyword) ? keyword.start : keyword, sourceFile);
+    return {
+      fileName: sourceFile.fileName,
+      textSpan,
+      kind: "keyword" /* keyword */,
+      name: "switch",
+      containerKind: void 0,
+      containerName: "",
+      ...ts_FindAllReferences_exports.toContextSpan(textSpan, sourceFile, keyword),
+      isLocal: true,
+      isAmbient: false,
+      unverified: false,
+      failedAliasResolution: void 0
+    };
+  }
   function isDefinitionVisible(checker, declaration) {
     if (checker.isDeclarationVisible(declaration))
       return true;
@@ -165572,6 +165501,7 @@ ${newComment.split("\n").map((c) => ` * ${c}`).join("\n")}
     "src/services/goToDefinition.ts"() {
       "use strict";
       init_ts4();
+      init_ts_FindAllReferences();
       typesWithUnwrappedTypeArguments = /* @__PURE__ */ new Set([
         "Array",
         "ArrayLike",