typescript 5.4.0-dev.20240110 → 5.4.0-dev.20240112

package/lib/lib.esnext.collection.d.ts

@@ -0,0 +1,29 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/// <reference no-default-lib="true"/>
+
+interface MapConstructor {
+    /**
+     * Groups members of an iterable according to the return value of the passed callback.
+     * @param items An iterable.
+     * @param keySelector A callback which will be invoked for each item in items.
+     */
+    groupBy<K, T>(
+        items: Iterable<T>,
+        keySelector: (item: T, index: number) => K,
+    ): Map<K, T[]>;
+}

package/lib/lib.esnext.d.ts

@@ -21,3 +21,5 @@ and limitations under the License.
 /// <reference lib="esnext.decorators" />
 /// <reference lib="esnext.disposable" />
 /// <reference lib="esnext.promise" />
+/// <reference lib="esnext.object" />
+/// <reference lib="esnext.collection" />

package/lib/lib.esnext.object.d.ts

@@ -0,0 +1,29 @@
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+
+/// <reference no-default-lib="true"/>
+
+interface ObjectConstructor {
+    /**
+     * Groups members of an iterable according to the return value of the passed callback.
+     * @param items An iterable.
+     * @param keySelector A callback which will be invoked for each item in items.
+     */
+    groupBy<K extends PropertyKey, T>(
+        items: Iterable<T>,
+        keySelector: (item: T, index: number) => K,
+    ): Partial<Record<K, T[]>>;
+}

package/lib/tsc.js

@@ -18,7 +18,7 @@ and limitations under the License.
 
 // src/compiler/corePublic.ts
 var versionMajorMinor = "5.4";
-var version = `${versionMajorMinor}.0-dev.20240110`;
+var version = `${versionMajorMinor}.0-dev.20240112`;
 
 // src/compiler/core.ts
 var emptyArray = [];
@@ -4898,6 +4898,7 @@ var sys = (() => {
       resolvePath: (path) => _path.resolve(path),
       fileExists,
       directoryExists,
+      getAccessibleFileSystemEntries,
       createDirectory(directoryName) {
         if (!nodeSystem.directoryExists(directoryName)) {
           try {
@@ -11372,6 +11373,45 @@ function isRestParameter(node) {
   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);
+  });
+}
 
 // src/compiler/utilities.ts
 var resolvingEmptyArray = [];
@@ -17671,6 +17711,9 @@ var stringReplace = String.prototype.replace;
 function replaceFirstStar(s, replacement) {
   return stringReplace.call(s, "*", replacement);
 }
+function getNameFromImportAttribute(node) {
+  return isIdentifier(node.name) ? node.name.escapedText : escapeLeadingUnderscores(node.name.text);
+}
 
 // src/compiler/factory/baseNodeFactory.ts
 function createBaseNodeFactory() {
@@ -34065,7 +34108,7 @@ var libEntries = [
   ["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"],
@@ -34075,6 +34118,7 @@ var libEntries = [
   ["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"]
 ];
@@ -44446,6 +44490,7 @@ function createTypeChecker(host) {
   var deferredGlobalImportMetaType;
   var deferredGlobalImportMetaExpressionType;
   var deferredGlobalImportCallOptionsType;
+  var deferredGlobalImportAttributesType;
   var deferredGlobalDisposableType;
   var deferredGlobalAsyncDisposableType;
   var deferredGlobalExtractSymbol;
@@ -44602,7 +44647,12 @@ function createTypeChecker(host) {
   }
   function markAsSynthetic(node) {
     setTextRangePosEnd(node, -1, -1);
-    return visitEachChild(node, markAsSynthetic, nullTransformationContext);
+    return visitEachChild(
+      node,
+      markAsSynthetic,
+      /*context*/
+      void 0
+    );
   }
   function getEmitResolver(sourceFile, cancellationToken2) {
     getDiagnostics(sourceFile, cancellationToken2);
@@ -48644,7 +48694,13 @@ function createTypeChecker(host) {
           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) {
@@ -49366,7 +49422,8 @@ function createTypeChecker(host) {
           let visited = visitEachChild(
             node2,
             elideInitializerAndSetEmitFlags,
-            nullTransformationContext,
+            /*context*/
+            void 0,
             /*nodesVisitor*/
             void 0,
             elideInitializerAndSetEmitFlags
@@ -50144,7 +50201,12 @@ function createTypeChecker(host) {
         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);
         }
@@ -50244,7 +50306,7 @@ function createTypeChecker(host) {
       });
       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);
       }
@@ -50701,8 +50763,18 @@ function createTypeChecker(host) {
         );
       }
       function getNamespaceMembersForSerialization(symbol) {
-        const exports2 = getExportsOfSymbol(symbol);
-        return !exports2 ? [] : filter(arrayFrom(exports2.values()), (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
+        let exports2 = arrayFrom(getExportsOfSymbol(symbol).values());
+        const merged = getMergedSymbol(symbol);
+        if (merged !== symbol) {
+          const membersSet = new Set(exports2);
+          for (const exported of getExportsOfSymbol(merged).values()) {
+            if (!(getSymbolFlags(resolveSymbol(exported)) & 111551 /* Value */)) {
+              membersSet.add(exported);
+            }
+          }
+          exports2 = arrayFrom(membersSet);
+        }
+        return filter(exports2, (m) => isNamespaceMember(m) && isIdentifierText(m.escapedName, 99 /* ESNext */));
       }
       function isTypeOnlyNamespace(symbol) {
         return every(getNamespaceMembersForSerialization(symbol), (m) => !(getSymbolFlags(resolveSymbol(m)) & 111551 /* Value */));
@@ -52683,7 +52755,7 @@ function createTypeChecker(host) {
         /*reportErrors*/
         false
       ) : unknownType;
-      return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, 0 /* Normal */, contextualType)));
+      return addOptionality(widenTypeInferredFromInitializer(element, checkDeclarationInitializer(element, reportErrors2 ? 0 /* Normal */ : 1 /* Contextual */, contextualType)));
     }
     if (isBindingPattern(element.name)) {
       return getTypeFromBindingPattern(element.name, includePatternInType, reportErrors2);
@@ -52764,6 +52836,24 @@ function createTypeChecker(host) {
       0 /* Normal */
     ), declaration, reportErrors2);
   }
+  function getTypeFromImportAttributes(node) {
+    const links = getNodeLinks(node);
+    if (!links.resolvedType) {
+      const symbol = createSymbol(4096 /* ObjectLiteral */, "__importAttributes" /* ImportAttributes */);
+      const members = createSymbolTable();
+      forEach(node.elements, (attr) => {
+        const member = createSymbol(4 /* Property */, getNameFromImportAttribute(attr));
+        member.parent = symbol;
+        member.links.type = checkImportAttribute(attr);
+        member.links.target = member;
+        members.set(member.escapedName, member);
+      });
+      const type = createAnonymousType(symbol, members, emptyArray, emptyArray, emptyArray);
+      type.objectFlags |= 128 /* ObjectLiteral */ | 262144 /* NonInferrableType */;
+      links.resolvedType = type;
+    }
+    return links.resolvedType;
+  }
   function isGlobalSymbolConstructor(node) {
     const symbol = getSymbolOfNode(node);
     const globalSymbol = getGlobalESSymbolConstructorTypeSymbol(
@@ -52817,18 +52907,18 @@ function createTypeChecker(host) {
     }
     return false;
   }
-  function getTypeOfVariableOrParameterOrProperty(symbol) {
+  function getTypeOfVariableOrParameterOrProperty(symbol, checkMode) {
     const links = getSymbolLinks(symbol);
     if (!links.type) {
-      const type = getTypeOfVariableOrParameterOrPropertyWorker(symbol);
-      if (!links.type && !isParameterOfContextSensitiveSignature(symbol)) {
+      const type = getTypeOfVariableOrParameterOrPropertyWorker(symbol, checkMode);
+      if (!links.type && !isParameterOfContextSensitiveSignature(symbol) && !checkMode) {
         links.type = type;
       }
       return type;
     }
     return links.type;
   }
-  function getTypeOfVariableOrParameterOrPropertyWorker(symbol) {
+  function getTypeOfVariableOrParameterOrPropertyWorker(symbol, checkMode) {
     if (symbol.flags & 4194304 /* Prototype */) {
       return getTypeOfPrototypeProperty(symbol);
     }
@@ -52866,6 +52956,9 @@ function createTypeChecker(host) {
       if (symbol.flags & 512 /* ValueModule */ && !(symbol.flags & 67108864 /* Assignment */)) {
         return getTypeOfFuncClassEnumModule(symbol);
       }
+      if (isBindingElement(declaration) && checkMode === 1 /* Contextual */) {
+        return errorType;
+      }
       return reportCircularityError(symbol);
     }
     let type;
@@ -52903,6 +52996,9 @@ function createTypeChecker(host) {
       if (symbol.flags & 512 /* ValueModule */ && !(symbol.flags & 67108864 /* Assignment */)) {
         return getTypeOfFuncClassEnumModule(symbol);
       }
+      if (isBindingElement(declaration) && checkMode === 1 /* Contextual */) {
+        return type;
+      }
       return reportCircularityError(symbol);
     }
     return type;
@@ -53131,7 +53227,7 @@ function createTypeChecker(host) {
     }
     return getTypeOfSymbol(symbol);
   }
-  function getTypeOfSymbol(symbol) {
+  function getTypeOfSymbol(symbol, checkMode) {
     const checkFlags = getCheckFlags(symbol);
     if (checkFlags & 65536 /* DeferredType */) {
       return getTypeOfSymbolWithDeferredType(symbol);
@@ -53146,7 +53242,7 @@ function createTypeChecker(host) {
       return getTypeOfReverseMappedSymbol(symbol);
     }
     if (symbol.flags & (3 /* Variable */ | 4 /* Property */)) {
-      return getTypeOfVariableOrParameterOrProperty(symbol);
+      return getTypeOfVariableOrParameterOrProperty(symbol, checkMode);
     }
     if (symbol.flags & (16 /* Function */ | 8192 /* Method */ | 32 /* Class */ | 384 /* Enum */ | 512 /* ValueModule */)) {
       return getTypeOfFuncClassEnumModule(symbol);
@@ -56762,6 +56858,14 @@ function createTypeChecker(host) {
       reportErrors2
     )) || emptyObjectType;
   }
+  function getGlobalImportAttributesType(reportErrors2) {
+    return deferredGlobalImportAttributesType || (deferredGlobalImportAttributesType = getGlobalType(
+      "ImportAttributes",
+      /*arity*/
+      0,
+      reportErrors2
+    )) || emptyObjectType;
+  }
   function getGlobalESSymbolConstructorSymbol(reportErrors2) {
     return deferredGlobalESSymbolConstructorSymbol || (deferredGlobalESSymbolConstructorSymbol = getGlobalValueSymbol("Symbol", reportErrors2));
   }
@@ -67509,9 +67613,9 @@ function createTypeChecker(host) {
       }
     }
   }
-  function getNarrowedTypeOfSymbol(symbol, location) {
+  function getNarrowedTypeOfSymbol(symbol, location, checkMode) {
     var _a;
-    const type = getTypeOfSymbol(symbol);
+    const type = getTypeOfSymbol(symbol, checkMode);
     const declaration = symbol.valueDeclaration;
     if (declaration) {
       if (isBindingElement(declaration) && !declaration.initializer && !declaration.dotDotDotToken && declaration.parent.elements.length >= 2) {
@@ -67638,7 +67742,7 @@ function createTypeChecker(host) {
       }
     }
     checkNestedBlockScopedBinding(node, symbol);
-    let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node);
+    let type = getNarrowedTypeOfSymbol(localOrExportSymbol, node, checkMode);
     const assignmentKind = getAssignmentTargetKind(node);
     if (assignmentKind) {
       if (!(localOrExportSymbol.flags & 3 /* Variable */) && !(isInJSFile(node) && localOrExportSymbol.flags & 512 /* ValueModule */)) {
@@ -68948,6 +69052,8 @@ function createTypeChecker(host) {
       case 286 /* JsxOpeningElement */:
       case 285 /* JsxSelfClosingElement */:
         return getContextualJsxElementAttributesType(parent, contextFlags);
+      case 301 /* ImportAttribute */:
+        return getContextualImportAttributeType(parent);
     }
     return void 0;
   }
@@ -68995,6 +69101,12 @@ function createTypeChecker(host) {
       }
     }
   }
+  function getContextualImportAttributeType(node) {
+    return getTypeOfPropertyOfContextualType(getGlobalImportAttributesType(
+      /*reportErrors*/
+      false
+    ), getNameFromImportAttribute(node));
+  }
   function getContextualJsxElementAttributesType(node, contextFlags) {
     if (isJsxOpeningElement(node) && contextFlags !== 4 /* Completions */) {
       const index = findContextualNode(
@@ -81080,6 +81192,13 @@ function createTypeChecker(host) {
     var _a;
     const node = declaration.attributes;
     if (node) {
+      const importAttributesType = getGlobalImportAttributesType(
+        /*reportErrors*/
+        true
+      );
+      if (importAttributesType !== emptyObjectType) {
+        checkTypeAssignableTo(getTypeFromImportAttributes(node), getNullableType(importAttributesType, 32768 /* Undefined */), node);
+      }
       const validForTypeAttributes = isExclusivelyTypeOnlyImportOrExport(declaration);
       const override = getResolutionModeOverride(node, validForTypeAttributes ? grammarErrorOnNode : void 0);
       const isImportAttributes2 = declaration.attributes.token === 118 /* WithKeyword */;
@@ -81099,6 +81218,9 @@ function createTypeChecker(host) {
       }
     }
   }
+  function checkImportAttribute(node) {
+    return getRegularTypeOfLiteralType(checkExpressionCached(node.value));
+  }
   function checkImportDeclaration(node) {
     if (checkGrammarModuleElementContext(node, isInJSFile(node) ? Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_module : Diagnostics.An_import_declaration_can_only_be_used_at_the_top_level_of_a_namespace_or_module)) {
       return;
@@ -82514,6 +82636,12 @@ function createTypeChecker(host) {
     if (isMetaProperty(node.parent) && node.parent.keywordToken === node.kind) {
       return checkMetaPropertyKeyword(node.parent);
     }
+    if (isImportAttributes(node)) {
+      return getGlobalImportAttributesType(
+        /*reportErrors*/
+        false
+      );
+    }
     return errorType;
   }
   function getTypeOfAssignmentPattern(expr) {
@@ -85585,7 +85713,7 @@ function visitCommaListElements(elements, visitor, discardVisitor = visitor) {
     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;
   }
@@ -99888,12 +100016,22 @@ function transformES2015(context) {
       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 */) {
@@ -99929,12 +100067,22 @@ function transformES2015(context) {
       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));
@@ -108332,44 +108480,6 @@ function getDeclarationDiagnostics(host, resolver, file) {
   );
   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);
-  });
-}
 var declarationEmitNodeBuilderFlags = 1024 /* MultilineObjectLiterals */ | 2048 /* WriteClassExpressionAsTypeLiteral */ | 4096 /* UseTypeOfFunction */ | 8 /* UseStructuralFallback */ | 524288 /* AllowEmptyTuple */ | 4 /* GenerateNamesForShadowedTypeParams */ | 1 /* NoTruncation */;
 function transformDeclarations(context) {
   const throwDiagnostic = () => Debug.fail("Diagnostic emitted without context");
@@ -119601,7 +119711,7 @@ function createProgram(rootNamesOrOptions, _options, _host, _oldProgram, _config
         }
         const isFromNodeModulesSearch = resolution.isExternalLibraryImport;
         const isJsFile = !resolutionExtensionIsTSOrJson(resolution.extension);
-        const isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile;
+        const isJsFileFromNodeModules = isFromNodeModulesSearch && isJsFile && (!resolution.originalPath || pathContainsNodeModules(resolution.resolvedFileName));
         const resolvedFileName = resolution.resolvedFileName;
         if (isFromNodeModulesSearch) {
           currentNodeModulesDepth++;