typescript 4.9.0-dev.20221020 → 4.9.0-dev.20221022

package/lib/typingsInstaller.js

@@ -89,7 +89,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221020");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221022");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1881,8 +1881,8 @@ var ts;
         return compareValues(a === null || a === void 0 ? void 0 : a.start, b === null || b === void 0 ? void 0 : b.start) || compareValues(a === null || a === void 0 ? void 0 : a.length, b === null || b === void 0 ? void 0 : b.length);
     }
     ts.compareTextSpans = compareTextSpans;
-    function min(a, b, compare) {
-        return compare(a, b) === -1 /* Comparison.LessThan */ ? a : b;
+    function min(items, compare) {
+        return reduceLeft(items, function (x, y) { return compare(x, y) === -1 /* Comparison.LessThan */ ? x : y; });
     }
     ts.min = min;
     /**
@@ -5099,8 +5099,8 @@ var ts;
         NodeCheckFlags[NodeCheckFlags["SuperInstance"] = 256] = "SuperInstance";
         NodeCheckFlags[NodeCheckFlags["SuperStatic"] = 512] = "SuperStatic";
         NodeCheckFlags[NodeCheckFlags["ContextChecked"] = 1024] = "ContextChecked";
-        NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuper"] = 2048] = "AsyncMethodWithSuper";
-        NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuperBinding"] = 4096] = "AsyncMethodWithSuperBinding";
+        NodeCheckFlags[NodeCheckFlags["MethodWithSuperPropertyAccessInAsync"] = 2048] = "MethodWithSuperPropertyAccessInAsync";
+        NodeCheckFlags[NodeCheckFlags["MethodWithSuperPropertyAssignmentInAsync"] = 4096] = "MethodWithSuperPropertyAssignmentInAsync";
         NodeCheckFlags[NodeCheckFlags["CaptureArguments"] = 8192] = "CaptureArguments";
         NodeCheckFlags[NodeCheckFlags["EnumValuesComputed"] = 16384] = "EnumValuesComputed";
         NodeCheckFlags[NodeCheckFlags["LexicalModuleMergesWithClass"] = 32768] = "LexicalModuleMergesWithClass";
@@ -42251,12 +42251,23 @@ var ts;
         }
         function writeConfigurations() {
             // Filter applicable options to place in the file
-            var categorizedOptions = ts.createMultiMap();
+            var categorizedOptions = new ts.Map();
+            // Set allowed categories in order
+            categorizedOptions.set(ts.Diagnostics.Projects, []);
+            categorizedOptions.set(ts.Diagnostics.Language_and_Environment, []);
+            categorizedOptions.set(ts.Diagnostics.Modules, []);
+            categorizedOptions.set(ts.Diagnostics.JavaScript_Support, []);
+            categorizedOptions.set(ts.Diagnostics.Emit, []);
+            categorizedOptions.set(ts.Diagnostics.Interop_Constraints, []);
+            categorizedOptions.set(ts.Diagnostics.Type_Checking, []);
+            categorizedOptions.set(ts.Diagnostics.Completeness, []);
             for (var _i = 0, optionDeclarations_1 = ts.optionDeclarations; _i < optionDeclarations_1.length; _i++) {
                 var option = optionDeclarations_1[_i];
-                var category = option.category;
                 if (isAllowedOptionForOutput(option)) {
-                    categorizedOptions.add(ts.getLocaleSpecificMessage(category), option);
+                    var listForCategory = categorizedOptions.get(option.category);
+                    if (!listForCategory)
+                        categorizedOptions.set(option.category, listForCategory = []);
+                    listForCategory.push(option);
                 }
             }
             // Serialize all options and their descriptions
@@ -42267,7 +42278,7 @@ var ts;
                 if (entries.length !== 0) {
                     entries.push({ value: "" });
                 }
-                entries.push({ value: "/* ".concat(category, " */") });
+                entries.push({ value: "/* ".concat(ts.getLocaleSpecificMessage(category), " */") });
                 for (var _i = 0, options_1 = options; _i < options_1.length; _i++) {
                     var option = options_1[_i];
                     var optionName = void 0;
@@ -73278,7 +73289,7 @@ var ts;
             // We only look for uninitialized variables in strict null checking mode, and only when we can analyze
             // the entire control flow graph from the variable's declaration (i.e. when the flow container and
             // declaration container are the same).
-            var assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || ts.isBindingElement(declaration) ||
+            var assumeInitialized = isParameter || isAlias || isOuterVariable || isSpreadDestructuringAssignmentTarget || isModuleExports || isSameScopedBindingElement(node, declaration) ||
                 type !== autoType && type !== autoArrayType && (!strictNullChecks || (type.flags & (3 /* TypeFlags.AnyOrUnknown */ | 16384 /* TypeFlags.Void */)) !== 0 ||
                     isInTypeQuery(node) || node.parent.kind === 278 /* SyntaxKind.ExportSpecifier */) ||
                 node.parent.kind === 232 /* SyntaxKind.NonNullExpression */ ||
@@ -73307,6 +73318,12 @@ var ts;
             }
             return assignmentKind ? getBaseTypeOfLiteralType(flowType) : flowType;
         }
+        function isSameScopedBindingElement(node, declaration) {
+            if (ts.isBindingElement(declaration)) {
+                var bindingElement = ts.findAncestor(node, ts.isBindingElement);
+                return bindingElement && ts.getRootDeclaration(bindingElement) === ts.getRootDeclaration(declaration);
+            }
+        }
         function shouldMarkIdentifierAliasReferenced(node) {
             var _a;
             var parent = node.parent;
@@ -73648,12 +73665,17 @@ var ts;
             var immediateContainer = ts.getSuperContainer(node, /*stopOnFunctions*/ true);
             var container = immediateContainer;
             var needToCaptureLexicalThis = false;
+            var inAsyncFunction = false;
             // adjust the container reference in case if super is used inside arrow functions with arbitrarily deep nesting
             if (!isCallExpression) {
                 while (container && container.kind === 216 /* SyntaxKind.ArrowFunction */) {
+                    if (ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */))
+                        inAsyncFunction = true;
                     container = ts.getSuperContainer(container, /*stopOnFunctions*/ true);
                     needToCaptureLexicalThis = languageVersion < 2 /* ScriptTarget.ES2015 */;
                 }
+                if (container && ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */))
+                    inAsyncFunction = true;
             }
             var canUseSuperExpression = isLegalUsageOfSuperExpression(container);
             var nodeCheckFlag = 0;
@@ -73759,12 +73781,12 @@ var ts;
             // as a call expression cannot be used as the target of a destructuring assignment while a property access can.
             //
             // For element access expressions (`super[x]`), we emit a generic helper that forwards the element access in both situations.
-            if (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */)) {
+            if (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && inAsyncFunction) {
                 if (ts.isSuperProperty(node.parent) && ts.isAssignmentTarget(node.parent)) {
-                    getNodeLinks(container).flags |= 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */;
+                    getNodeLinks(container).flags |= 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */;
                 }
                 else {
-                    getNodeLinks(container).flags |= 2048 /* NodeCheckFlags.AsyncMethodWithSuper */;
+                    getNodeLinks(container).flags |= 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */;
                 }
             }
             if (needToCaptureLexicalThis) {
@@ -82920,7 +82942,7 @@ var ts;
                 return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0];
             }
             // primitives with a `{ then() }` won't be unwrapped/adopted.
-            if (allTypesAssignableToKind(type, 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
+            if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
                 return undefined;
             }
             var thenFunction = getTypeOfPropertyOfType(type, "then"); // TODO: GH#18217
@@ -82987,7 +83009,7 @@ var ts;
          * Determines whether a type is an object with a callable `then` member.
          */
         function isThenableType(type) {
-            if (allTypesAssignableToKind(type, 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
+            if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
                 // primitive types cannot be considered "thenable" since they are not objects.
                 return false;
             }
@@ -98486,8 +98508,11 @@ var ts;
                     }
                     return ts.visitEachChild(node, visitor, context);
                 case 174 /* SyntaxKind.GetAccessor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitGetAccessorDeclaration, node);
                 case 175 /* SyntaxKind.SetAccessor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitSetAccessorDeclaration, node);
                 case 173 /* SyntaxKind.Constructor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitConstructorDeclaration, node);
                 case 260 /* SyntaxKind.ClassDeclaration */:
                 case 228 /* SyntaxKind.ClassExpression */:
                     return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitDefault, node);
@@ -98588,6 +98613,9 @@ var ts;
             return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression(
             /*asteriskToken*/ undefined, ts.visitNode(node.expression, visitor, ts.isExpression)), node), node);
         }
+        function visitConstructorDeclaration(node) {
+            return factory.updateConstructorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), ts.visitParameterList(node.parameters, visitor, context), transformMethodBody(node));
+        }
         /**
          * Visits a MethodDeclaration node.
          *
@@ -98602,7 +98630,14 @@ var ts;
             /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
             /*type*/ undefined, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */
                 ? transformAsyncFunctionBody(node)
-                : ts.visitFunctionBody(node.body, visitor, context));
+                : transformMethodBody(node));
+        }
+        function visitGetAccessorDeclaration(node) {
+            return factory.updateGetAccessorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, ts.visitParameterList(node.parameters, visitor, context), 
+            /*type*/ undefined, transformMethodBody(node));
+        }
+        function visitSetAccessorDeclaration(node) {
+            return factory.updateSetAccessorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, ts.visitParameterList(node.parameters, visitor, context), transformMethodBody(node));
         }
         /**
          * Visits a FunctionDeclaration node.
@@ -98716,6 +98751,42 @@ var ts;
             }
             return false;
         }
+        function transformMethodBody(node) {
+            ts.Debug.assertIsDefined(node.body);
+            var savedCapturedSuperProperties = capturedSuperProperties;
+            var savedHasSuperElementAccess = hasSuperElementAccess;
+            capturedSuperProperties = new ts.Set();
+            hasSuperElementAccess = false;
+            var updated = ts.visitFunctionBody(node.body, visitor, context);
+            // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
+            // This step isn't needed if we eventually transform this to ES5.
+            var originalMethod = ts.getOriginalNode(node, ts.isFunctionLikeDeclaration);
+            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ &&
+                resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) &&
+                (ts.getFunctionFlags(originalMethod) & 3 /* FunctionFlags.AsyncGenerator */) !== 3 /* FunctionFlags.AsyncGenerator */;
+            if (emitSuperHelpers) {
+                enableSubstitutionForAsyncMethodsWithSuper();
+                if (capturedSuperProperties.size) {
+                    var variableStatement = createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
+                    substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true;
+                    var statements = updated.statements.slice();
+                    ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]);
+                    updated = factory.updateBlock(updated, statements);
+                }
+                if (hasSuperElementAccess) {
+                    // Emit helpers for super element access expressions (`super[x]`).
+                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
+                        ts.addEmitHelper(updated, ts.advancedAsyncSuperHelper);
+                    }
+                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
+                        ts.addEmitHelper(updated, ts.asyncSuperHelper);
+                    }
+                }
+            }
+            capturedSuperProperties = savedCapturedSuperProperties;
+            hasSuperElementAccess = savedHasSuperElementAccess;
+            return updated;
+        }
         function transformAsyncFunctionBody(node) {
             resumeLexicalEnvironment();
             var original = ts.getOriginalNode(node, ts.isFunctionLike);
@@ -98748,7 +98819,7 @@ var ts;
                 ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
                 // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
                 // This step isn't needed if we eventually transform this to ES5.
-                var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */ | 2048 /* NodeCheckFlags.AsyncMethodWithSuper */);
+                var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */);
                 if (emitSuperHelpers) {
                     enableSubstitutionForAsyncMethodsWithSuper();
                     if (capturedSuperProperties.size) {
@@ -98761,10 +98832,10 @@ var ts;
                 ts.setTextRange(block, node.body);
                 if (emitSuperHelpers && hasSuperElementAccess) {
                     // Emit helpers for super element access expressions (`super[x]`).
-                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                         ts.addEmitHelper(block, ts.advancedAsyncSuperHelper);
                     }
-                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.AsyncMethodWithSuper */) {
+                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
                         ts.addEmitHelper(block, ts.asyncSuperHelper);
                     }
                 }
@@ -98836,7 +98907,7 @@ var ts;
             // If we need to support substitutions for `super` in an async method,
             // we should track it here.
             if (enabledSubstitutions & 1 /* ES2017SubstitutionFlags.AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.AsyncMethodWithSuper */ | 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */);
+                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */ | 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */);
                 if (superContainerFlags !== enclosingSuperContainerFlags) {
                     var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
                     enclosingSuperContainerFlags = superContainerFlags;
@@ -98913,7 +98984,7 @@ var ts;
                 || kind === 175 /* SyntaxKind.SetAccessor */;
         }
         function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                 return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createUniqueName("_superIndex", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), 
                 /*typeArguments*/ undefined, [argumentExpression]), "value"), location);
             }
@@ -98928,7 +98999,7 @@ var ts;
     function createSuperAccessVariableStatement(factory, resolver, node, names) {
         // Create a variable declaration with a getter/setter (if binding) definition for each name:
         //   const _super = Object.create(null, { x: { get: () => super.x, set: (v) => super.x = v }, ... });
-        var hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) !== 0;
+        var hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) !== 0;
         var accessors = [];
         names.forEach(function (_, key) {
             var name = ts.unescapeLeadingUnderscores(key);
@@ -99636,7 +99707,7 @@ var ts;
             /*type*/ undefined, factory.updateBlock(node.body, ts.visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset))), !!(hierarchyFacts & 1 /* HierarchyFacts.HasLexicalThis */)));
             // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
             // This step isn't needed if we eventually transform this to ES5.
-            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */ | 2048 /* NodeCheckFlags.AsyncMethodWithSuper */);
+            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */);
             if (emitSuperHelpers) {
                 enableSubstitutionForAsyncMethodsWithSuper();
                 var variableStatement = ts.createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
@@ -99647,10 +99718,10 @@ var ts;
             ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
             var block = factory.updateBlock(node.body, statements);
             if (emitSuperHelpers && hasSuperElementAccess) {
-                if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+                if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                     ts.addEmitHelper(block, ts.advancedAsyncSuperHelper);
                 }
-                else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.AsyncMethodWithSuper */) {
+                else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
                     ts.addEmitHelper(block, ts.asyncSuperHelper);
                 }
             }
@@ -99779,7 +99850,7 @@ var ts;
             // If we need to support substitutions for `super` in an async method,
             // we should track it here.
             if (enabledSubstitutions & 1 /* ESNextSubstitutionFlags.AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.AsyncMethodWithSuper */ | 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */);
+                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */ | 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */);
                 if (superContainerFlags !== enclosingSuperContainerFlags) {
                     var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
                     enclosingSuperContainerFlags = superContainerFlags;
@@ -99856,7 +99927,7 @@ var ts;
                 || kind === 175 /* SyntaxKind.SetAccessor */;
         }
         function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                 return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createIdentifier("_superIndex"), 
                 /*typeArguments*/ undefined, [argumentExpression]), "value"), location);
             }
@@ -123882,7 +123953,7 @@ var ts;
         var isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== 47 /* CharacterCodes.slash */;
         if (isNonDirectorySeparatorRoot &&
             dirPath.search(/[a-zA-Z]:/) !== 0 && // Non dos style paths
-            pathPartForUserCheck.search(/[a-zA-z]\$\//) === 0) { // Dos style nextPart
+            pathPartForUserCheck.search(/[a-zA-Z]\$\//) === 0) { // Dos style nextPart
             nextDirectorySeparator = dirPath.indexOf(ts.directorySeparator, nextDirectorySeparator + 1);
             if (nextDirectorySeparator === -1) {
                 // ignore "//vda1cs4850/c$/folderAtRoot"
@@ -125388,15 +125459,21 @@ var ts;
             return undefined;
         }
         function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) {
-            var normalizedTargetPath = getPathRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
-            if (normalizedTargetPath === undefined) {
+            var normalizedTargetPaths = getPathsRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
+            if (normalizedTargetPaths === undefined) {
+                return undefined;
+            }
+            var normalizedSourcePaths = getPathsRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName);
+            var relativePaths = ts.flatMap(normalizedSourcePaths, function (sourcePath) {
+                return ts.map(normalizedTargetPaths, function (targetPath) { return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourcePath, targetPath, getCanonicalFileName)); });
+            });
+            var shortest = ts.min(relativePaths, ts.compareNumberOfDirectorySeparators);
+            if (!shortest) {
                 return undefined;
             }
-            var normalizedSourcePath = getPathRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName);
-            var relativePath = normalizedSourcePath !== undefined ? ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(normalizedSourcePath, normalizedTargetPath, getCanonicalFileName)) : normalizedTargetPath;
             return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs
-                ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
-                : ts.removeFileExtension(relativePath);
+                ? removeExtensionAndIndexPostFix(shortest, ending, compilerOptions)
+                : ts.removeFileExtension(shortest);
         }
         function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
             var path = _a.path, isRedirect = _a.isRedirect;
@@ -125533,8 +125610,8 @@ var ts;
                 }
             }
         }
-        function getPathRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
-            return ts.firstDefined(rootDirs, function (rootDir) {
+        function getPathsRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
+            return ts.mapDefined(rootDirs, function (rootDir) {
                 var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName);
                 return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath;
             });

package/package.json

@@ -2,7 +2,7 @@
     "name": "typescript",
     "author": "Microsoft Corp.",
     "homepage": "https://www.typescriptlang.org/",
-    "version": "4.9.0-dev.20221020",
+    "version": "4.9.0-dev.20221022",
     "license": "Apache-2.0",
     "description": "TypeScript is a language for application scale JavaScript development",
     "keywords": [