typescript 4.9.0-dev.20221021 → 4.9.0-dev.20221023

package/lib/typescript.js

@@ -99,7 +99,7 @@ var ts;
     // The following is baselined as a literal template type without intervention
     /** The version of the TypeScript compiler release */
     // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221021");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221023");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -1891,8 +1891,8 @@ var ts;
         return compareValues(a === null || a === void 0 ? void 0 : a.start, b === null || b === void 0 ? void 0 : b.start) || compareValues(a === null || a === void 0 ? void 0 : a.length, b === null || b === void 0 ? void 0 : b.length);
     }
     ts.compareTextSpans = compareTextSpans;
-    function min(a, b, compare) {
-        return compare(a, b) === -1 /* Comparison.LessThan */ ? a : b;
+    function min(items, compare) {
+        return reduceLeft(items, function (x, y) { return compare(x, y) === -1 /* Comparison.LessThan */ ? x : y; });
     }
     ts.min = min;
     /**
@@ -5109,8 +5109,8 @@ var ts;
         NodeCheckFlags[NodeCheckFlags["SuperInstance"] = 256] = "SuperInstance";
         NodeCheckFlags[NodeCheckFlags["SuperStatic"] = 512] = "SuperStatic";
         NodeCheckFlags[NodeCheckFlags["ContextChecked"] = 1024] = "ContextChecked";
-        NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuper"] = 2048] = "AsyncMethodWithSuper";
-        NodeCheckFlags[NodeCheckFlags["AsyncMethodWithSuperBinding"] = 4096] = "AsyncMethodWithSuperBinding";
+        NodeCheckFlags[NodeCheckFlags["MethodWithSuperPropertyAccessInAsync"] = 2048] = "MethodWithSuperPropertyAccessInAsync";
+        NodeCheckFlags[NodeCheckFlags["MethodWithSuperPropertyAssignmentInAsync"] = 4096] = "MethodWithSuperPropertyAssignmentInAsync";
         NodeCheckFlags[NodeCheckFlags["CaptureArguments"] = 8192] = "CaptureArguments";
         NodeCheckFlags[NodeCheckFlags["EnumValuesComputed"] = 16384] = "EnumValuesComputed";
         NodeCheckFlags[NodeCheckFlags["LexicalModuleMergesWithClass"] = 32768] = "LexicalModuleMergesWithClass";
@@ -63312,7 +63312,7 @@ var ts;
                     type.flags & 134217728 /* TypeFlags.TemplateLiteral */ ? getTemplateLiteralType.apply(void 0, applyTemplateStringMapping(symbol, type.texts, type.types)) :
                         // Mapping<Mapping<T>> === Mapping<T>
                         type.flags & 268435456 /* TypeFlags.StringMapping */ && symbol === type.symbol ? type :
-                            type.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */ || type.flags & 268435456 /* TypeFlags.StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) :
+                            type.flags & (1 /* TypeFlags.Any */ | 4 /* TypeFlags.String */ | 268435456 /* TypeFlags.StringMapping */) || isGenericIndexType(type) ? getStringMappingTypeForGenericType(symbol, type) :
                                 // This handles Mapping<`${number}`> and Mapping<`${bigint}`>
                                 isPatternLiteralPlaceholderType(type) ? getStringMappingTypeForGenericType(symbol, getTemplateLiteralType(["", ""], [type])) :
                                     type;
@@ -73675,12 +73675,17 @@ var ts;
             var immediateContainer = ts.getSuperContainer(node, /*stopOnFunctions*/ true);
             var container = immediateContainer;
             var needToCaptureLexicalThis = false;
+            var inAsyncFunction = false;
             // adjust the container reference in case if super is used inside arrow functions with arbitrarily deep nesting
             if (!isCallExpression) {
                 while (container && container.kind === 216 /* SyntaxKind.ArrowFunction */) {
+                    if (ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */))
+                        inAsyncFunction = true;
                     container = ts.getSuperContainer(container, /*stopOnFunctions*/ true);
                     needToCaptureLexicalThis = languageVersion < 2 /* ScriptTarget.ES2015 */;
                 }
+                if (container && ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */))
+                    inAsyncFunction = true;
             }
             var canUseSuperExpression = isLegalUsageOfSuperExpression(container);
             var nodeCheckFlag = 0;
@@ -73786,12 +73791,12 @@ var ts;
             // as a call expression cannot be used as the target of a destructuring assignment while a property access can.
             //
             // For element access expressions (`super[x]`), we emit a generic helper that forwards the element access in both situations.
-            if (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && ts.hasSyntacticModifier(container, 512 /* ModifierFlags.Async */)) {
+            if (container.kind === 171 /* SyntaxKind.MethodDeclaration */ && inAsyncFunction) {
                 if (ts.isSuperProperty(node.parent) && ts.isAssignmentTarget(node.parent)) {
-                    getNodeLinks(container).flags |= 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */;
+                    getNodeLinks(container).flags |= 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */;
                 }
                 else {
-                    getNodeLinks(container).flags |= 2048 /* NodeCheckFlags.AsyncMethodWithSuper */;
+                    getNodeLinks(container).flags |= 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */;
                 }
             }
             if (needToCaptureLexicalThis) {
@@ -82947,7 +82952,7 @@ var ts;
                 return typeAsPromise.promisedTypeOfPromise = getTypeArguments(type)[0];
             }
             // primitives with a `{ then() }` won't be unwrapped/adopted.
-            if (allTypesAssignableToKind(type, 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
+            if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
                 return undefined;
             }
             var thenFunction = getTypeOfPropertyOfType(type, "then"); // TODO: GH#18217
@@ -83014,7 +83019,7 @@ var ts;
          * Determines whether a type is an object with a callable `then` member.
          */
         function isThenableType(type) {
-            if (allTypesAssignableToKind(type, 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
+            if (allTypesAssignableToKind(getBaseConstraintOrType(type), 131068 /* TypeFlags.Primitive */ | 131072 /* TypeFlags.Never */)) {
                 // primitive types cannot be considered "thenable" since they are not objects.
                 return false;
             }
@@ -98513,8 +98518,11 @@ var ts;
                     }
                     return ts.visitEachChild(node, visitor, context);
                 case 174 /* SyntaxKind.GetAccessor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitGetAccessorDeclaration, node);
                 case 175 /* SyntaxKind.SetAccessor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitSetAccessorDeclaration, node);
                 case 173 /* SyntaxKind.Constructor */:
+                    return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitConstructorDeclaration, node);
                 case 260 /* SyntaxKind.ClassDeclaration */:
                 case 228 /* SyntaxKind.ClassExpression */:
                     return doWithContext(1 /* ContextFlags.NonTopLevel */ | 2 /* ContextFlags.HasLexicalThis */, visitDefault, node);
@@ -98615,6 +98623,9 @@ var ts;
             return ts.setOriginalNode(ts.setTextRange(factory.createYieldExpression(
             /*asteriskToken*/ undefined, ts.visitNode(node.expression, visitor, ts.isExpression)), node), node);
         }
+        function visitConstructorDeclaration(node) {
+            return factory.updateConstructorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), ts.visitParameterList(node.parameters, visitor, context), transformMethodBody(node));
+        }
         /**
          * Visits a MethodDeclaration node.
          *
@@ -98629,7 +98640,14 @@ var ts;
             /*typeParameters*/ undefined, ts.visitParameterList(node.parameters, visitor, context), 
             /*type*/ undefined, ts.getFunctionFlags(node) & 2 /* FunctionFlags.Async */
                 ? transformAsyncFunctionBody(node)
-                : ts.visitFunctionBody(node.body, visitor, context));
+                : transformMethodBody(node));
+        }
+        function visitGetAccessorDeclaration(node) {
+            return factory.updateGetAccessorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, ts.visitParameterList(node.parameters, visitor, context), 
+            /*type*/ undefined, transformMethodBody(node));
+        }
+        function visitSetAccessorDeclaration(node) {
+            return factory.updateSetAccessorDeclaration(node, ts.visitNodes(node.modifiers, visitor, ts.isModifierLike), node.name, ts.visitParameterList(node.parameters, visitor, context), transformMethodBody(node));
         }
         /**
          * Visits a FunctionDeclaration node.
@@ -98743,6 +98761,42 @@ var ts;
             }
             return false;
         }
+        function transformMethodBody(node) {
+            ts.Debug.assertIsDefined(node.body);
+            var savedCapturedSuperProperties = capturedSuperProperties;
+            var savedHasSuperElementAccess = hasSuperElementAccess;
+            capturedSuperProperties = new ts.Set();
+            hasSuperElementAccess = false;
+            var updated = ts.visitFunctionBody(node.body, visitor, context);
+            // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
+            // This step isn't needed if we eventually transform this to ES5.
+            var originalMethod = ts.getOriginalNode(node, ts.isFunctionLikeDeclaration);
+            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ &&
+                resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) &&
+                (ts.getFunctionFlags(originalMethod) & 3 /* FunctionFlags.AsyncGenerator */) !== 3 /* FunctionFlags.AsyncGenerator */;
+            if (emitSuperHelpers) {
+                enableSubstitutionForAsyncMethodsWithSuper();
+                if (capturedSuperProperties.size) {
+                    var variableStatement = createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
+                    substitutedSuperAccessors[ts.getNodeId(variableStatement)] = true;
+                    var statements = updated.statements.slice();
+                    ts.insertStatementsAfterStandardPrologue(statements, [variableStatement]);
+                    updated = factory.updateBlock(updated, statements);
+                }
+                if (hasSuperElementAccess) {
+                    // Emit helpers for super element access expressions (`super[x]`).
+                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
+                        ts.addEmitHelper(updated, ts.advancedAsyncSuperHelper);
+                    }
+                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
+                        ts.addEmitHelper(updated, ts.asyncSuperHelper);
+                    }
+                }
+            }
+            capturedSuperProperties = savedCapturedSuperProperties;
+            hasSuperElementAccess = savedHasSuperElementAccess;
+            return updated;
+        }
         function transformAsyncFunctionBody(node) {
             resumeLexicalEnvironment();
             var original = ts.getOriginalNode(node, ts.isFunctionLike);
@@ -98775,7 +98829,7 @@ var ts;
                 ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
                 // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
                 // This step isn't needed if we eventually transform this to ES5.
-                var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */ | 2048 /* NodeCheckFlags.AsyncMethodWithSuper */);
+                var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */);
                 if (emitSuperHelpers) {
                     enableSubstitutionForAsyncMethodsWithSuper();
                     if (capturedSuperProperties.size) {
@@ -98788,10 +98842,10 @@ var ts;
                 ts.setTextRange(block, node.body);
                 if (emitSuperHelpers && hasSuperElementAccess) {
                     // Emit helpers for super element access expressions (`super[x]`).
-                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+                    if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                         ts.addEmitHelper(block, ts.advancedAsyncSuperHelper);
                     }
-                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.AsyncMethodWithSuper */) {
+                    else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
                         ts.addEmitHelper(block, ts.asyncSuperHelper);
                     }
                 }
@@ -98863,7 +98917,7 @@ var ts;
             // If we need to support substitutions for `super` in an async method,
             // we should track it here.
             if (enabledSubstitutions & 1 /* ES2017SubstitutionFlags.AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.AsyncMethodWithSuper */ | 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */);
+                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */ | 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */);
                 if (superContainerFlags !== enclosingSuperContainerFlags) {
                     var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
                     enclosingSuperContainerFlags = superContainerFlags;
@@ -98940,7 +98994,7 @@ var ts;
                 || kind === 175 /* SyntaxKind.SetAccessor */;
         }
         function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                 return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createUniqueName("_superIndex", 16 /* GeneratedIdentifierFlags.Optimistic */ | 32 /* GeneratedIdentifierFlags.FileLevel */), 
                 /*typeArguments*/ undefined, [argumentExpression]), "value"), location);
             }
@@ -98955,7 +99009,7 @@ var ts;
     function createSuperAccessVariableStatement(factory, resolver, node, names) {
         // Create a variable declaration with a getter/setter (if binding) definition for each name:
         //   const _super = Object.create(null, { x: { get: () => super.x, set: (v) => super.x = v }, ... });
-        var hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) !== 0;
+        var hasBinding = (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) !== 0;
         var accessors = [];
         names.forEach(function (_, key) {
             var name = ts.unescapeLeadingUnderscores(key);
@@ -99663,7 +99717,7 @@ var ts;
             /*type*/ undefined, factory.updateBlock(node.body, ts.visitLexicalEnvironment(node.body.statements, visitor, context, statementOffset))), !!(hierarchyFacts & 1 /* HierarchyFacts.HasLexicalThis */)));
             // Minor optimization, emit `_super` helper to capture `super` access in an arrow.
             // This step isn't needed if we eventually transform this to ES5.
-            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */ | 2048 /* NodeCheckFlags.AsyncMethodWithSuper */);
+            var emitSuperHelpers = languageVersion >= 2 /* ScriptTarget.ES2015 */ && resolver.getNodeCheckFlags(node) & (4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */ | 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */);
             if (emitSuperHelpers) {
                 enableSubstitutionForAsyncMethodsWithSuper();
                 var variableStatement = ts.createSuperAccessVariableStatement(factory, resolver, node, capturedSuperProperties);
@@ -99674,10 +99728,10 @@ var ts;
             ts.insertStatementsAfterStandardPrologue(statements, endLexicalEnvironment());
             var block = factory.updateBlock(node.body, statements);
             if (emitSuperHelpers && hasSuperElementAccess) {
-                if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+                if (resolver.getNodeCheckFlags(node) & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                     ts.addEmitHelper(block, ts.advancedAsyncSuperHelper);
                 }
-                else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.AsyncMethodWithSuper */) {
+                else if (resolver.getNodeCheckFlags(node) & 2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */) {
                     ts.addEmitHelper(block, ts.asyncSuperHelper);
                 }
             }
@@ -99806,7 +99860,7 @@ var ts;
             // If we need to support substitutions for `super` in an async method,
             // we should track it here.
             if (enabledSubstitutions & 1 /* ESNextSubstitutionFlags.AsyncMethodsWithSuper */ && isSuperContainer(node)) {
-                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.AsyncMethodWithSuper */ | 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */);
+                var superContainerFlags = resolver.getNodeCheckFlags(node) & (2048 /* NodeCheckFlags.MethodWithSuperPropertyAccessInAsync */ | 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */);
                 if (superContainerFlags !== enclosingSuperContainerFlags) {
                     var savedEnclosingSuperContainerFlags = enclosingSuperContainerFlags;
                     enclosingSuperContainerFlags = superContainerFlags;
@@ -99883,7 +99937,7 @@ var ts;
                 || kind === 175 /* SyntaxKind.SetAccessor */;
         }
         function createSuperElementAccessInAsyncMethod(argumentExpression, location) {
-            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.AsyncMethodWithSuperBinding */) {
+            if (enclosingSuperContainerFlags & 4096 /* NodeCheckFlags.MethodWithSuperPropertyAssignmentInAsync */) {
                 return ts.setTextRange(factory.createPropertyAccessExpression(factory.createCallExpression(factory.createIdentifier("_superIndex"), 
                 /*typeArguments*/ undefined, [argumentExpression]), "value"), location);
             }
@@ -123909,7 +123963,7 @@ var ts;
         var isNonDirectorySeparatorRoot = rootLength > 1 || dirPath.charCodeAt(0) !== 47 /* CharacterCodes.slash */;
         if (isNonDirectorySeparatorRoot &&
             dirPath.search(/[a-zA-Z]:/) !== 0 && // Non dos style paths
-            pathPartForUserCheck.search(/[a-zA-z]\$\//) === 0) { // Dos style nextPart
+            pathPartForUserCheck.search(/[a-zA-Z]\$\//) === 0) { // Dos style nextPart
             nextDirectorySeparator = dirPath.indexOf(ts.directorySeparator, nextDirectorySeparator + 1);
             if (nextDirectorySeparator === -1) {
                 // ignore "//vda1cs4850/c$/folderAtRoot"
@@ -125415,15 +125469,21 @@ var ts;
             return undefined;
         }
         function tryGetModuleNameFromRootDirs(rootDirs, moduleFileName, sourceDirectory, getCanonicalFileName, ending, compilerOptions) {
-            var normalizedTargetPath = getPathRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
-            if (normalizedTargetPath === undefined) {
+            var normalizedTargetPaths = getPathsRelativeToRootDirs(moduleFileName, rootDirs, getCanonicalFileName);
+            if (normalizedTargetPaths === undefined) {
+                return undefined;
+            }
+            var normalizedSourcePaths = getPathsRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName);
+            var relativePaths = ts.flatMap(normalizedSourcePaths, function (sourcePath) {
+                return ts.map(normalizedTargetPaths, function (targetPath) { return ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(sourcePath, targetPath, getCanonicalFileName)); });
+            });
+            var shortest = ts.min(relativePaths, ts.compareNumberOfDirectorySeparators);
+            if (!shortest) {
                 return undefined;
             }
-            var normalizedSourcePath = getPathRelativeToRootDirs(sourceDirectory, rootDirs, getCanonicalFileName);
-            var relativePath = normalizedSourcePath !== undefined ? ts.ensurePathIsNonModuleName(ts.getRelativePathFromDirectory(normalizedSourcePath, normalizedTargetPath, getCanonicalFileName)) : normalizedTargetPath;
             return ts.getEmitModuleResolutionKind(compilerOptions) === ts.ModuleResolutionKind.NodeJs
-                ? removeExtensionAndIndexPostFix(relativePath, ending, compilerOptions)
-                : ts.removeFileExtension(relativePath);
+                ? removeExtensionAndIndexPostFix(shortest, ending, compilerOptions)
+                : ts.removeFileExtension(shortest);
         }
         function tryGetModuleNameAsNodeModule(_a, _b, importingSourceFile, host, options, userPreferences, packageNameOnly, overrideMode) {
             var path = _a.path, isRedirect = _a.isRedirect;
@@ -125560,8 +125620,8 @@ var ts;
                 }
             }
         }
-        function getPathRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
-            return ts.firstDefined(rootDirs, function (rootDir) {
+        function getPathsRelativeToRootDirs(path, rootDirs, getCanonicalFileName) {
+            return ts.mapDefined(rootDirs, function (rootDir) {
                 var relativePath = getRelativePathIfInDirectory(path, rootDir, getCanonicalFileName);
                 return relativePath !== undefined && isPathRelativeToParent(relativePath) ? undefined : relativePath;
             });
@@ -146070,7 +146130,7 @@ var ts;
         return bestMatch;
     }
     function betterMatch(a, b) {
-        return ts.min(a, b, compareMatches);
+        return ts.min([a, b], compareMatches);
     }
     function compareMatches(a, b) {
         return a === undefined ? 1 /* Comparison.GreaterThan */ : b === undefined ? -1 /* Comparison.LessThan */