@typescript-deploys/pr-build 4.5.0-pr-46429-36 → 4.5.0-pr-46464-7

package/lib/lib.es5.d.ts

@@ -216,13 +216,13 @@ interface ObjectConstructor {
 
     /**
      * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
-     * @param o Object on which to lock the attributes.
+     * @param a Object on which to lock the attributes.
      */
     freeze<T>(a: T[]): readonly T[];
 
     /**
      * Prevents the modification of existing property attributes and values, and prevents the addition of new properties.
-     * @param o Object on which to lock the attributes.
+     * @param f Object on which to lock the attributes.
      */
     freeze<T extends Function>(f: T): T;
 

package/lib/tsc.js

@@ -69,7 +69,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 var ts;
 (function (ts) {
     ts.versionMajorMinor = "4.5";
-    ts.version = ts.versionMajorMinor + ".0-insiders.20211021";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20211022";
     var NativeCollections;
     (function (NativeCollections) {
         function tryGetNativeMap() {
@@ -15846,7 +15846,7 @@ var ts;
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+            basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
         };
     }
     ts.getFileMatcherPatterns = getFileMatcherPatterns;
@@ -15865,20 +15865,20 @@ var ts;
         var visited = new ts.Map();
         var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
         for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
-            var basePath = _a[_i];
-            if (directoryExists(basePath)) {
-                visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth);
+            var absoluteBasePath = _a[_i];
+            if (directoryExists(absoluteBasePath)) {
+                visitDirectory(absoluteBasePath, depth);
             }
         }
         return ts.flatten(results);
-        function visitDirectory(path, absolutePath, depth) {
+        function visitDirectory(absolutePath, depth) {
             var canonicalPath = toCanonical(realpath(absolutePath));
             if (visited.has(canonicalPath))
                 return;
             visited.set(canonicalPath, true);
-            var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories;
+            var _a = getFileSystemEntries(absolutePath), files = _a.files, directories = _a.directories;
             var _loop_1 = function (current) {
-                var name = ts.combinePaths(path, current);
+                var name = ts.combinePaths(absolutePath, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if (extensions && !ts.fileExtensionIsOneOf(name, extensions))
                     return "continue";
@@ -15906,28 +15906,27 @@ var ts;
             }
             for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) {
                 var current = _d[_c];
-                var name = ts.combinePaths(path, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName, depth);
+                    visitDirectory(absoluteName, depth);
                 }
             }
         }
     }
     ts.matchFiles = matchFiles;
-    function getBasePaths(path, includes, useCaseSensitiveFileNames) {
-        var basePaths = [path];
+    function getBasePaths(absoluteTsconfigPath, includes, useCaseSensitiveFileNames) {
+        var basePaths = [absoluteTsconfigPath];
         if (includes) {
             var includeBasePaths = [];
             for (var _i = 0, includes_1 = includes; _i < includes_1.length; _i++) {
                 var include = includes_1[_i];
-                var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include));
-                includeBasePaths.push(getIncludeBasePath(absolute));
+                var absoluteIncludePath = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(absoluteTsconfigPath, include));
+                includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
             }
             includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames));
             var _loop_2 = function (includeBasePath) {
-                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) {
+                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames); })) {
                     basePaths.push(includeBasePath);
                 }
             };
@@ -50422,13 +50421,14 @@ var ts;
             }
             return result;
         }
+        function isDistributionDependent(root) {
+            return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) ||
+                isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
+        }
         function getTypeFromConditionalTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var checkType = getTypeFromTypeNode(node.checkType);
-                var isDistributive = !!(checkType.flags & 262144);
-                var isDistributionDependent = isDistributive && (isTypeParameterPossiblyReferenced(checkType, node.trueType) ||
-                    isTypeParameterPossiblyReferenced(checkType, node.falseType));
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
                 var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
                 var allOuterTypeParameters = getOuterTypeParameters(node, true);
@@ -50437,8 +50437,7 @@ var ts;
                     node: node,
                     checkType: checkType,
                     extendsType: getTypeFromTypeNode(node.extendsType),
-                    isDistributive: isDistributive,
-                    isDistributionDependent: isDistributionDependent,
+                    isDistributive: !!(checkType.flags & 262144),
                     inferTypeParameters: getInferTypeParameters(node),
                     outerTypeParameters: outerTypeParameters,
                     instantiations: undefined,
@@ -53195,7 +53194,7 @@ var ts;
                         return 3;
                     }
                     var c = target;
-                    if (!c.root.inferTypeParameters && !c.root.isDistributionDependent) {
+                    if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
                         var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
                         var skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
                         if (result = skipTrue ? -1 : isRelatedTo(source, getTrueTypeFromConditionalType(c), 2, false)) {
@@ -64651,6 +64650,7 @@ var ts;
             var parent = node.parent;
             return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) ||
                 ts.isJSDocTypeAssertion(parent) && ts.isConstTypeReference(ts.getJSDocTypeAssertionType(parent)) ||
+                ts.isComputedPropertyName(parent) ||
                 (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) ||
                 (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isTemplateSpan(parent)) && isConstContext(parent.parent);
         }

package/lib/tsserver.js

@@ -100,7 +100,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 = ts.versionMajorMinor + ".0-insiders.20211021";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20211022";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -19993,7 +19993,7 @@ var ts;
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+            basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
         };
     }
     ts.getFileMatcherPatterns = getFileMatcherPatterns;
@@ -20015,20 +20015,20 @@ var ts;
         var visited = new ts.Map();
         var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
         for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
-            var basePath = _a[_i];
-            if (directoryExists(basePath)) {
-                visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth);
+            var absoluteBasePath = _a[_i];
+            if (directoryExists(absoluteBasePath)) {
+                visitDirectory(absoluteBasePath, depth);
             }
         }
         return ts.flatten(results);
-        function visitDirectory(path, absolutePath, depth) {
+        function visitDirectory(absolutePath, depth) {
             var canonicalPath = toCanonical(realpath(absolutePath));
             if (visited.has(canonicalPath))
                 return;
             visited.set(canonicalPath, true);
-            var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories;
+            var _a = getFileSystemEntries(absolutePath), files = _a.files, directories = _a.directories;
             var _loop_1 = function (current) {
-                var name = ts.combinePaths(path, current);
+                var name = ts.combinePaths(absolutePath, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if (extensions && !ts.fileExtensionIsOneOf(name, extensions))
                     return "continue";
@@ -20056,11 +20056,10 @@ var ts;
             }
             for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) {
                 var current = _d[_c];
-                var name = ts.combinePaths(path, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName, depth);
+                    visitDirectory(absoluteName, depth);
                 }
             }
         }
@@ -20068,10 +20067,11 @@ var ts;
     ts.matchFiles = matchFiles;
     /**
      * Computes the unique non-wildcard base paths amongst the provided include patterns.
+     * @returns Absolute directory paths
      */
-    function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+    function getBasePaths(absoluteTsconfigPath, includes, useCaseSensitiveFileNames) {
         // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
-        var basePaths = [path];
+        var basePaths = [absoluteTsconfigPath];
         if (includes) {
             // Storage for literal base paths amongst the include patterns.
             var includeBasePaths = [];
@@ -20079,14 +20079,14 @@ var ts;
                 var include = includes_1[_i];
                 // We also need to check the relative paths by converting them to absolute and normalizing
                 // in case they escape the base path (e.g "..\somedirectory")
-                var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include));
+                var absoluteIncludePath = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(absoluteTsconfigPath, include));
                 // Append the literal and canonical candidate base paths.
-                includeBasePaths.push(getIncludeBasePath(absolute));
+                includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
             }
             // Sort the offsets array using either the literal or canonical path representations.
             includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames));
             var _loop_2 = function (includeBasePath) {
-                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) {
+                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames); })) {
                     basePaths.push(includeBasePath);
                 }
             };
@@ -60707,13 +60707,14 @@ var ts;
             }
             return result;
         }
+        function isDistributionDependent(root) {
+            return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) ||
+                isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
+        }
         function getTypeFromConditionalTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var checkType = getTypeFromTypeNode(node.checkType);
-                var isDistributive = !!(checkType.flags & 262144 /* TypeParameter */);
-                var isDistributionDependent = isDistributive && (isTypeParameterPossiblyReferenced(checkType, node.trueType) ||
-                    isTypeParameterPossiblyReferenced(checkType, node.falseType));
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
                 var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
                 var allOuterTypeParameters = getOuterTypeParameters(node, /*includeThisTypes*/ true);
@@ -60722,8 +60723,7 @@ var ts;
                     node: node,
                     checkType: checkType,
                     extendsType: getTypeFromTypeNode(node.extendsType),
-                    isDistributive: isDistributive,
-                    isDistributionDependent: isDistributionDependent,
+                    isDistributive: !!(checkType.flags & 262144 /* TypeParameter */),
                     inferTypeParameters: getInferTypeParameters(node),
                     outerTypeParameters: outerTypeParameters,
                     instantiations: undefined,
@@ -63870,7 +63870,7 @@ var ts;
                     // We check for a relationship to a conditional type target only when the conditional type has no
                     // 'infer' positions and is not distributive or is distributive but doesn't reference the check type
                     // parameter in either of the result types.
-                    if (!c.root.inferTypeParameters && !c.root.isDistributionDependent) {
+                    if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
                         // Check if the conditional is always true or always false but still deferred for distribution purposes.
                         var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
                         var skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
@@ -77164,6 +77164,7 @@ var ts;
             var parent = node.parent;
             return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) ||
                 ts.isJSDocTypeAssertion(parent) && ts.isConstTypeReference(ts.getJSDocTypeAssertionType(parent)) ||
+                ts.isComputedPropertyName(parent) ||
                 (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) ||
                 (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isTemplateSpan(parent)) && isConstContext(parent.parent);
         }
@@ -148204,12 +148205,14 @@ var ts;
             }
             var allowsImportingSpecifier = ts.createPackageJsonImportFilter(sourceFile, preferences, host).allowsImportingSpecifier;
             return fixes.reduce(function (best, fix) {
+                // Takes true branch of conditional if `fix` is better than `best`
                 return compareModuleSpecifiers(fix, best, sourceFile, program, allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best;
             });
         }
+        /** @returns `Comparison.LessThan` if `a` is better than `b`. */
         function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier) {
             if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
-                return ts.compareBooleans(allowsImportingSpecifier(a.moduleSpecifier), allowsImportingSpecifier(b.moduleSpecifier))
+                return ts.compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier))
                     || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program)
                     || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
             }
@@ -150861,7 +150864,8 @@ var ts;
                     insertBefore = ts.findChildOfKind(containingFunction, 98 /* FunctionKeyword */, sourceFile);
                     break;
                 case 213 /* ArrowFunction */:
-                    insertBefore = ts.findChildOfKind(containingFunction, 20 /* OpenParenToken */, sourceFile) || ts.first(containingFunction.parameters);
+                    var kind = containingFunction.typeParameters ? 29 /* LessThanToken */ : 20 /* OpenParenToken */;
+                    insertBefore = ts.findChildOfKind(containingFunction, kind, sourceFile) || ts.first(containingFunction.parameters);
                     break;
                 default:
                     return;

package/lib/tsserverlibrary.d.ts

@@ -2747,7 +2747,6 @@ declare namespace ts {
         checkType: Type;
         extendsType: Type;
         isDistributive: boolean;
-        isDistributionDependent: boolean;
         inferTypeParameters?: TypeParameter[];
         outerTypeParameters?: TypeParameter[];
         instantiations?: Map<Type>;

package/lib/tsserverlibrary.js

@@ -294,7 +294,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 = ts.versionMajorMinor + ".0-insiders.20211021";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20211022";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -20187,7 +20187,7 @@ var ts;
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+            basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
         };
     }
     ts.getFileMatcherPatterns = getFileMatcherPatterns;
@@ -20209,20 +20209,20 @@ var ts;
         var visited = new ts.Map();
         var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
         for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
-            var basePath = _a[_i];
-            if (directoryExists(basePath)) {
-                visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth);
+            var absoluteBasePath = _a[_i];
+            if (directoryExists(absoluteBasePath)) {
+                visitDirectory(absoluteBasePath, depth);
             }
         }
         return ts.flatten(results);
-        function visitDirectory(path, absolutePath, depth) {
+        function visitDirectory(absolutePath, depth) {
             var canonicalPath = toCanonical(realpath(absolutePath));
             if (visited.has(canonicalPath))
                 return;
             visited.set(canonicalPath, true);
-            var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories;
+            var _a = getFileSystemEntries(absolutePath), files = _a.files, directories = _a.directories;
             var _loop_1 = function (current) {
-                var name = ts.combinePaths(path, current);
+                var name = ts.combinePaths(absolutePath, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if (extensions && !ts.fileExtensionIsOneOf(name, extensions))
                     return "continue";
@@ -20250,11 +20250,10 @@ var ts;
             }
             for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) {
                 var current = _d[_c];
-                var name = ts.combinePaths(path, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName, depth);
+                    visitDirectory(absoluteName, depth);
                 }
             }
         }
@@ -20262,10 +20261,11 @@ var ts;
     ts.matchFiles = matchFiles;
     /**
      * Computes the unique non-wildcard base paths amongst the provided include patterns.
+     * @returns Absolute directory paths
      */
-    function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+    function getBasePaths(absoluteTsconfigPath, includes, useCaseSensitiveFileNames) {
         // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
-        var basePaths = [path];
+        var basePaths = [absoluteTsconfigPath];
         if (includes) {
             // Storage for literal base paths amongst the include patterns.
             var includeBasePaths = [];
@@ -20273,14 +20273,14 @@ var ts;
                 var include = includes_1[_i];
                 // We also need to check the relative paths by converting them to absolute and normalizing
                 // in case they escape the base path (e.g "..\somedirectory")
-                var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include));
+                var absoluteIncludePath = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(absoluteTsconfigPath, include));
                 // Append the literal and canonical candidate base paths.
-                includeBasePaths.push(getIncludeBasePath(absolute));
+                includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
             }
             // Sort the offsets array using either the literal or canonical path representations.
             includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames));
             var _loop_2 = function (includeBasePath) {
-                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) {
+                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames); })) {
                     basePaths.push(includeBasePath);
                 }
             };
@@ -60901,13 +60901,14 @@ var ts;
             }
             return result;
         }
+        function isDistributionDependent(root) {
+            return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) ||
+                isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
+        }
         function getTypeFromConditionalTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var checkType = getTypeFromTypeNode(node.checkType);
-                var isDistributive = !!(checkType.flags & 262144 /* TypeParameter */);
-                var isDistributionDependent = isDistributive && (isTypeParameterPossiblyReferenced(checkType, node.trueType) ||
-                    isTypeParameterPossiblyReferenced(checkType, node.falseType));
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
                 var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
                 var allOuterTypeParameters = getOuterTypeParameters(node, /*includeThisTypes*/ true);
@@ -60916,8 +60917,7 @@ var ts;
                     node: node,
                     checkType: checkType,
                     extendsType: getTypeFromTypeNode(node.extendsType),
-                    isDistributive: isDistributive,
-                    isDistributionDependent: isDistributionDependent,
+                    isDistributive: !!(checkType.flags & 262144 /* TypeParameter */),
                     inferTypeParameters: getInferTypeParameters(node),
                     outerTypeParameters: outerTypeParameters,
                     instantiations: undefined,
@@ -64064,7 +64064,7 @@ var ts;
                     // We check for a relationship to a conditional type target only when the conditional type has no
                     // 'infer' positions and is not distributive or is distributive but doesn't reference the check type
                     // parameter in either of the result types.
-                    if (!c.root.inferTypeParameters && !c.root.isDistributionDependent) {
+                    if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
                         // Check if the conditional is always true or always false but still deferred for distribution purposes.
                         var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
                         var skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
@@ -77358,6 +77358,7 @@ var ts;
             var parent = node.parent;
             return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) ||
                 ts.isJSDocTypeAssertion(parent) && ts.isConstTypeReference(ts.getJSDocTypeAssertionType(parent)) ||
+                ts.isComputedPropertyName(parent) ||
                 (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) ||
                 (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isTemplateSpan(parent)) && isConstContext(parent.parent);
         }
@@ -148786,12 +148787,14 @@ var ts;
             }
             var allowsImportingSpecifier = ts.createPackageJsonImportFilter(sourceFile, preferences, host).allowsImportingSpecifier;
             return fixes.reduce(function (best, fix) {
+                // Takes true branch of conditional if `fix` is better than `best`
                 return compareModuleSpecifiers(fix, best, sourceFile, program, allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best;
             });
         }
+        /** @returns `Comparison.LessThan` if `a` is better than `b`. */
         function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier) {
             if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
-                return ts.compareBooleans(allowsImportingSpecifier(a.moduleSpecifier), allowsImportingSpecifier(b.moduleSpecifier))
+                return ts.compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier))
                     || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program)
                     || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
             }
@@ -151443,7 +151446,8 @@ var ts;
                     insertBefore = ts.findChildOfKind(containingFunction, 98 /* FunctionKeyword */, sourceFile);
                     break;
                 case 213 /* ArrowFunction */:
-                    insertBefore = ts.findChildOfKind(containingFunction, 20 /* OpenParenToken */, sourceFile) || ts.first(containingFunction.parameters);
+                    var kind = containingFunction.typeParameters ? 29 /* LessThanToken */ : 20 /* OpenParenToken */;
+                    insertBefore = ts.findChildOfKind(containingFunction, kind, sourceFile) || ts.first(containingFunction.parameters);
                     break;
                 default:
                     return;

package/lib/typescript.d.ts

@@ -2747,7 +2747,6 @@ declare namespace ts {
         checkType: Type;
         extendsType: Type;
         isDistributive: boolean;
-        isDistributionDependent: boolean;
         inferTypeParameters?: TypeParameter[];
         outerTypeParameters?: TypeParameter[];
         instantiations?: Map<Type>;

package/lib/typescript.js

@@ -294,7 +294,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 = ts.versionMajorMinor + ".0-insiders.20211021";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20211022";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -20187,7 +20187,7 @@ var ts;
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+            basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
         };
     }
     ts.getFileMatcherPatterns = getFileMatcherPatterns;
@@ -20209,20 +20209,20 @@ var ts;
         var visited = new ts.Map();
         var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
         for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
-            var basePath = _a[_i];
-            if (directoryExists(basePath)) {
-                visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth);
+            var absoluteBasePath = _a[_i];
+            if (directoryExists(absoluteBasePath)) {
+                visitDirectory(absoluteBasePath, depth);
             }
         }
         return ts.flatten(results);
-        function visitDirectory(path, absolutePath, depth) {
+        function visitDirectory(absolutePath, depth) {
             var canonicalPath = toCanonical(realpath(absolutePath));
             if (visited.has(canonicalPath))
                 return;
             visited.set(canonicalPath, true);
-            var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories;
+            var _a = getFileSystemEntries(absolutePath), files = _a.files, directories = _a.directories;
             var _loop_1 = function (current) {
-                var name = ts.combinePaths(path, current);
+                var name = ts.combinePaths(absolutePath, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if (extensions && !ts.fileExtensionIsOneOf(name, extensions))
                     return "continue";
@@ -20250,11 +20250,10 @@ var ts;
             }
             for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) {
                 var current = _d[_c];
-                var name = ts.combinePaths(path, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName, depth);
+                    visitDirectory(absoluteName, depth);
                 }
             }
         }
@@ -20262,10 +20261,11 @@ var ts;
     ts.matchFiles = matchFiles;
     /**
      * Computes the unique non-wildcard base paths amongst the provided include patterns.
+     * @returns Absolute directory paths
      */
-    function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+    function getBasePaths(absoluteTsconfigPath, includes, useCaseSensitiveFileNames) {
         // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
-        var basePaths = [path];
+        var basePaths = [absoluteTsconfigPath];
         if (includes) {
             // Storage for literal base paths amongst the include patterns.
             var includeBasePaths = [];
@@ -20273,14 +20273,14 @@ var ts;
                 var include = includes_1[_i];
                 // We also need to check the relative paths by converting them to absolute and normalizing
                 // in case they escape the base path (e.g "..\somedirectory")
-                var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include));
+                var absoluteIncludePath = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(absoluteTsconfigPath, include));
                 // Append the literal and canonical candidate base paths.
-                includeBasePaths.push(getIncludeBasePath(absolute));
+                includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
             }
             // Sort the offsets array using either the literal or canonical path representations.
             includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames));
             var _loop_2 = function (includeBasePath) {
-                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) {
+                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames); })) {
                     basePaths.push(includeBasePath);
                 }
             };
@@ -60901,13 +60901,14 @@ var ts;
             }
             return result;
         }
+        function isDistributionDependent(root) {
+            return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) ||
+                isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
+        }
         function getTypeFromConditionalTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var checkType = getTypeFromTypeNode(node.checkType);
-                var isDistributive = !!(checkType.flags & 262144 /* TypeParameter */);
-                var isDistributionDependent = isDistributive && (isTypeParameterPossiblyReferenced(checkType, node.trueType) ||
-                    isTypeParameterPossiblyReferenced(checkType, node.falseType));
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
                 var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
                 var allOuterTypeParameters = getOuterTypeParameters(node, /*includeThisTypes*/ true);
@@ -60916,8 +60917,7 @@ var ts;
                     node: node,
                     checkType: checkType,
                     extendsType: getTypeFromTypeNode(node.extendsType),
-                    isDistributive: isDistributive,
-                    isDistributionDependent: isDistributionDependent,
+                    isDistributive: !!(checkType.flags & 262144 /* TypeParameter */),
                     inferTypeParameters: getInferTypeParameters(node),
                     outerTypeParameters: outerTypeParameters,
                     instantiations: undefined,
@@ -64064,7 +64064,7 @@ var ts;
                     // We check for a relationship to a conditional type target only when the conditional type has no
                     // 'infer' positions and is not distributive or is distributive but doesn't reference the check type
                     // parameter in either of the result types.
-                    if (!c.root.inferTypeParameters && !c.root.isDistributionDependent) {
+                    if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
                         // Check if the conditional is always true or always false but still deferred for distribution purposes.
                         var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
                         var skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
@@ -77358,6 +77358,7 @@ var ts;
             var parent = node.parent;
             return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) ||
                 ts.isJSDocTypeAssertion(parent) && ts.isConstTypeReference(ts.getJSDocTypeAssertionType(parent)) ||
+                ts.isComputedPropertyName(parent) ||
                 (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) ||
                 (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isTemplateSpan(parent)) && isConstContext(parent.parent);
         }
@@ -148786,12 +148787,14 @@ var ts;
             }
             var allowsImportingSpecifier = ts.createPackageJsonImportFilter(sourceFile, preferences, host).allowsImportingSpecifier;
             return fixes.reduce(function (best, fix) {
+                // Takes true branch of conditional if `fix` is better than `best`
                 return compareModuleSpecifiers(fix, best, sourceFile, program, allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best;
             });
         }
+        /** @returns `Comparison.LessThan` if `a` is better than `b`. */
         function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier) {
             if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
-                return ts.compareBooleans(allowsImportingSpecifier(a.moduleSpecifier), allowsImportingSpecifier(b.moduleSpecifier))
+                return ts.compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier))
                     || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program)
                     || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
             }
@@ -151443,7 +151446,8 @@ var ts;
                     insertBefore = ts.findChildOfKind(containingFunction, 98 /* FunctionKeyword */, sourceFile);
                     break;
                 case 213 /* ArrowFunction */:
-                    insertBefore = ts.findChildOfKind(containingFunction, 20 /* OpenParenToken */, sourceFile) || ts.first(containingFunction.parameters);
+                    var kind = containingFunction.typeParameters ? 29 /* LessThanToken */ : 20 /* OpenParenToken */;
+                    insertBefore = ts.findChildOfKind(containingFunction, kind, sourceFile) || ts.first(containingFunction.parameters);
                     break;
                 default:
                     return;

package/lib/typescriptServices.d.ts

@@ -2747,7 +2747,6 @@ declare namespace ts {
         checkType: Type;
         extendsType: Type;
         isDistributive: boolean;
-        isDistributionDependent: boolean;
         inferTypeParameters?: TypeParameter[];
         outerTypeParameters?: TypeParameter[];
         instantiations?: Map<Type>;

package/lib/typescriptServices.js

@@ -294,7 +294,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 = ts.versionMajorMinor + ".0-insiders.20211021";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20211022";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -20187,7 +20187,7 @@ var ts;
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+            basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
         };
     }
     ts.getFileMatcherPatterns = getFileMatcherPatterns;
@@ -20209,20 +20209,20 @@ var ts;
         var visited = new ts.Map();
         var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
         for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
-            var basePath = _a[_i];
-            if (directoryExists(basePath)) {
-                visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth);
+            var absoluteBasePath = _a[_i];
+            if (directoryExists(absoluteBasePath)) {
+                visitDirectory(absoluteBasePath, depth);
             }
         }
         return ts.flatten(results);
-        function visitDirectory(path, absolutePath, depth) {
+        function visitDirectory(absolutePath, depth) {
             var canonicalPath = toCanonical(realpath(absolutePath));
             if (visited.has(canonicalPath))
                 return;
             visited.set(canonicalPath, true);
-            var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories;
+            var _a = getFileSystemEntries(absolutePath), files = _a.files, directories = _a.directories;
             var _loop_1 = function (current) {
-                var name = ts.combinePaths(path, current);
+                var name = ts.combinePaths(absolutePath, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if (extensions && !ts.fileExtensionIsOneOf(name, extensions))
                     return "continue";
@@ -20250,11 +20250,10 @@ var ts;
             }
             for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) {
                 var current = _d[_c];
-                var name = ts.combinePaths(path, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName, depth);
+                    visitDirectory(absoluteName, depth);
                 }
             }
         }
@@ -20262,10 +20261,11 @@ var ts;
     ts.matchFiles = matchFiles;
     /**
      * Computes the unique non-wildcard base paths amongst the provided include patterns.
+     * @returns Absolute directory paths
      */
-    function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+    function getBasePaths(absoluteTsconfigPath, includes, useCaseSensitiveFileNames) {
         // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
-        var basePaths = [path];
+        var basePaths = [absoluteTsconfigPath];
         if (includes) {
             // Storage for literal base paths amongst the include patterns.
             var includeBasePaths = [];
@@ -20273,14 +20273,14 @@ var ts;
                 var include = includes_1[_i];
                 // We also need to check the relative paths by converting them to absolute and normalizing
                 // in case they escape the base path (e.g "..\somedirectory")
-                var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include));
+                var absoluteIncludePath = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(absoluteTsconfigPath, include));
                 // Append the literal and canonical candidate base paths.
-                includeBasePaths.push(getIncludeBasePath(absolute));
+                includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
             }
             // Sort the offsets array using either the literal or canonical path representations.
             includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames));
             var _loop_2 = function (includeBasePath) {
-                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) {
+                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames); })) {
                     basePaths.push(includeBasePath);
                 }
             };
@@ -60901,13 +60901,14 @@ var ts;
             }
             return result;
         }
+        function isDistributionDependent(root) {
+            return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) ||
+                isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
+        }
         function getTypeFromConditionalTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var checkType = getTypeFromTypeNode(node.checkType);
-                var isDistributive = !!(checkType.flags & 262144 /* TypeParameter */);
-                var isDistributionDependent = isDistributive && (isTypeParameterPossiblyReferenced(checkType, node.trueType) ||
-                    isTypeParameterPossiblyReferenced(checkType, node.falseType));
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
                 var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
                 var allOuterTypeParameters = getOuterTypeParameters(node, /*includeThisTypes*/ true);
@@ -60916,8 +60917,7 @@ var ts;
                     node: node,
                     checkType: checkType,
                     extendsType: getTypeFromTypeNode(node.extendsType),
-                    isDistributive: isDistributive,
-                    isDistributionDependent: isDistributionDependent,
+                    isDistributive: !!(checkType.flags & 262144 /* TypeParameter */),
                     inferTypeParameters: getInferTypeParameters(node),
                     outerTypeParameters: outerTypeParameters,
                     instantiations: undefined,
@@ -64064,7 +64064,7 @@ var ts;
                     // We check for a relationship to a conditional type target only when the conditional type has no
                     // 'infer' positions and is not distributive or is distributive but doesn't reference the check type
                     // parameter in either of the result types.
-                    if (!c.root.inferTypeParameters && !c.root.isDistributionDependent) {
+                    if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
                         // Check if the conditional is always true or always false but still deferred for distribution purposes.
                         var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
                         var skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
@@ -77358,6 +77358,7 @@ var ts;
             var parent = node.parent;
             return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) ||
                 ts.isJSDocTypeAssertion(parent) && ts.isConstTypeReference(ts.getJSDocTypeAssertionType(parent)) ||
+                ts.isComputedPropertyName(parent) ||
                 (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) ||
                 (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isTemplateSpan(parent)) && isConstContext(parent.parent);
         }
@@ -148786,12 +148787,14 @@ var ts;
             }
             var allowsImportingSpecifier = ts.createPackageJsonImportFilter(sourceFile, preferences, host).allowsImportingSpecifier;
             return fixes.reduce(function (best, fix) {
+                // Takes true branch of conditional if `fix` is better than `best`
                 return compareModuleSpecifiers(fix, best, sourceFile, program, allowsImportingSpecifier) === -1 /* LessThan */ ? fix : best;
             });
         }
+        /** @returns `Comparison.LessThan` if `a` is better than `b`. */
         function compareModuleSpecifiers(a, b, importingFile, program, allowsImportingSpecifier) {
             if (a.kind !== 0 /* UseNamespace */ && b.kind !== 0 /* UseNamespace */) {
-                return ts.compareBooleans(allowsImportingSpecifier(a.moduleSpecifier), allowsImportingSpecifier(b.moduleSpecifier))
+                return ts.compareBooleans(allowsImportingSpecifier(b.moduleSpecifier), allowsImportingSpecifier(a.moduleSpecifier))
                     || compareNodeCoreModuleSpecifiers(a.moduleSpecifier, b.moduleSpecifier, importingFile, program)
                     || ts.compareNumberOfDirectorySeparators(a.moduleSpecifier, b.moduleSpecifier);
             }
@@ -151443,7 +151446,8 @@ var ts;
                     insertBefore = ts.findChildOfKind(containingFunction, 98 /* FunctionKeyword */, sourceFile);
                     break;
                 case 213 /* ArrowFunction */:
-                    insertBefore = ts.findChildOfKind(containingFunction, 20 /* OpenParenToken */, sourceFile) || ts.first(containingFunction.parameters);
+                    var kind = containingFunction.typeParameters ? 29 /* LessThanToken */ : 20 /* OpenParenToken */;
+                    insertBefore = ts.findChildOfKind(containingFunction, kind, sourceFile) || ts.first(containingFunction.parameters);
                     break;
                 default:
                     return;

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 = ts.versionMajorMinor + ".0-insiders.20211021";
+    ts.version = ts.versionMajorMinor + ".0-insiders.20211022";
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -19982,7 +19982,7 @@ var ts;
             includeFilePattern: getRegularExpressionForWildcard(includes, absolutePath, "files"),
             includeDirectoryPattern: getRegularExpressionForWildcard(includes, absolutePath, "directories"),
             excludePattern: getRegularExpressionForWildcard(excludes, absolutePath, "exclude"),
-            basePaths: getBasePaths(path, includes, useCaseSensitiveFileNames)
+            basePaths: getBasePaths(absolutePath, includes, useCaseSensitiveFileNames)
         };
     }
     ts.getFileMatcherPatterns = getFileMatcherPatterns;
@@ -20004,20 +20004,20 @@ var ts;
         var visited = new ts.Map();
         var toCanonical = ts.createGetCanonicalFileName(useCaseSensitiveFileNames);
         for (var _i = 0, _a = patterns.basePaths; _i < _a.length; _i++) {
-            var basePath = _a[_i];
-            if (directoryExists(basePath)) {
-                visitDirectory(basePath, ts.combinePaths(currentDirectory, basePath), depth);
+            var absoluteBasePath = _a[_i];
+            if (directoryExists(absoluteBasePath)) {
+                visitDirectory(absoluteBasePath, depth);
             }
         }
         return ts.flatten(results);
-        function visitDirectory(path, absolutePath, depth) {
+        function visitDirectory(absolutePath, depth) {
             var canonicalPath = toCanonical(realpath(absolutePath));
             if (visited.has(canonicalPath))
                 return;
             visited.set(canonicalPath, true);
-            var _a = getFileSystemEntries(path), files = _a.files, directories = _a.directories;
+            var _a = getFileSystemEntries(absolutePath), files = _a.files, directories = _a.directories;
             var _loop_1 = function (current) {
-                var name = ts.combinePaths(path, current);
+                var name = ts.combinePaths(absolutePath, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if (extensions && !ts.fileExtensionIsOneOf(name, extensions))
                     return "continue";
@@ -20045,11 +20045,10 @@ var ts;
             }
             for (var _c = 0, _d = ts.sort(directories, ts.compareStringsCaseSensitive); _c < _d.length; _c++) {
                 var current = _d[_c];
-                var name = ts.combinePaths(path, current);
                 var absoluteName = ts.combinePaths(absolutePath, current);
                 if ((!includeDirectoryRegex || includeDirectoryRegex.test(absoluteName)) &&
                     (!excludeRegex || !excludeRegex.test(absoluteName))) {
-                    visitDirectory(name, absoluteName, depth);
+                    visitDirectory(absoluteName, depth);
                 }
             }
         }
@@ -20057,10 +20056,11 @@ var ts;
     ts.matchFiles = matchFiles;
     /**
      * Computes the unique non-wildcard base paths amongst the provided include patterns.
+     * @returns Absolute directory paths
      */
-    function getBasePaths(path, includes, useCaseSensitiveFileNames) {
+    function getBasePaths(absoluteTsconfigPath, includes, useCaseSensitiveFileNames) {
         // Storage for our results in the form of literal paths (e.g. the paths as written by the user).
-        var basePaths = [path];
+        var basePaths = [absoluteTsconfigPath];
         if (includes) {
             // Storage for literal base paths amongst the include patterns.
             var includeBasePaths = [];
@@ -20068,14 +20068,14 @@ var ts;
                 var include = includes_1[_i];
                 // We also need to check the relative paths by converting them to absolute and normalizing
                 // in case they escape the base path (e.g "..\somedirectory")
-                var absolute = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(path, include));
+                var absoluteIncludePath = ts.isRootedDiskPath(include) ? include : ts.normalizePath(ts.combinePaths(absoluteTsconfigPath, include));
                 // Append the literal and canonical candidate base paths.
-                includeBasePaths.push(getIncludeBasePath(absolute));
+                includeBasePaths.push(getIncludeBasePath(absoluteIncludePath));
             }
             // Sort the offsets array using either the literal or canonical path representations.
             includeBasePaths.sort(ts.getStringComparer(!useCaseSensitiveFileNames));
             var _loop_2 = function (includeBasePath) {
-                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, path, !useCaseSensitiveFileNames); })) {
+                if (ts.every(basePaths, function (basePath) { return !ts.containsPath(basePath, includeBasePath, absoluteTsconfigPath, !useCaseSensitiveFileNames); })) {
                     basePaths.push(includeBasePath);
                 }
             };
@@ -60696,13 +60696,14 @@ var ts;
             }
             return result;
         }
+        function isDistributionDependent(root) {
+            return root.isDistributive && (isTypeParameterPossiblyReferenced(root.checkType, root.node.trueType) ||
+                isTypeParameterPossiblyReferenced(root.checkType, root.node.falseType));
+        }
         function getTypeFromConditionalTypeNode(node) {
             var links = getNodeLinks(node);
             if (!links.resolvedType) {
                 var checkType = getTypeFromTypeNode(node.checkType);
-                var isDistributive = !!(checkType.flags & 262144 /* TypeParameter */);
-                var isDistributionDependent = isDistributive && (isTypeParameterPossiblyReferenced(checkType, node.trueType) ||
-                    isTypeParameterPossiblyReferenced(checkType, node.falseType));
                 var aliasSymbol = getAliasSymbolForTypeNode(node);
                 var aliasTypeArguments = getTypeArgumentsForAliasSymbol(aliasSymbol);
                 var allOuterTypeParameters = getOuterTypeParameters(node, /*includeThisTypes*/ true);
@@ -60711,8 +60712,7 @@ var ts;
                     node: node,
                     checkType: checkType,
                     extendsType: getTypeFromTypeNode(node.extendsType),
-                    isDistributive: isDistributive,
-                    isDistributionDependent: isDistributionDependent,
+                    isDistributive: !!(checkType.flags & 262144 /* TypeParameter */),
                     inferTypeParameters: getInferTypeParameters(node),
                     outerTypeParameters: outerTypeParameters,
                     instantiations: undefined,
@@ -63859,7 +63859,7 @@ var ts;
                     // We check for a relationship to a conditional type target only when the conditional type has no
                     // 'infer' positions and is not distributive or is distributive but doesn't reference the check type
                     // parameter in either of the result types.
-                    if (!c.root.inferTypeParameters && !c.root.isDistributionDependent) {
+                    if (!c.root.inferTypeParameters && !isDistributionDependent(c.root)) {
                         // Check if the conditional is always true or always false but still deferred for distribution purposes.
                         var skipTrue = !isTypeAssignableTo(getPermissiveInstantiation(c.checkType), getPermissiveInstantiation(c.extendsType));
                         var skipFalse = !skipTrue && isTypeAssignableTo(getRestrictiveInstantiation(c.checkType), getRestrictiveInstantiation(c.extendsType));
@@ -77153,6 +77153,7 @@ var ts;
             var parent = node.parent;
             return ts.isAssertionExpression(parent) && ts.isConstTypeReference(parent.type) ||
                 ts.isJSDocTypeAssertion(parent) && ts.isConstTypeReference(ts.getJSDocTypeAssertionType(parent)) ||
+                ts.isComputedPropertyName(parent) ||
                 (ts.isParenthesizedExpression(parent) || ts.isArrayLiteralExpression(parent) || ts.isSpreadElement(parent)) && isConstContext(parent) ||
                 (ts.isPropertyAssignment(parent) || ts.isShorthandPropertyAssignment(parent) || ts.isTemplateSpan(parent)) && isConstContext(parent.parent);
         }

package/package.json

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