@typescript-deploys/pr-build 4.7.0-pr-48294-7 → 4.7.0-pr-48264-4

package/lib/typingsInstaller.js

@@ -14939,6 +14939,10 @@ var ts;
         }
     }
     ts.isAnyImportSyntax = isAnyImportSyntax;
+    function isAnyImportOrBareOrAccessedRequire(node) {
+        return isAnyImportSyntax(node) || isVariableDeclarationInitializedToBareOrAccessedRequire(node);
+    }
+    ts.isAnyImportOrBareOrAccessedRequire = isAnyImportOrBareOrAccessedRequire;
     function isLateVisibilityPaintedStatement(node) {
         switch (node.kind) {
             case 265 /* ImportDeclaration */:
@@ -16517,14 +16521,14 @@ var ts;
     }
     ts.isFunctionSymbol = isFunctionSymbol;
     function tryGetModuleSpecifierFromDeclaration(node) {
-        var _a, _b, _c;
+        var _a, _b;
         switch (node.kind) {
             case 253 /* VariableDeclaration */:
-                return node.initializer.arguments[0].text;
+                return (_a = ts.findAncestor(node.initializer, function (node) { return isRequireCall(node, /*requireStringLiteralLikeArgument*/ true); })) === null || _a === void 0 ? void 0 : _a.arguments[0];
             case 265 /* ImportDeclaration */:
-                return (_a = ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike)) === null || _a === void 0 ? void 0 : _a.text;
+                return ts.tryCast(node.moduleSpecifier, ts.isStringLiteralLike);
             case 264 /* ImportEqualsDeclaration */:
-                return (_c = ts.tryCast((_b = ts.tryCast(node.moduleReference, ts.isExternalModuleReference)) === null || _b === void 0 ? void 0 : _b.expression, ts.isStringLiteralLike)) === null || _c === void 0 ? void 0 : _c.text;
+                return ts.tryCast((_b = ts.tryCast(node.moduleReference, ts.isExternalModuleReference)) === null || _b === void 0 ? void 0 : _b.expression, ts.isStringLiteralLike);
             default:
                 ts.Debug.assertNever(node);
         }
@@ -17051,21 +17055,28 @@ var ts;
     // export = <EntityNameExpression>
     // export default <EntityNameExpression>
     // module.exports = <EntityNameExpression>
-    // {<Identifier>}
-    // {name: <EntityNameExpression>}
+    // module.exports.x = <EntityNameExpression>
+    // const x = require("...")
+    // const { x } = require("...")
+    // const x = require("...").y
+    // const { x } = require("...").y
     function isAliasSymbolDeclaration(node) {
-        return node.kind === 264 /* ImportEqualsDeclaration */ ||
+        if (node.kind === 264 /* ImportEqualsDeclaration */ ||
             node.kind === 263 /* NamespaceExportDeclaration */ ||
             node.kind === 266 /* ImportClause */ && !!node.name ||
             node.kind === 267 /* NamespaceImport */ ||
             node.kind === 273 /* NamespaceExport */ ||
             node.kind === 269 /* ImportSpecifier */ ||
             node.kind === 274 /* ExportSpecifier */ ||
-            node.kind === 270 /* ExportAssignment */ && exportAssignmentIsAlias(node) ||
-            ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) ||
-            ts.isPropertyAccessExpression(node) && ts.isBinaryExpression(node.parent) && node.parent.left === node && node.parent.operatorToken.kind === 63 /* EqualsToken */ && isAliasableExpression(node.parent.right) ||
-            node.kind === 296 /* ShorthandPropertyAssignment */ ||
-            node.kind === 295 /* PropertyAssignment */ && isAliasableExpression(node.initializer);
+            node.kind === 270 /* ExportAssignment */ && exportAssignmentIsAlias(node)) {
+            return true;
+        }
+        return isInJSFile(node) && (ts.isBinaryExpression(node) && getAssignmentDeclarationKind(node) === 2 /* ModuleExports */ && exportAssignmentIsAlias(node) ||
+            ts.isPropertyAccessExpression(node)
+                && ts.isBinaryExpression(node.parent)
+                && node.parent.left === node
+                && node.parent.operatorToken.kind === 63 /* EqualsToken */
+                && isAliasableExpression(node.parent.right));
     }
     ts.isAliasSymbolDeclaration = isAliasSymbolDeclaration;
     function getAliasDeclarationFromName(node) {
@@ -17076,6 +17087,7 @@ var ts;
             case 274 /* ExportSpecifier */:
             case 270 /* ExportAssignment */:
             case 264 /* ImportEqualsDeclaration */:
+            case 273 /* NamespaceExport */:
                 return node.parent;
             case 160 /* QualifiedName */:
                 do {
@@ -39434,6 +39446,13 @@ var ts;
             description: ts.Diagnostics.Allow_accessing_UMD_globals_from_modules,
             defaultValueDescription: false,
         },
+        {
+            name: "noDtsResolution",
+            type: "boolean",
+            affectsModuleResolution: true,
+            category: ts.Diagnostics.Modules,
+            defaultValueDescription: false,
+        },
         // Source Maps
         {
             name: "sourceRoot",
@@ -41813,7 +41832,8 @@ var ts;
         Extensions[Extensions["JavaScript"] = 1] = "JavaScript";
         Extensions[Extensions["Json"] = 2] = "Json";
         Extensions[Extensions["TSConfig"] = 3] = "TSConfig";
-        Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly"; /** Only '.d.ts' */
+        Extensions[Extensions["DtsOnly"] = 4] = "DtsOnly";
+        Extensions[Extensions["TypeScriptButNotDts"] = 5] = "TypeScriptButNotDts";
     })(Extensions || (Extensions = {}));
     /** Used with `Extensions.DtsOnly` to extract the path from TypeScript results. */
     function resolvedTypeScriptOnly(resolved) {
@@ -42758,7 +42778,21 @@ var ts;
         return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, initialDir, { moduleResolution: ts.ModuleResolutionKind.NodeJs, allowJs: true }, host, /*cache*/ undefined, jsOnlyExtensions, /*redirectedReferences*/ undefined);
     }
     function nodeModuleNameResolver(moduleName, containingFile, compilerOptions, host, cache, redirectedReference, lookupConfig) {
-        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, lookupConfig ? tsconfigExtensions : (compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions), redirectedReference);
+        var extensions;
+        if (lookupConfig) {
+            extensions = tsconfigExtensions;
+        }
+        else if (compilerOptions.noDtsResolution) {
+            extensions = [Extensions.TypeScriptButNotDts];
+            if (compilerOptions.allowJs)
+                extensions.push(Extensions.JavaScript);
+            if (compilerOptions.resolveJsonModule)
+                extensions.push(Extensions.Json);
+        }
+        else {
+            extensions = compilerOptions.resolveJsonModule ? tsPlusJsonExtensions : tsExtensions;
+        }
+        return nodeModuleNameResolverWorker(NodeResolutionFeatures.None, moduleName, ts.getDirectoryPath(containingFile), compilerOptions, host, cache, extensions, redirectedReference);
     }
     ts.nodeModuleNameResolver = nodeModuleNameResolver;
     function nodeModuleNameResolverWorker(features, moduleName, containingDirectory, compilerOptions, host, cache, extensions, redirectedReference) {
@@ -42767,6 +42801,10 @@ var ts;
         var failedLookupLocations = [];
         // conditions are only used by the node12/nodenext resolver - there's no priority order in the list,
         //it's essentially a set (priority is determined by object insertion order in the object we look at).
+        var conditions = features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"];
+        if (compilerOptions.noDtsResolution) {
+            conditions.pop();
+        }
         var state = {
             compilerOptions: compilerOptions,
             host: host,
@@ -42774,7 +42812,7 @@ var ts;
             failedLookupLocations: failedLookupLocations,
             packageJsonInfoCache: cache,
             features: features,
-            conditions: features & NodeResolutionFeatures.EsmMode ? ["node", "import", "types"] : ["node", "require", "types"]
+            conditions: conditions,
         };
         var result = ts.forEach(extensions, function (ext) { return tryResolve(ext); });
         return createResolvedModuleWithFailedLookupLocations((_a = result === null || result === void 0 ? void 0 : result.value) === null || _a === void 0 ? void 0 : _a.resolved, (_b = result === null || result === void 0 ? void 0 : result.value) === null || _b === void 0 ? void 0 : _b.isExternalLibraryImport, failedLookupLocations, state.resultFromCache);
@@ -42982,20 +43020,22 @@ var ts;
                     default: return tryExtension(".d.ts" /* Dts */);
                 }
             case Extensions.TypeScript:
+            case Extensions.TypeScriptButNotDts:
+                var useDts = extensions === Extensions.TypeScript;
                 switch (originalExtension) {
                     case ".mjs" /* Mjs */:
                     case ".mts" /* Mts */:
                     case ".d.mts" /* Dmts */:
-                        return tryExtension(".mts" /* Mts */) || tryExtension(".d.mts" /* Dmts */);
+                        return tryExtension(".mts" /* Mts */) || (useDts ? tryExtension(".d.mts" /* Dmts */) : undefined);
                     case ".cjs" /* Cjs */:
                     case ".cts" /* Cts */:
                     case ".d.cts" /* Dcts */:
-                        return tryExtension(".cts" /* Cts */) || tryExtension(".d.cts" /* Dcts */);
+                        return tryExtension(".cts" /* Cts */) || (useDts ? tryExtension(".d.cts" /* Dcts */) : undefined);
                     case ".json" /* Json */:
                         candidate += ".json" /* Json */;
-                        return tryExtension(".d.ts" /* Dts */);
+                        return useDts ? tryExtension(".d.ts" /* Dts */) : undefined;
                     default:
-                        return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || tryExtension(".d.ts" /* Dts */);
+                        return tryExtension(".ts" /* Ts */) || tryExtension(".tsx" /* Tsx */) || (useDts ? tryExtension(".d.ts" /* Dts */) : undefined);
                 }
             case Extensions.JavaScript:
                 switch (originalExtension) {
@@ -43213,6 +43253,7 @@ var ts;
             switch (extensions) {
                 case Extensions.JavaScript:
                 case Extensions.Json:
+                case Extensions.TypeScriptButNotDts:
                     packageFile = readPackageJsonMainField(jsonContent, candidate, state);
                     break;
                 case Extensions.TypeScript:
@@ -43291,6 +43332,8 @@ var ts;
                 return extension === ".json" /* Json */;
             case Extensions.TypeScript:
                 return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */ || extension === ".d.ts" /* Dts */;
+            case Extensions.TypeScriptButNotDts:
+                return extension === ".ts" /* Ts */ || extension === ".tsx" /* Tsx */;
             case Extensions.DtsOnly:
                 return extension === ".d.ts" /* Dts */;
         }
@@ -54907,7 +54950,7 @@ var ts;
                 if (!omitTypeAlias) {
                     return errorType;
                 }
-                return getGlobalTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
+                return getTypeAliasInstantiation(omitTypeAlias, [source, omitKeyType]);
             }
             var members = ts.createSymbolTable();
             for (var _b = 0, spreadableProperties_1 = spreadableProperties; _b < spreadableProperties_1.length; _b++) {
@@ -55359,7 +55402,7 @@ var ts;
                         }
                     }
                     var sourceTypes = ts.some(constructorTypes, function (t) { return !!(t.flags & ~98304 /* Nullable */); }) ? constructorTypes : types; // TODO: GH#18217
-                    type = getUnionType(sourceTypes, 2 /* Subtype */);
+                    type = getUnionType(sourceTypes);
                 }
             }
             var widened = getWidenedType(addOptionality(type, /*isProperty*/ false, definedInMethod && !definedInConstructor));
@@ -56674,7 +56717,7 @@ var ts;
                     }
                 }
                 if (memberTypeList.length) {
-                    var enumType_1 = getUnionType(memberTypeList, 1 /* Literal */, symbol, /*aliasTypeArguments*/ undefined, /*aliasMapper*/ undefined);
+                    var enumType_1 = getUnionType(memberTypeList, 1 /* Literal */, symbol, /*aliasTypeArguments*/ undefined);
                     if (enumType_1.flags & 1048576 /* Union */) {
                         enumType_1.flags |= 1024 /* EnumLiteral */;
                         enumType_1.symbol = symbol;
@@ -59397,7 +59440,7 @@ var ts;
             type.resolvedTypeArguments = source.resolvedTypeArguments;
             return type;
         }
-        function createDeferredTypeReference(target, node, mapper, aliasSymbol, aliasTypeArguments, aliasMapper) {
+        function createDeferredTypeReference(target, node, mapper, aliasSymbol, aliasTypeArguments) {
             if (!aliasSymbol) {
                 aliasSymbol = getAliasSymbolForTypeNode(node);
                 var localAliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
@@ -59409,7 +59452,6 @@ var ts;
             type.mapper = mapper;
             type.aliasSymbol = aliasSymbol;
             type.aliasTypeArguments = aliasTypeArguments;
-            type.aliasMapper = aliasMapper;
             return type;
         }
         function getTypeArguments(type) {
@@ -59474,7 +59516,7 @@ var ts;
             }
             return checkNoTypeArguments(node, symbol) ? type : errorType;
         }
-        function getGlobalTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
+        function getTypeAliasInstantiation(symbol, typeArguments, aliasSymbol, aliasTypeArguments) {
             var type = getDeclaredTypeOfSymbol(symbol);
             if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
                 return getStringMappingType(symbol, typeArguments[0]);
@@ -59488,33 +59530,6 @@ var ts;
             }
             return instantiation;
         }
-        function getLocalTypeAliasInstantiation(symbol, typeArguments, outerTypeParameterMapper, aliasSymbol, aliasTypeArguments) {
-            var type = getDeclaredTypeOfSymbol(symbol);
-            if (type === intrinsicMarkerType && intrinsicTypeKinds.has(symbol.escapedName) && typeArguments && typeArguments.length === 1) {
-                return getStringMappingType(symbol, typeArguments[0]);
-            }
-            var links = getSymbolLinks(symbol);
-            var outerTypeParameters = getOuterTypeParametersOfAlias(symbol);
-            var mappedOuterParams = outerTypeParameterMapper && outerTypeParameters && instantiateTypes(outerTypeParameters, outerTypeParameterMapper);
-            var typeParameters = links.typeParameters;
-            var id = getTypeListId(ts.concatenate(mappedOuterParams, typeArguments)) + getAliasId(aliasSymbol, aliasTypeArguments);
-            var instantiation = links.instantiations.get(id);
-            if (!instantiation) {
-                var outerTypeArgumentMapper = outerTypeParameters && mappedOuterParams && createTypeMapper(outerTypeParameters, mappedOuterParams);
-                var argumentMapper = createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), ts.isInJSFile(symbol.valueDeclaration)));
-                var combinedMapper = outerTypeArgumentMapper ? combineTypeMappers(argumentMapper, outerTypeArgumentMapper) : argumentMapper;
-                links.instantiations.set(id, instantiation = instantiateTypeWithAlias(type, combinedMapper, aliasSymbol, aliasTypeArguments));
-            }
-            return instantiation;
-        }
-        function getOuterTypeParametersOfAlias(symbol) {
-            var _a;
-            var links = getSymbolLinks(symbol);
-            if (!links.outerTypeParameters) {
-                links.outerTypeParameters = ((_a = symbol.declarations) === null || _a === void 0 ? void 0 : _a[0]) && getOuterTypeParameters(symbol.declarations[0], /*includeThisTypes*/ true);
-            }
-            return links.outerTypeParameters;
-        }
         /**
          * Get type from reference to type alias. When a type alias is generic, the declared type of the type alias may include
          * references to the type parameters of the alias. We replace those with the actual type arguments by instantiating the
@@ -59550,7 +59565,7 @@ var ts;
                 // a .d.ts file. See #43622 for an example.
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
                 var newAliasSymbol = aliasSymbol && (isLocalTypeAlias(symbol) || !isLocalTypeAlias(aliasSymbol)) ? aliasSymbol : undefined;
-                return getGlobalTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, getTypeArgumentsForAliasSymbol(newAliasSymbol));
+                return getTypeAliasInstantiation(symbol, typeArgumentsFromTypeReferenceNode(node), newAliasSymbol, getTypeArgumentsForAliasSymbol(newAliasSymbol));
             }
             return checkNoTypeArguments(node, symbol) ? type : errorType;
         }
@@ -60465,7 +60480,14 @@ var ts;
             result.types = types;
             return result;
         }
-        function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments, aliasMapper, origin) {
+        // We sort and deduplicate the constituent types based on object identity. If the subtypeReduction
+        // flag is specified we also reduce the constituent type set to only include types that aren't subtypes
+        // of other types. Subtype reduction is expensive for large union types and is possible only when union
+        // types are known not to circularly reference themselves (as is the case with union types created by
+        // expression constructs such as array literals and the || and ?: operators). Named types can
+        // circularly reference themselves and therefore cannot be subtype reduced during their declaration.
+        // For example, "type Item = string | (() => Item" is a named type that circularly references itself.
+        function getUnionType(types, unionReduction, aliasSymbol, aliasTypeArguments, origin) {
             if (unionReduction === void 0) { unionReduction = 1 /* Literal */; }
             if (types.length === 0) {
                 return neverType;
@@ -60534,7 +60556,7 @@ var ts;
             }
             var objectFlags = (includes & 36323363 /* NotPrimitiveUnion */ ? 0 : 65536 /* PrimitiveUnion */) |
                 (includes & 2097152 /* Intersection */ ? 33554432 /* ContainsIntersections */ : 0);
-            return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, aliasMapper, origin);
+            return getUnionTypeFromSortedList(typeSet, objectFlags, aliasSymbol, aliasTypeArguments, origin);
         }
         function getUnionOrIntersectionTypePredicate(signatures, kind) {
             var first;
@@ -60572,7 +60594,7 @@ var ts;
             return a.kind === b.kind && a.parameterIndex === b.parameterIndex;
         }
         // This function assumes the constituent type list is sorted and deduplicated.
-        function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, aliasMapper, origin) {
+        function getUnionTypeFromSortedList(types, objectFlags, aliasSymbol, aliasTypeArguments, origin) {
             if (types.length === 0) {
                 return neverType;
             }
@@ -60592,7 +60614,6 @@ var ts;
                 type.origin = origin;
                 type.aliasSymbol = aliasSymbol;
                 type.aliasTypeArguments = aliasTypeArguments;
-                type.aliasMapper = aliasMapper;
                 if (types.length === 2 && types[0].flags & 512 /* BooleanLiteral */ && types[1].flags & 512 /* BooleanLiteral */) {
                     type.flags |= 16 /* Boolean */;
                     type.intrinsicName = "boolean";
@@ -60605,7 +60626,7 @@ var ts;
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
-                links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), 1 /* Literal */, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), /*aliasMapper*/ undefined);
+                links.resolvedType = getUnionType(ts.map(node.types, getTypeFromTypeNode), 1 /* Literal */, aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
             }
             return links.resolvedType;
         }
@@ -60764,16 +60785,25 @@ var ts;
             types[index] = getUnionTypeFromSortedList(result, 65536 /* PrimitiveUnion */);
             return true;
         }
-        function createIntersectionType(types, aliasSymbol, aliasTypeArguments, aliasMapper) {
+        function createIntersectionType(types, aliasSymbol, aliasTypeArguments) {
             var result = createType(2097152 /* Intersection */);
             result.objectFlags = getPropagatingFlagsOfTypes(types, /*excludeKinds*/ 98304 /* Nullable */);
             result.types = types;
             result.aliasSymbol = aliasSymbol;
             result.aliasTypeArguments = aliasTypeArguments;
-            result.aliasMapper = aliasMapper;
             return result;
         }
-        function getIntersectionType(types, aliasSymbol, aliasTypeArguments, aliasMapper) {
+        // We normalize combinations of intersection and union types based on the distributive property of the '&'
+        // operator. Specifically, because X & (A | B) is equivalent to X & A | X & B, we can transform intersection
+        // types with union type constituents into equivalent union types with intersection type constituents and
+        // effectively ensure that union types are always at the top level in type representations.
+        //
+        // We do not perform structural deduplication on intersection types. Intersection types are created only by the &
+        // type operator and we can't reduce those because we want to support recursive intersection types. For example,
+        // a type alias of the form "type List<T> = T & { next: List<T> }" cannot be reduced during its declaration.
+        // Also, unlike union types, the order of the constituent types is preserved in order that overload resolution
+        // for intersections of types with signatures can be deterministic.
+        function getIntersectionType(types, aliasSymbol, aliasTypeArguments) {
             var typeMembershipMap = new ts.Map();
             var includes = addTypesToIntersection(typeMembershipMap, 0, types);
             var typeSet = ts.arrayFrom(typeMembershipMap.values());
@@ -60833,16 +60863,16 @@ var ts;
                         // When the intersection creates a reduced set (which might mean that *all* union types have
                         // disappeared), we restart the operation to get a new set of combined flags. Once we have
                         // reduced we'll never reduce again, so this occurs at most once.
-                        result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments, aliasMapper);
+                        result = getIntersectionType(typeSet, aliasSymbol, aliasTypeArguments);
                     }
                     else if (eachIsUnionContaining(typeSet, 32768 /* Undefined */)) {
                         var undefinedOrMissingType = exactOptionalPropertyTypes && ts.some(typeSet, function (t) { return containsType(t.types, missingType); }) ? missingType : undefinedType;
                         removeFromEach(typeSet, 32768 /* Undefined */);
-                        result = getUnionType([getIntersectionType(typeSet), undefinedOrMissingType], 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper);
+                        result = getUnionType([getIntersectionType(typeSet), undefinedOrMissingType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
                     }
                     else if (eachIsUnionContaining(typeSet, 65536 /* Null */)) {
                         removeFromEach(typeSet, 65536 /* Null */);
-                        result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper);
+                        result = getUnionType([getIntersectionType(typeSet), nullType], 1 /* Literal */, aliasSymbol, aliasTypeArguments);
                     }
                     else {
                         // We are attempting to construct a type of the form X & (A | B) & (C | D). Transform this into a type of
@@ -60855,7 +60885,7 @@ var ts;
                         // We attach a denormalized origin type when at least one constituent of the cross-product union is an
                         // intersection (i.e. when the intersection didn't just reduce one or more unions to smaller unions).
                         var origin = ts.some(constituents, function (t) { return !!(t.flags & 2097152 /* Intersection */); }) ? createOriginUnionOrIntersectionType(2097152 /* Intersection */, typeSet) : undefined;
-                        result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper, origin);
+                        result = getUnionType(constituents, 1 /* Literal */, aliasSymbol, aliasTypeArguments, origin);
                     }
                 }
                 else {
@@ -60901,7 +60931,7 @@ var ts;
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
-                links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol), /*aliasMapper*/ undefined);
+                links.resolvedType = getIntersectionType(ts.map(node.types, getTypeFromTypeNode), aliasSymbol, getTypeArgumentsForAliasSymbol(aliasSymbol));
             }
             return links.resolvedType;
         }
@@ -61020,7 +61050,7 @@ var ts;
             var indexKeyTypes = ts.map(getIndexInfosOfType(type), function (info) { return info !== enumNumberIndexInfo && isKeyTypeIncluded(info.keyType, include) ?
                 info.keyType === stringType && include & 8 /* Number */ ? stringOrNumberType : info.keyType : neverType; });
             return getUnionType(ts.concatenate(propertyTypes, indexKeyTypes), 1 /* Literal */, 
-            /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, /*aliasMapper*/ undefined, origin);
+            /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, origin);
         }
         /**
          * A union type which is reducible upon instantiation (meaning some members are removed under certain instantiations)
@@ -61053,7 +61083,7 @@ var ts;
                 return type;
             }
             var extractTypeAlias = getGlobalExtractSymbol();
-            return extractTypeAlias ? getGlobalTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType;
+            return extractTypeAlias ? getTypeAliasInstantiation(extractTypeAlias, [type, stringType]) : stringType;
         }
         function getIndexTypeOrString(type) {
             var indexType = getExtractStringType(getIndexType(type));
@@ -61183,14 +61213,13 @@ var ts;
             result.type = type;
             return result;
         }
-        function createIndexedAccessType(objectType, indexType, accessFlags, aliasSymbol, aliasTypeArguments, aliasMapper) {
+        function createIndexedAccessType(objectType, indexType, accessFlags, aliasSymbol, aliasTypeArguments) {
             var type = createType(8388608 /* IndexedAccess */);
             type.objectType = objectType;
             type.indexType = indexType;
             type.accessFlags = accessFlags;
             type.aliasSymbol = aliasSymbol;
             type.aliasTypeArguments = aliasTypeArguments;
-            type.aliasMapper = aliasMapper;
             return type;
         }
         /**
@@ -61548,9 +61577,9 @@ var ts;
             var templateMapper = combineTypeMappers(objectType.mapper, mapper);
             return instantiateType(getTemplateTypeFromMappedType(objectType), templateMapper);
         }
-        function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments, aliasMapper) {
+        function getIndexedAccessType(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
             if (accessFlags === void 0) { accessFlags = 0 /* None */; }
-            return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments, aliasMapper) || (accessNode ? errorType : unknownType);
+            return getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) || (accessNode ? errorType : unknownType);
         }
         function indexTypeLessThan(indexType, limit) {
             return everyType(indexType, function (t) {
@@ -61564,7 +61593,7 @@ var ts;
                 return false;
             });
         }
-        function getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments, aliasMapper) {
+        function getIndexedAccessTypeOrUndefined(objectType, indexType, accessFlags, accessNode, aliasSymbol, aliasTypeArguments) {
             if (accessFlags === void 0) { accessFlags = 0 /* None */; }
             if (objectType === wildcardType || indexType === wildcardType) {
                 return wildcardType;
@@ -61595,7 +61624,7 @@ var ts;
                 var id = objectType.id + "," + indexType.id + "," + persistentAccessFlags + getAliasId(aliasSymbol, aliasTypeArguments);
                 var type = indexedAccessTypes.get(id);
                 if (!type) {
-                    indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, persistentAccessFlags, aliasSymbol, aliasTypeArguments, aliasMapper));
+                    indexedAccessTypes.set(id, type = createIndexedAccessType(objectType, indexType, persistentAccessFlags, aliasSymbol, aliasTypeArguments));
                 }
                 return type;
             }
@@ -61625,8 +61654,8 @@ var ts;
                     return undefined;
                 }
                 return accessFlags & 4 /* Writing */
-                    ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments, aliasMapper)
-                    : getUnionType(propTypes, 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper);
+                    ? getIntersectionType(propTypes, aliasSymbol, aliasTypeArguments)
+                    : getUnionType(propTypes, 1 /* Literal */, aliasSymbol, aliasTypeArguments);
             }
             return getPropertyTypeForIndexType(objectType, apparentObjectType, indexType, indexType, accessNode, accessFlags | 8 /* CacheSymbol */ | 64 /* ReportDeprecated */);
         }
@@ -61636,7 +61665,7 @@ var ts;
                 var objectType = getTypeFromTypeNode(node.objectType);
                 var indexType = getTypeFromTypeNode(node.indexType);
                 var potentialAlias = getAliasSymbolForTypeNode(node);
-                var resolved = getIndexedAccessType(objectType, indexType, 0 /* None */, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias), /*aliasMapper*/ undefined);
+                var resolved = getIndexedAccessType(objectType, indexType, 0 /* None */, node, potentialAlias, getTypeArgumentsForAliasSymbol(potentialAlias));
                 links.resolvedType = resolved.flags & 8388608 /* IndexedAccess */ &&
                     resolved.objectType === objectType &&
                     resolved.indexType === indexType ?
@@ -61803,7 +61832,6 @@ var ts;
                 result.combinedMapper = combinedMapper;
                 result.aliasSymbol = aliasSymbol || root.aliasSymbol;
                 result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217
-                result.aliasMapper = result.aliasSymbol ? mapper : undefined;
                 return "break";
             };
             // We loop here for an immediately nested conditional type in the false position, effectively treating
@@ -62599,7 +62627,7 @@ var ts;
                 var result = target.instantiations.get(id);
                 if (!result) {
                     var newMapper = createTypeMapper(typeParameters, typeArguments);
-                    result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments, mapper) :
+                    result = target.objectFlags & 4 /* Reference */ ? createDeferredTypeReference(type.target, type.node, newMapper, newAliasSymbol, newAliasTypeArguments) :
                         target.objectFlags & 32 /* Mapped */ ? instantiateMappedType(target, newMapper, newAliasSymbol, newAliasTypeArguments) :
                             instantiateAnonymousType(target, newMapper, newAliasSymbol, newAliasTypeArguments);
                     target.instantiations.set(id, result);
@@ -62688,7 +62716,7 @@ var ts;
                             return instantiateAnonymousType(type, prependTypeMapping(typeVariable, t, mapper));
                         }
                         return t;
-                    }, aliasSymbol, aliasTypeArguments, mapper);
+                    }, aliasSymbol, aliasTypeArguments);
                 }
             }
             // If the constraint type of the instantiation is the wildcard type, return the wildcard type.
@@ -62757,7 +62785,6 @@ var ts;
             result.mapper = mapper;
             result.aliasSymbol = aliasSymbol || type.aliasSymbol;
             result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
-            result.aliasMapper = mapper;
             return result;
         }
         function getConditionalTypeInstantiation(type, mapper, aliasSymbol, aliasTypeArguments) {
@@ -62777,7 +62804,7 @@ var ts;
                     // distributive conditional type T extends U ? X : Y is instantiated with A | B for T, the
                     // result is (A extends U ? X : Y) | (B extends U ? X : Y).
                     result = distributionType && checkType_1 !== distributionType && distributionType.flags & (1048576 /* Union */ | 131072 /* Never */) ?
-                        mapTypeWithAlias(getReducedType(distributionType), function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, newMapper_1)); }, aliasSymbol, aliasTypeArguments, mapper) :
+                        mapTypeWithAlias(getReducedType(distributionType), function (t) { return getConditionalType(root, prependTypeMapping(checkType_1, t, newMapper_1)); }, aliasSymbol, aliasTypeArguments) :
                         getConditionalType(root, newMapper_1, aliasSymbol, aliasTypeArguments);
                     root.instantiations.set(id, result);
                 }
@@ -62837,8 +62864,8 @@ var ts;
                 var newAliasSymbol = aliasSymbol || type.aliasSymbol;
                 var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
                 return flags & 2097152 /* Intersection */ || origin && origin.flags & 2097152 /* Intersection */ ?
-                    getIntersectionType(newTypes, newAliasSymbol, newAliasTypeArguments, mapper) :
-                    getUnionType(newTypes, 1 /* Literal */, newAliasSymbol, newAliasTypeArguments, mapper);
+                    getIntersectionType(newTypes, newAliasSymbol, newAliasTypeArguments) :
+                    getUnionType(newTypes, 1 /* Literal */, newAliasSymbol, newAliasTypeArguments);
             }
             if (flags & 4194304 /* Index */) {
                 return getIndexType(instantiateType(type.type, mapper));
@@ -62852,7 +62879,7 @@ var ts;
             if (flags & 8388608 /* IndexedAccess */) {
                 var newAliasSymbol = aliasSymbol || type.aliasSymbol;
                 var newAliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(type.aliasTypeArguments, mapper);
-                return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.accessFlags, /*accessNode*/ undefined, newAliasSymbol, newAliasTypeArguments, mapper);
+                return getIndexedAccessType(instantiateType(type.objectType, mapper), instantiateType(type.indexType, mapper), type.accessFlags, /*accessNode*/ undefined, newAliasSymbol, newAliasTypeArguments);
             }
             if (flags & 16777216 /* Conditional */) {
                 return getConditionalTypeInstantiation(type, combineTypeMappers(type.mapper, mapper), aliasSymbol, aliasTypeArguments);
@@ -64846,10 +64873,7 @@ var ts;
                     if (variances === ts.emptyArray) {
                         return 1 /* Unknown */;
                     }
-                    var outerTypeParameters = getOuterTypeParametersOfAlias(source.aliasSymbol);
-                    var sourceArgs = outerTypeParameters && source.aliasMapper ? ts.concatenate(source.aliasTypeArguments, instantiateTypes(outerTypeParameters, source.aliasMapper)) : source.aliasTypeArguments;
-                    var targetArgs = outerTypeParameters && target.aliasMapper ? ts.concatenate(target.aliasTypeArguments, instantiateTypes(outerTypeParameters, target.aliasMapper)) : target.aliasTypeArguments;
-                    var varianceResult = relateVariances(sourceArgs, targetArgs, variances, intersectionState);
+                    var varianceResult = relateVariances(source.aliasTypeArguments, target.aliasTypeArguments, variances, intersectionState);
                     if (varianceResult !== undefined) {
                         return varianceResult;
                     }
@@ -66138,11 +66162,8 @@ var ts;
         }
         function getAliasVariances(symbol) {
             var links = getSymbolLinks(symbol);
-            // outer type parameter aliases are last so they can be easily ignored by, eg, inference
-            var params = ts.concatenate(links.typeParameters, getOuterTypeParametersOfAlias(symbol));
-            return getVariancesWorker(params, links, function (_links, param, marker) {
-                var mapper = makeUnaryTypeMapper(param, marker);
-                var type = getLocalTypeAliasInstantiation(symbol, instantiateTypes(links.typeParameters, mapper), mapper);
+            return getVariancesWorker(links.typeParameters, links, function (_links, param, marker) {
+                var type = getTypeAliasInstantiation(symbol, instantiateTypes(links.typeParameters, makeUnaryTypeMapper(param, marker)));
                 type.aliasTypeArgumentsContainsMarker = true;
                 return type;
             });
@@ -66799,7 +66820,7 @@ var ts;
             }
             // If the NonNullable<T> type is available, return an instantiation. Otherwise just return the reduced type.
             return deferredGlobalNonNullableTypeAlias !== unknownSymbol ?
-                getGlobalTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [reducedType]) :
+                getTypeAliasInstantiation(deferredGlobalNonNullableTypeAlias, [reducedType]) :
                 reducedType;
         }
         function getNonNullableType(type) {
@@ -69025,7 +69046,7 @@ var ts;
                         newOrigin = createOriginUnionOrIntersectionType(1048576 /* Union */, originFiltered);
                     }
                 }
-                return getUnionTypeFromSortedList(filtered, type.objectFlags, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, /*aliasMapper*/ undefined, newOrigin);
+                return getUnionTypeFromSortedList(filtered, type.objectFlags, /*aliasSymbol*/ undefined, /*aliasTypeArguments*/ undefined, newOrigin);
             }
             return type.flags & 131072 /* Never */ || f(type) ? type : neverType;
         }
@@ -69061,9 +69082,9 @@ var ts;
             }
             return changed ? mappedTypes && getUnionType(mappedTypes, noReductions ? 0 /* None */ : 1 /* Literal */) : type;
         }
-        function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments, aliasMapper) {
+        function mapTypeWithAlias(type, mapper, aliasSymbol, aliasTypeArguments) {
             return type.flags & 1048576 /* Union */ && aliasSymbol ?
-                getUnionType(ts.map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments, aliasMapper) :
+                getUnionType(ts.map(type.types, mapper), 1 /* Literal */, aliasSymbol, aliasTypeArguments) :
                 mapType(type, mapper);
         }
         function extractTypesOfKind(type, kind) {
@@ -72248,7 +72269,7 @@ var ts;
                     var params = getSymbolLinks(managedSym).typeParameters;
                     if (ts.length(params) >= 2) {
                         var args = fillMissingTypeArguments([ctorType, attributesType], params, 2, ts.isInJSFile(context));
-                        return getGlobalTypeAliasInstantiation(managedSym, args);
+                        return getTypeAliasInstantiation(managedSym, args);
                     }
                 }
                 if (ts.length(declaredManagedType.typeParameters) >= 2) {
@@ -80392,7 +80413,7 @@ var ts;
                     if (awaitedSymbol) {
                         // Unwrap unions that may contain `Awaited<T>`, otherwise its possible to manufacture an `Awaited<Awaited<T> | U>` where
                         // an `Awaited<T | U>` would suffice.
-                        return getGlobalTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
+                        return getTypeAliasInstantiation(awaitedSymbol, [unwrapAwaitedType(type)]);
                     }
                 }
             }

package/package.json

@@ -2,7 +2,7 @@
   "name": "@typescript-deploys/pr-build",
   "author": "Microsoft Corp.",
   "homepage": "https://www.typescriptlang.org/",
-  "version": "4.7.0-pr-48294-7",
+  "version": "4.7.0-pr-48264-4",
   "license": "Apache-2.0",
   "description": "TypeScript is a language for application scale JavaScript development",
   "keywords": [