typescript 4.9.0-dev.20221013 → 4.9.0-dev.20221014

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.20221013");
+    ts.version = "".concat(ts.versionMajorMinor, ".0-dev.20221014");
     /* @internal */
     var Comparison;
     (function (Comparison) {
@@ -9910,6 +9910,8 @@ var ts;
         Remove_type_from_import_of_0_from_1: diag(90056, ts.DiagnosticCategory.Message, "Remove_type_from_import_of_0_from_1_90056", "Remove 'type' from import of '{0}' from \"{1}\""),
         Add_import_from_0: diag(90057, ts.DiagnosticCategory.Message, "Add_import_from_0_90057", "Add import from \"{0}\""),
         Update_import_from_0: diag(90058, ts.DiagnosticCategory.Message, "Update_import_from_0_90058", "Update import from \"{0}\""),
+        Export_0_from_module_1: diag(90059, ts.DiagnosticCategory.Message, "Export_0_from_module_1_90059", "Export '{0}' from module '{1}'"),
+        Export_all_referenced_locals: diag(90060, ts.DiagnosticCategory.Message, "Export_all_referenced_locals_90060", "Export all referenced locals"),
         Convert_function_to_an_ES2015_class: diag(95001, ts.DiagnosticCategory.Message, "Convert_function_to_an_ES2015_class_95001", "Convert function to an ES2015 class"),
         Convert_0_to_1_in_0: diag(95003, ts.DiagnosticCategory.Message, "Convert_0_to_1_in_0_95003", "Convert '{0}' to '{1} in {0}'"),
         Extract_to_0_in_1: diag(95004, ts.DiagnosticCategory.Message, "Extract_to_0_in_1_95004", "Extract to {0} in {1}"),
@@ -21670,6 +21672,32 @@ var ts;
         return parameter.kind === 343 /* SyntaxKind.JSDocParameterTag */ ? (_a = parameter.typeExpression) === null || _a === void 0 ? void 0 : _a.type : parameter.type;
     }
     ts.getParameterTypeNode = getParameterTypeNode;
+    function isTypeDeclaration(node) {
+        switch (node.kind) {
+            case 165 /* SyntaxKind.TypeParameter */:
+            case 260 /* SyntaxKind.ClassDeclaration */:
+            case 261 /* SyntaxKind.InterfaceDeclaration */:
+            case 262 /* SyntaxKind.TypeAliasDeclaration */:
+            case 263 /* SyntaxKind.EnumDeclaration */:
+            case 348 /* SyntaxKind.JSDocTypedefTag */:
+            case 341 /* SyntaxKind.JSDocCallbackTag */:
+            case 342 /* SyntaxKind.JSDocEnumTag */:
+                return true;
+            case 270 /* SyntaxKind.ImportClause */:
+                return node.isTypeOnly;
+            case 273 /* SyntaxKind.ImportSpecifier */:
+            case 278 /* SyntaxKind.ExportSpecifier */:
+                return node.parent.parent.isTypeOnly;
+            default:
+                return false;
+        }
+    }
+    ts.isTypeDeclaration = isTypeDeclaration;
+    function canHaveExportModifier(node) {
+        return ts.isEnumDeclaration(node) || ts.isVariableStatement(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)
+            || ts.isInterfaceDeclaration(node) || isTypeDeclaration(node) || (ts.isModuleDeclaration(node) && !isExternalModuleAugmentation(node) && !isGlobalScopeAugmentation(node));
+    }
+    ts.canHaveExportModifier = canHaveExportModifier;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
@@ -49072,8 +49100,6 @@ var ts;
         IntersectionState[IntersectionState["None"] = 0] = "None";
         IntersectionState[IntersectionState["Source"] = 1] = "Source";
         IntersectionState[IntersectionState["Target"] = 2] = "Target";
-        IntersectionState[IntersectionState["PropertyCheck"] = 4] = "PropertyCheck";
-        IntersectionState[IntersectionState["InPropertyCheck"] = 8] = "InPropertyCheck";
     })(IntersectionState || (IntersectionState = {}));
     var RecursionFlags;
     (function (RecursionFlags) {
@@ -55415,7 +55441,7 @@ var ts;
                                 // export {name} - look thru `statements` for `name`, and if all results can take an `export` modifier, do so and filter it
                                 var indices = ts.indicesOf(statements);
                                 var associatedIndices = ts.filter(indices, function (i) { return ts.nodeHasName(statements[i], e.name); });
-                                if (ts.length(associatedIndices) && ts.every(associatedIndices, function (i) { return canHaveExportModifier(statements[i]); })) {
+                                if (ts.length(associatedIndices) && ts.every(associatedIndices, function (i) { return ts.canHaveExportModifier(statements[i]); })) {
                                     for (var _i = 0, associatedIndices_1 = associatedIndices; _i < associatedIndices_1.length; _i++) {
                                         var index_1 = associatedIndices_1[_i];
                                         statements[index_1] = addExportModifier(statements[index_1]);
@@ -55449,15 +55475,6 @@ var ts;
                     }
                     return statements;
                 }
-                function canHaveExportModifier(node) {
-                    return ts.isEnumDeclaration(node) ||
-                        ts.isVariableStatement(node) ||
-                        ts.isFunctionDeclaration(node) ||
-                        ts.isClassDeclaration(node) ||
-                        (ts.isModuleDeclaration(node) && !ts.isExternalModuleAugmentation(node) && !ts.isGlobalScopeAugmentation(node)) ||
-                        ts.isInterfaceDeclaration(node) ||
-                        isTypeDeclaration(node);
-                }
                 function addExportModifier(node) {
                     var flags = (ts.getEffectiveModifierFlags(node) | 1 /* ModifierFlags.Export */) & ~2 /* ModifierFlags.Ambient */;
                     return ts.factory.updateModifiers(node, flags);
@@ -55704,7 +55721,7 @@ var ts;
                             (ts.isJSDocTypeAlias(context.enclosingDeclaration) ? ts.getSourceFileOfNode(context.enclosingDeclaration) : context.enclosingDeclaration);
                         if (additionalModifierFlags & 1 /* ModifierFlags.Export */ &&
                             enclosingDeclaration_1 && (isExportingScope(enclosingDeclaration_1) || ts.isModuleDeclaration(enclosingDeclaration_1)) &&
-                            canHaveExportModifier(node)) {
+                            ts.canHaveExportModifier(node)) {
                             // Classes, namespaces, variables, functions, interfaces, and types should all be `export`ed in a module context if not private
                             newModifierFlags |= 1 /* ModifierFlags.Export */;
                         }
@@ -63831,18 +63848,23 @@ var ts;
             var result;
             var extraTypes;
             var tailCount = 0;
-            var _loop_20 = function () {
+            // We loop here for an immediately nested conditional type in the false position, effectively treating
+            // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
+            // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of
+            // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive
+            // cases we increment the tail recursion counter and stop after 1000 iterations.
+            while (true) {
                 if (tailCount === 1000) {
                     error(currentNode, ts.Diagnostics.Type_instantiation_is_excessively_deep_and_possibly_infinite);
                     result = errorType;
-                    return "break";
+                    break;
                 }
                 var isUnwrapped = isTypicalNondistributiveConditional(root);
                 var checkType = instantiateType(unwrapNondistributiveConditionalTuple(root, getActualTypeVariable(root.checkType)), mapper);
                 var checkTypeInstantiable = isGenericType(checkType);
                 var extendsType = instantiateType(unwrapNondistributiveConditionalTuple(root, root.extendsType), mapper);
                 if (checkType === wildcardType || extendsType === wildcardType) {
-                    return { value: wildcardType };
+                    return wildcardType;
                 }
                 var combinedMapper = void 0;
                 if (root.inferTypeParameters) {
@@ -63875,11 +63897,7 @@ var ts;
                             }
                         }
                     }
-                    // We skip inference of the possible `infer` types unles the `extendsType` _is_ an infer type
-                    // if it was, it's trivial to say that extendsType = checkType, however such a pattern is used to
-                    // "reset" the type being build up during constraint calculation and avoid making an apparently "infinite" constraint
-                    // so in those cases we refain from performing inference and retain the uninfered type parameter
-                    if (!checkTypeInstantiable || !ts.some(root.inferTypeParameters, function (t) { return t === extendsType; })) {
+                    if (!checkTypeInstantiable) {
                         // We don't want inferences from constraints as they may cause us to eagerly resolve the
                         // conditional type instead of deferring resolution. Also, we always want strict function
                         // types rules (i.e. proper contravariance) for inferences.
@@ -63911,14 +63929,14 @@ var ts;
                             var newRoot = falseType_1.root;
                             if (newRoot.node.parent === root.node && (!newRoot.isDistributive || newRoot.checkType === root.checkType)) {
                                 root = newRoot;
-                                return "continue";
+                                continue;
                             }
                             if (canTailRecurse(falseType_1, mapper)) {
-                                return "continue";
+                                continue;
                             }
                         }
                         result = instantiateType(falseType_1, mapper);
-                        return "break";
+                        break;
                     }
                     // Return trueType for a definitely true extends check. We check instantiations of the two
                     // types with type parameters mapped to their restrictive form, i.e. a form of the type parameter
@@ -63929,10 +63947,10 @@ var ts;
                         var trueType_1 = getTypeFromTypeNode(root.node.trueType);
                         var trueMapper = combinedMapper || mapper;
                         if (canTailRecurse(trueType_1, trueMapper)) {
-                            return "continue";
+                            continue;
                         }
                         result = instantiateType(trueType_1, trueMapper);
-                        return "break";
+                        break;
                     }
                 }
                 // Return a deferred type for a check that is neither definitely true nor definitely false
@@ -63944,19 +63962,7 @@ var ts;
                 result.combinedMapper = combinedMapper;
                 result.aliasSymbol = aliasSymbol || root.aliasSymbol;
                 result.aliasTypeArguments = aliasSymbol ? aliasTypeArguments : instantiateTypes(root.aliasTypeArguments, mapper); // TODO: GH#18217
-                return "break";
-            };
-            // We loop here for an immediately nested conditional type in the false position, effectively treating
-            // types of the form 'A extends B ? X : C extends D ? Y : E extends F ? Z : ...' as a single construct for
-            // purposes of resolution. We also loop here when resolution of a conditional type ends in resolution of
-            // another (or, through recursion, possibly the same) conditional type. In the potentially tail-recursive
-            // cases we increment the tail recursion counter and stop after 1000 iterations.
-            while (true) {
-                var state_6 = _loop_20();
-                if (typeof state_6 === "object")
-                    return state_6.value;
-                if (state_6 === "break")
-                    break;
+                break;
             }
             return extraTypes ? getUnionType(ts.append(extraTypes, result)) : result;
             // We tail-recurse for generic conditional types that (a) have not already been evaluated and cached, and
@@ -66410,7 +66416,7 @@ var ts;
                             return 0 /* Ternary.False */;
                         }
                     }
-                    var isPerformingCommonPropertyChecks = (relation !== comparableRelation || !(source.flags & 1048576 /* TypeFlags.Union */) && isLiteralType(source)) &&
+                    var isPerformingCommonPropertyChecks = (relation !== comparableRelation || isUnitType(source)) &&
                         !(intersectionState & 2 /* IntersectionState.Target */) &&
                         source.flags & (131068 /* TypeFlags.Primitive */ | 524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && source !== globalObjectType &&
                         target.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) && isWeakType(target) &&
@@ -66438,27 +66444,6 @@ var ts;
                     var result_7 = skipCaching ?
                         unionOrIntersectionRelatedTo(source, target, reportErrors, intersectionState) :
                         recursiveTypeRelatedTo(source, target, reportErrors, intersectionState, recursionFlags);
-                    // For certain combinations involving intersections and optional, excess, or mismatched properties we need
-                    // an extra property check where the intersection is viewed as a single object. The following are motivating
-                    // examples that all should be errors, but aren't without this extra property check:
-                    //
-                    //   let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 };  // Nested excess property
-                    //
-                    //   declare let wrong: { a: { y: string } };
-                    //   let weak: { a?: { x?: number } } & { c?: string } = wrong;  // Nested weak object type
-                    //
-                    //   function foo<T extends object>(x: { a?: string }, y: T & { a: boolean }) {
-                    //     x = y;  // Mismatched property in source intersection
-                    //   }
-                    //
-                    // We suppress recursive intersection property checks because they can generate lots of work when relating
-                    // recursive intersections that are structurally similar but not exactly identical. See #37854.
-                    if (result_7 && !inPropertyCheck && (target.flags & 2097152 /* TypeFlags.Intersection */ && (isPerformingExcessPropertyChecks || isPerformingCommonPropertyChecks) ||
-                        isNonGenericObjectType(target) && !isArrayOrTupleType(target) && source.flags & 2097152 /* TypeFlags.Intersection */ && getApparentType(source).flags & 3670016 /* TypeFlags.StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 262144 /* ObjectFlags.NonInferrableType */); }))) {
-                        inPropertyCheck = true;
-                        result_7 &= recursiveTypeRelatedTo(source, target, reportErrors, 4 /* IntersectionState.PropertyCheck */, recursionFlags);
-                        inPropertyCheck = false;
-                    }
                     if (result_7) {
                         return result_7;
                     }
@@ -66570,7 +66555,7 @@ var ts;
                     reducedTarget = findMatchingDiscriminantType(source, target, isRelatedTo) || filterPrimitivesIfContainsNonPrimitive(target);
                     checkTypes = reducedTarget.flags & 1048576 /* TypeFlags.Union */ ? reducedTarget.types : [reducedTarget];
                 }
-                var _loop_21 = function (prop) {
+                var _loop_20 = function (prop) {
                     if (shouldCheckAsExcessProperty(prop, source.symbol) && !isIgnoredJsxProperty(source, prop)) {
                         if (!isKnownProperty(reducedTarget, prop.escapedName, isComparingJsxAttributes)) {
                             if (reportErrors) {
@@ -66633,9 +66618,9 @@ var ts;
                 };
                 for (var _i = 0, _b = getPropertiesOfType(source); _i < _b.length; _i++) {
                     var prop = _b[_i];
-                    var state_7 = _loop_21(prop);
-                    if (typeof state_7 === "object")
-                        return state_7.value;
+                    var state_6 = _loop_20(prop);
+                    if (typeof state_6 === "object")
+                        return state_6.value;
                 }
                 return false;
             }
@@ -66856,8 +66841,7 @@ var ts;
                 if (overflow) {
                     return 0 /* Ternary.False */;
                 }
-                var keyIntersectionState = intersectionState | (inPropertyCheck ? 8 /* IntersectionState.InPropertyCheck */ : 0);
-                var id = getRelationKey(source, target, keyIntersectionState, relation, /*ingnoreConstraints*/ false);
+                var id = getRelationKey(source, target, intersectionState, relation, /*ingnoreConstraints*/ false);
                 var entry = relation.get(id);
                 if (entry !== undefined) {
                     if (reportErrors && entry & 2 /* RelationComparisonResult.Failed */ && !(entry & 4 /* RelationComparisonResult.Reported */)) {
@@ -66887,7 +66871,7 @@ var ts;
                     // A key that starts with "*" is an indication that we have type references that reference constrained
                     // type parameters. For such keys we also check against the key we would have gotten if all type parameters
                     // were unconstrained.
-                    var broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, keyIntersectionState, relation, /*ignoreConstraints*/ true) : undefined;
+                    var broadestEquivalentId = id.startsWith("*") ? getRelationKey(source, target, intersectionState, relation, /*ignoreConstraints*/ true) : undefined;
                     for (var i = 0; i < maybeCount; i++) {
                         // If source and target are already being compared, consider them related with assumptions
                         if (id === maybeKeys[i] || broadestEquivalentId && broadestEquivalentId === maybeKeys[i]) {
@@ -66974,7 +66958,7 @@ var ts;
             function structuredTypeRelatedTo(source, target, reportErrors, intersectionState) {
                 var saveErrorInfo = captureErrorCalculationState();
                 var result = structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo);
-                if (!result && (source.flags & 2097152 /* TypeFlags.Intersection */ || source.flags & 262144 /* TypeFlags.TypeParameter */ && target.flags & 1048576 /* TypeFlags.Union */)) {
+                if (relation !== identityRelation) {
                     // The combined constraint of an intersection type is the intersection of the constraints of
                     // the constituents. When an intersection type contains instantiable types with union type
                     // constraints, there are situations where we need to examine the combined constraint. One is
@@ -66988,10 +66972,33 @@ var ts;
                     // needs to have its constraint hoisted into an intersection with said type parameter, this way
                     // the type param can be compared with itself in the target (with the influence of its constraint to match other parts)
                     // For example, if `T extends 1 | 2` and `U extends 2 | 3` and we compare `T & U` to `T & U & (1 | 2 | 3)`
-                    var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* TypeFlags.Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* TypeFlags.Union */));
-                    if (constraint && !(constraint.flags & 131072 /* TypeFlags.Never */) && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
-                        // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
-                        result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState);
+                    if (!result && (source.flags & 2097152 /* TypeFlags.Intersection */ || source.flags & 262144 /* TypeFlags.TypeParameter */ && target.flags & 1048576 /* TypeFlags.Union */)) {
+                        var constraint = getEffectiveConstraintOfIntersection(source.flags & 2097152 /* TypeFlags.Intersection */ ? source.types : [source], !!(target.flags & 1048576 /* TypeFlags.Union */));
+                        if (constraint && !(constraint.flags & 131072 /* TypeFlags.Never */) && everyType(constraint, function (c) { return c !== source; })) { // Skip comparison if expansion contains the source itself
+                            // TODO: Stack errors so we get a pyramid for the "normal" comparison above, _and_ a second for this
+                            result = isRelatedTo(constraint, target, 1 /* RecursionFlags.Source */, /*reportErrors*/ false, /*headMessage*/ undefined, intersectionState);
+                        }
+                    }
+                    // For certain combinations involving intersections and optional, excess, or mismatched properties we need
+                    // an extra property check where the intersection is viewed as a single object. The following are motivating
+                    // examples that all should be errors, but aren't without this extra property check:
+                    //
+                    //   let obj: { a: { x: string } } & { c: number } = { a: { x: 'hello', y: 2 }, c: 5 };  // Nested excess property
+                    //
+                    //   declare let wrong: { a: { y: string } };
+                    //   let weak: { a?: { x?: number } } & { c?: string } = wrong;  // Nested weak object type
+                    //
+                    //   function foo<T extends object>(x: { a?: string }, y: T & { a: boolean }) {
+                    //     x = y;  // Mismatched property in source intersection
+                    //   }
+                    //
+                    // We suppress recursive intersection property checks because they can generate lots of work when relating
+                    // recursive intersections that are structurally similar but not exactly identical. See #37854.
+                    if (result && !inPropertyCheck && (target.flags & 2097152 /* TypeFlags.Intersection */ && !isGenericObjectType(target) && source.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */) ||
+                        isNonGenericObjectType(target) && !isArrayOrTupleType(target) && source.flags & 2097152 /* TypeFlags.Intersection */ && getApparentType(source).flags & 3670016 /* TypeFlags.StructuredType */ && !ts.some(source.types, function (t) { return !!(ts.getObjectFlags(t) & 262144 /* ObjectFlags.NonInferrableType */); }))) {
+                        inPropertyCheck = true;
+                        result &= propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* IntersectionState.None */);
+                        inPropertyCheck = false;
                     }
                 }
                 if (result) {
@@ -67000,9 +67007,6 @@ var ts;
                 return result;
             }
             function structuredTypeRelatedToWorker(source, target, reportErrors, intersectionState, saveErrorInfo) {
-                if (intersectionState & 4 /* IntersectionState.PropertyCheck */) {
-                    return propertiesRelatedTo(source, target, reportErrors, /*excludedProperties*/ undefined, 0 /* IntersectionState.None */);
-                }
                 var result;
                 var originalErrorInfo;
                 var varianceCheckFailed = false;
@@ -67626,11 +67630,11 @@ var ts;
                 // constituents of 'target'. If any combination does not have a match then 'source' is not relatable.
                 var discriminantCombinations = ts.cartesianProduct(sourceDiscriminantTypes);
                 var matchingTypes = [];
-                var _loop_22 = function (combination) {
+                var _loop_21 = function (combination) {
                     var hasMatch = false;
                     outer: for (var _c = 0, _d = target.types; _c < _d.length; _c++) {
                         var type = _d[_c];
-                        var _loop_23 = function (i) {
+                        var _loop_22 = function (i) {
                             var sourceProperty = sourcePropertiesFiltered[i];
                             var targetProperty = getPropertyOfType(type, sourceProperty.escapedName);
                             if (!targetProperty)
@@ -67646,8 +67650,8 @@ var ts;
                             }
                         };
                         for (var i = 0; i < sourcePropertiesFiltered.length; i++) {
-                            var state_9 = _loop_23(i);
-                            switch (state_9) {
+                            var state_8 = _loop_22(i);
+                            switch (state_8) {
                                 case "continue-outer": continue outer;
                             }
                         }
@@ -67660,9 +67664,9 @@ var ts;
                 };
                 for (var _a = 0, discriminantCombinations_1 = discriminantCombinations; _a < discriminantCombinations_1.length; _a++) {
                     var combination = discriminantCombinations_1[_a];
-                    var state_8 = _loop_22(combination);
-                    if (typeof state_8 === "object")
-                        return state_8.value;
+                    var state_7 = _loop_21(combination);
+                    if (typeof state_7 === "object")
+                        return state_7.value;
                 }
                 // Compare the remaining non-discriminant properties of each match.
                 var result = -1 /* Ternary.True */;
@@ -68367,7 +68371,7 @@ var ts;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.push("checkTypes" /* tracing.Phase.CheckTypes */, "getVariancesWorker", { arity: typeParameters.length, id: getTypeId(getDeclaredTypeOfSymbol(symbol)) });
                 links.variances = ts.emptyArray;
                 var variances = [];
-                var _loop_24 = function (tp) {
+                var _loop_23 = function (tp) {
                     var modifiers = getVarianceModifiers(tp);
                     var variance = modifiers & 65536 /* ModifierFlags.Out */ ?
                         modifiers & 32768 /* ModifierFlags.In */ ? 0 /* VarianceFlags.Invariant */ : 1 /* VarianceFlags.Covariant */ :
@@ -68405,7 +68409,7 @@ var ts;
                 };
                 for (var _i = 0, typeParameters_2 = typeParameters; _i < typeParameters_2.length; _i++) {
                     var tp = typeParameters_2[_i];
-                    _loop_24(tp);
+                    _loop_23(tp);
                 }
                 links.variances = variances;
                 ts.tracing === null || ts.tracing === void 0 ? void 0 : ts.tracing.pop({ variances: variances.map(ts.Debug.formatVariance) });
@@ -70363,7 +70367,7 @@ var ts;
                 // upon instantiation, would collapse all the placeholders to just 'string', and an assignment check might
                 // succeed. That would be a pointless and confusing outcome.
                 if (matches || ts.every(target.texts, function (s) { return s.length === 0; })) {
-                    var _loop_25 = function (i) {
+                    var _loop_24 = function (i) {
                         var source_1 = matches ? matches[i] : neverType;
                         var target_3 = types[i];
                         // If we are inferring from a string literal type to a type variable whose constraint includes one of the
@@ -70413,7 +70417,7 @@ var ts;
                         inferFromTypes(source_1, target_3);
                     };
                     for (var i = 0; i < types.length; i++) {
-                        _loop_25(i);
+                        _loop_24(i);
                     }
                 }
             }
@@ -70942,7 +70946,7 @@ var ts;
         function mapTypesByKeyProperty(types, name) {
             var map = new ts.Map();
             var count = 0;
-            var _loop_26 = function (type) {
+            var _loop_25 = function (type) {
                 if (type.flags & (524288 /* TypeFlags.Object */ | 2097152 /* TypeFlags.Intersection */ | 58982400 /* TypeFlags.InstantiableNonPrimitive */)) {
                     var discriminant = getTypeOfPropertyOfType(type, name);
                     if (discriminant) {
@@ -70968,9 +70972,9 @@ var ts;
             };
             for (var _i = 0, types_15 = types; _i < types_15.length; _i++) {
                 var type = types_15[_i];
-                var state_10 = _loop_26(type);
-                if (typeof state_10 === "object")
-                    return state_10.value;
+                var state_9 = _loop_25(type);
+                if (typeof state_9 === "object")
+                    return state_9.value;
             }
             return count >= 10 && count * 2 >= types.length ? map : undefined;
         }
@@ -77426,7 +77430,7 @@ var ts;
             if (spreadIndex >= 0) {
                 // Create synthetic arguments from spreads of tuple types.
                 var effectiveArgs_1 = args.slice(0, spreadIndex);
-                var _loop_27 = function (i) {
+                var _loop_26 = function (i) {
                     var arg = args[i];
                     // We can call checkExpressionCached because spread expressions never have a contextual type.
                     var spreadType = arg.kind === 227 /* SyntaxKind.SpreadElement */ && (flowLoopCount ? checkExpression(arg.expression) : checkExpressionCached(arg.expression));
@@ -77443,7 +77447,7 @@ var ts;
                     }
                 };
                 for (var i = spreadIndex; i < args.length; i++) {
-                    _loop_27(i);
+                    _loop_26(i);
                 }
                 return effectiveArgs_1;
             }
@@ -77772,7 +77776,7 @@ var ts;
                         var min_3 = Number.MAX_VALUE;
                         var minIndex = 0;
                         var i_1 = 0;
-                        var _loop_28 = function (c) {
+                        var _loop_27 = function (c) {
                             var chain_2 = function () { return ts.chainDiagnosticMessages(/*details*/ undefined, ts.Diagnostics.Overload_0_of_1_2_gave_the_following_error, i_1 + 1, candidates.length, signatureToString(c)); };
                             var diags_2 = getSignatureApplicabilityError(node, args, c, assignableRelation, 0 /* CheckMode.Normal */, /*reportErrors*/ true, chain_2);
                             if (diags_2) {
@@ -77790,7 +77794,7 @@ var ts;
                         };
                         for (var _a = 0, candidatesForArgumentError_1 = candidatesForArgumentError; _a < candidatesForArgumentError_1.length; _a++) {
                             var c = candidatesForArgumentError_1[_a];
-                            _loop_28(c);
+                            _loop_27(c);
                         }
                         var diags_3 = max > 1 ? allDiagnostics[minIndex] : ts.flatten(allDiagnostics);
                         ts.Debug.assert(diags_3.length > 0, "No errors reported for 3 or fewer overload signatures");
@@ -77948,7 +77952,7 @@ var ts;
             }
             var _a = ts.minAndMax(candidates, getNumNonRestParameters), minArgumentCount = _a.min, maxNonRestParam = _a.max;
             var parameters = [];
-            var _loop_29 = function (i) {
+            var _loop_28 = function (i) {
                 var symbols = ts.mapDefined(candidates, function (s) { return signatureHasRestParameter(s) ?
                     i < s.parameters.length - 1 ? s.parameters[i] : ts.last(s.parameters) :
                     i < s.parameters.length ? s.parameters[i] : undefined; });
@@ -77956,7 +77960,7 @@ var ts;
                 parameters.push(createCombinedSymbolFromTypes(symbols, ts.mapDefined(candidates, function (candidate) { return tryGetTypeAtPosition(candidate, i); })));
             };
             for (var i = 0; i < maxNonRestParam; i++) {
-                _loop_29(i);
+                _loop_28(i);
             }
             var restParameterSymbols = ts.mapDefined(candidates, function (c) { return signatureHasRestParameter(c) ? ts.last(c.parameters) : undefined; });
             var flags = 0 /* SignatureFlags.None */;
@@ -82014,7 +82018,7 @@ var ts;
             var indexSymbol = getIndexSymbol(getSymbolOfNode(node));
             if (indexSymbol === null || indexSymbol === void 0 ? void 0 : indexSymbol.declarations) {
                 var indexSignatureMap_1 = new ts.Map();
-                var _loop_30 = function (declaration) {
+                var _loop_29 = function (declaration) {
                     if (declaration.parameters.length === 1 && declaration.parameters[0].type) {
                         forEachType(getTypeFromTypeNode(declaration.parameters[0].type), function (type) {
                             var entry = indexSignatureMap_1.get(getTypeId(type));
@@ -82029,7 +82033,7 @@ var ts;
                 };
                 for (var _i = 0, _a = indexSymbol.declarations; _i < _a.length; _i++) {
                     var declaration = _a[_i];
-                    _loop_30(declaration);
+                    _loop_29(declaration);
                 }
                 indexSignatureMap_1.forEach(function (entry) {
                     if (entry.declarations.length > 1) {
@@ -82306,7 +82310,7 @@ var ts;
                 }
                 var symbol = getNodeLinks(node).resolvedSymbol;
                 if (symbol) {
-                    if (ts.some(symbol.declarations, function (d) { return isTypeDeclaration(d) && !!(d.flags & 268435456 /* NodeFlags.Deprecated */); })) {
+                    if (ts.some(symbol.declarations, function (d) { return ts.isTypeDeclaration(d) && !!(d.flags & 268435456 /* NodeFlags.Deprecated */); })) {
                         addDeprecatedSuggestion(getDeprecatedSuggestionNode(node), symbol.declarations, symbol.escapedName);
                     }
                     if (type.flags & 32 /* TypeFlags.Enum */ && symbol.flags & 8 /* SymbolFlags.EnumMember */) {
@@ -83684,7 +83688,7 @@ var ts;
         }
         function errorUnusedLocal(declaration, name, addDiagnostic) {
             var node = ts.getNameOfDeclaration(declaration) || declaration;
-            var message = isTypeDeclaration(declaration) ? ts.Diagnostics._0_is_declared_but_never_used : ts.Diagnostics._0_is_declared_but_its_value_is_never_read;
+            var message = ts.isTypeDeclaration(declaration) ? ts.Diagnostics._0_is_declared_but_never_used : ts.Diagnostics._0_is_declared_but_its_value_is_never_read;
             addDiagnostic(declaration, 0 /* UnusedKind.Local */, ts.createDiagnosticForNode(node, message, name));
         }
         function isIdentifierThatStartsWithUnderscore(node) {
@@ -85638,7 +85642,7 @@ var ts;
             var propDeclaration = declaration && declaration.kind === 223 /* SyntaxKind.BinaryExpression */ ||
                 name && name.kind === 164 /* SyntaxKind.ComputedPropertyName */ ? declaration : undefined;
             var localPropDeclaration = getParentOfSymbol(prop) === type.symbol ? declaration : undefined;
-            var _loop_31 = function (info) {
+            var _loop_30 = function (info) {
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
                 // We check only when (a) the property is declared in the containing type, or (b) the applicable index signature is declared
                 // in the containing type, or (c) the containing type is an interface and no base interface contains both the property and
@@ -85655,7 +85659,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_9 = indexInfos; _i < indexInfos_9.length; _i++) {
                 var info = indexInfos_9[_i];
-                _loop_31(info);
+                _loop_30(info);
             }
         }
         function checkIndexConstraintForIndexSignature(type, checkInfo) {
@@ -85663,7 +85667,7 @@ var ts;
             var indexInfos = getApplicableIndexInfos(type, checkInfo.keyType);
             var interfaceDeclaration = ts.getObjectFlags(type) & 2 /* ObjectFlags.Interface */ ? ts.getDeclarationOfKind(type.symbol, 261 /* SyntaxKind.InterfaceDeclaration */) : undefined;
             var localCheckDeclaration = declaration && getParentOfSymbol(getSymbolOfNode(declaration)) === type.symbol ? declaration : undefined;
-            var _loop_32 = function (info) {
+            var _loop_31 = function (info) {
                 if (info === checkInfo)
                     return "continue";
                 var localIndexDeclaration = info.declaration && getParentOfSymbol(getSymbolOfNode(info.declaration)) === type.symbol ? info.declaration : undefined;
@@ -85678,7 +85682,7 @@ var ts;
             };
             for (var _i = 0, indexInfos_10 = indexInfos; _i < indexInfos_10.length; _i++) {
                 var info = indexInfos_10[_i];
-                _loop_32(info);
+                _loop_31(info);
             }
         }
         function checkTypeNameIsReserved(name, message) {
@@ -85733,7 +85737,7 @@ var ts;
             }
             else {
                 ts.forEach(jsdocParameters, function (_a, index) {
-                    var name = _a.name;
+                    var name = _a.name, isNameFirst = _a.isNameFirst;
                     if (excludedParameters.has(index) || ts.isIdentifier(name) && parameters.has(name.escapedText)) {
                         return;
                     }
@@ -85743,7 +85747,9 @@ var ts;
                         }
                     }
                     else {
-                        errorOrSuggestion(isJs, name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(name));
+                        if (!isNameFirst) {
+                            errorOrSuggestion(isJs, name, ts.Diagnostics.JSDoc_param_tag_has_name_0_but_there_is_no_parameter_with_that_name, ts.idText(name));
+                        }
                     }
                 });
             }
@@ -85998,7 +86004,7 @@ var ts;
             var baseTypes = baseTypeNode && getBaseTypes(type);
             var baseWithThis = (baseTypes === null || baseTypes === void 0 ? void 0 : baseTypes.length) ? getTypeWithThisArgument(ts.first(baseTypes), type.thisType) : undefined;
             var baseStaticType = getBaseConstructorTypeOfClass(type);
-            var _loop_33 = function (member) {
+            var _loop_32 = function (member) {
                 if (ts.hasAmbientModifier(member)) {
                     return "continue";
                 }
@@ -86015,7 +86021,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_33(member);
+                _loop_32(member);
             }
         }
         /**
@@ -86103,7 +86109,7 @@ var ts;
         function issueMemberSpecificError(node, typeWithThis, baseWithThis, broadDiag) {
             // iterate over all implemented properties and issue errors on each one which isn't compatible, rather than the class as a whole, if possible
             var issuedMemberError = false;
-            var _loop_34 = function (member) {
+            var _loop_33 = function (member) {
                 if (ts.isStatic(member)) {
                     return "continue";
                 }
@@ -86122,7 +86128,7 @@ var ts;
             };
             for (var _i = 0, _a = node.members; _i < _a.length; _i++) {
                 var member = _a[_i];
-                _loop_34(member);
+                _loop_33(member);
             }
             if (!issuedMemberError) {
                 // check again with diagnostics to generate a less-specific error
@@ -86193,7 +86199,7 @@ var ts;
             var _a, _b, _c, _d;
             // NOTE: assignability is checked in checkClassDeclaration
             var baseProperties = getPropertiesOfType(baseType);
-            var _loop_35 = function (baseProperty) {
+            var _loop_34 = function (baseProperty) {
                 var base = getTargetSymbol(baseProperty);
                 if (base.flags & 4194304 /* SymbolFlags.Prototype */) {
                     return "continue";
@@ -86303,8 +86309,8 @@ var ts;
             };
             basePropertyCheck: for (var _i = 0, baseProperties_1 = baseProperties; _i < baseProperties_1.length; _i++) {
                 var baseProperty = baseProperties_1[_i];
-                var state_11 = _loop_35(baseProperty);
-                switch (state_11) {
+                var state_10 = _loop_34(baseProperty);
+                switch (state_10) {
                     case "continue-basePropertyCheck": continue basePropertyCheck;
                 }
             }
@@ -88014,29 +88020,9 @@ var ts;
         }
         function isTypeDeclarationName(name) {
             return name.kind === 79 /* SyntaxKind.Identifier */ &&
-                isTypeDeclaration(name.parent) &&
+                ts.isTypeDeclaration(name.parent) &&
                 ts.getNameOfDeclaration(name.parent) === name;
         }
-        function isTypeDeclaration(node) {
-            switch (node.kind) {
-                case 165 /* SyntaxKind.TypeParameter */:
-                case 260 /* SyntaxKind.ClassDeclaration */:
-                case 261 /* SyntaxKind.InterfaceDeclaration */:
-                case 262 /* SyntaxKind.TypeAliasDeclaration */:
-                case 263 /* SyntaxKind.EnumDeclaration */:
-                case 348 /* SyntaxKind.JSDocTypedefTag */:
-                case 341 /* SyntaxKind.JSDocCallbackTag */:
-                case 342 /* SyntaxKind.JSDocEnumTag */:
-                    return true;
-                case 270 /* SyntaxKind.ImportClause */:
-                    return node.isTypeOnly;
-                case 273 /* SyntaxKind.ImportSpecifier */:
-                case 278 /* SyntaxKind.ExportSpecifier */:
-                    return node.parent.parent.isTypeOnly;
-                default:
-                    return false;
-            }
-        }
         // True if the given identifier is part of a type reference
         function isTypeReferenceIdentifier(node) {
             while (node.parent.kind === 163 /* SyntaxKind.QualifiedName */) {
@@ -88469,7 +88455,7 @@ var ts;
                 var baseType = ts.firstOrUndefined(getBaseTypes(classType));
                 return baseType ? getTypeWithThisArgument(baseType, classType.thisType) : errorType;
             }
-            if (isTypeDeclaration(node)) {
+            if (ts.isTypeDeclaration(node)) {
                 // In this case, we call getSymbolOfNode instead of getSymbolAtLocation because it is a declaration
                 var symbol = getSymbolOfNode(node);
                 return getDeclaredTypeOfSymbol(symbol);
@@ -125155,7 +125141,7 @@ var ts;
             });
             // Sort by paths closest to importing file Name directory
             var sortedPaths = [];
-            var _loop_36 = function (directory) {
+            var _loop_35 = function (directory) {
                 var directoryStart = ts.ensureTrailingDirectorySeparator(directory);
                 var pathsInDirectory;
                 allFileNames.forEach(function (_a, fileName) {
@@ -125179,9 +125165,9 @@ var ts;
             };
             var out_directory_1;
             for (var directory = ts.getDirectoryPath(importingFileName); allFileNames.size !== 0;) {
-                var state_12 = _loop_36(directory);
+                var state_11 = _loop_35(directory);
                 directory = out_directory_1;
-                if (state_12 === "break")
+                if (state_11 === "break")
                     break;
             }
             if (allFileNames.size) {
@@ -125250,7 +125236,7 @@ var ts;
         }
         function tryGetModuleNameFromPaths(relativeToBaseUrl, paths, allowedEndings, host, compilerOptions) {
             for (var key in paths) {
-                var _loop_37 = function (patternText_1) {
+                var _loop_36 = function (patternText_1) {
                     var pattern = ts.normalizePath(patternText_1);
                     var indexOfStar = pattern.indexOf("*");
                     // In module resolution, if `pattern` itself has an extension, a file with that extension is looked up directly,
@@ -125317,9 +125303,9 @@ var ts;
                 };
                 for (var _i = 0, _a = paths[key]; _i < _a.length; _i++) {
                     var patternText_1 = _a[_i];
-                    var state_13 = _loop_37(patternText_1);
-                    if (typeof state_13 === "object")
-                        return state_13.value;
+                    var state_12 = _loop_36(patternText_1);
+                    if (typeof state_12 === "object")
+                        return state_12.value;
                 }
             }
             function validateEnding(_a) {
@@ -132849,6 +132835,10 @@ var ts;
         return jsx === 2 /* JsxEmit.React */ || jsx === 3 /* JsxEmit.ReactNative */;
     }
     ts.jsxModeNeedsExplicitImport = jsxModeNeedsExplicitImport;
+    function isSourceFileFromLibrary(program, node) {
+        return program.isSourceFileFromExternalLibrary(node) || program.isSourceFileDefaultLibrary(node);
+    }
+    ts.isSourceFileFromLibrary = isSourceFileFromLibrary;
     // #endregion
 })(ts || (ts = {}));
 /*@internal*/
@@ -157956,6 +157946,143 @@ var ts;
 })(ts || (ts = {}));
 /* @internal */
 var ts;
+(function (ts) {
+    var codefix;
+    (function (codefix) {
+        var fixId = "fixImportNonExportedMember";
+        var errorCodes = [
+            ts.Diagnostics.Module_0_declares_1_locally_but_it_is_not_exported.code,
+        ];
+        codefix.registerCodeFix({
+            errorCodes: errorCodes,
+            fixIds: [fixId],
+            getCodeActions: function (context) {
+                var sourceFile = context.sourceFile, span = context.span, program = context.program;
+                var info = getInfo(sourceFile, span.start, program);
+                if (info === undefined)
+                    return undefined;
+                var changes = ts.textChanges.ChangeTracker.with(context, function (t) { return doChange(t, program, info); });
+                return [codefix.createCodeFixAction(fixId, changes, [ts.Diagnostics.Export_0_from_module_1, info.exportName.node.text, info.moduleSpecifier], fixId, ts.Diagnostics.Export_all_referenced_locals)];
+            },
+            getAllCodeActions: function (context) {
+                var program = context.program;
+                return codefix.createCombinedCodeActions(ts.textChanges.ChangeTracker.with(context, function (changes) {
+                    var exports = new ts.Map();
+                    codefix.eachDiagnostic(context, errorCodes, function (diag) {
+                        var info = getInfo(diag.file, diag.start, program);
+                        if (info === undefined)
+                            return undefined;
+                        var exportName = info.exportName, node = info.node, moduleSourceFile = info.moduleSourceFile;
+                        if (tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly) === undefined && ts.canHaveExportModifier(node)) {
+                            changes.insertExportModifier(moduleSourceFile, node);
+                        }
+                        else {
+                            var moduleExports = exports.get(moduleSourceFile) || { typeOnlyExports: [], exports: [] };
+                            if (exportName.isTypeOnly) {
+                                moduleExports.typeOnlyExports.push(exportName);
+                            }
+                            else {
+                                moduleExports.exports.push(exportName);
+                            }
+                            exports.set(moduleSourceFile, moduleExports);
+                        }
+                    });
+                    exports.forEach(function (moduleExports, moduleSourceFile) {
+                        var exportDeclaration = tryGetExportDeclaration(moduleSourceFile, /*isTypeOnly*/ true);
+                        if (exportDeclaration && exportDeclaration.isTypeOnly) {
+                            doChanges(changes, program, moduleSourceFile, moduleExports.typeOnlyExports, exportDeclaration);
+                            doChanges(changes, program, moduleSourceFile, moduleExports.exports, tryGetExportDeclaration(moduleSourceFile, /*isTypeOnly*/ false));
+                        }
+                        else {
+                            doChanges(changes, program, moduleSourceFile, __spreadArray(__spreadArray([], moduleExports.exports, true), moduleExports.typeOnlyExports, true), exportDeclaration);
+                        }
+                    });
+                }));
+            }
+        });
+        function getInfo(sourceFile, pos, program) {
+            var _a;
+            var token = ts.getTokenAtPosition(sourceFile, pos);
+            if (ts.isIdentifier(token)) {
+                var importDeclaration = ts.findAncestor(token, ts.isImportDeclaration);
+                if (importDeclaration === undefined)
+                    return undefined;
+                var moduleSpecifier = ts.isStringLiteral(importDeclaration.moduleSpecifier) ? importDeclaration.moduleSpecifier.text : undefined;
+                if (moduleSpecifier === undefined)
+                    return undefined;
+                var resolvedModule = ts.getResolvedModule(sourceFile, moduleSpecifier, /*mode*/ undefined);
+                if (resolvedModule === undefined)
+                    return undefined;
+                var moduleSourceFile = program.getSourceFile(resolvedModule.resolvedFileName);
+                if (moduleSourceFile === undefined || ts.isSourceFileFromLibrary(program, moduleSourceFile))
+                    return undefined;
+                var moduleSymbol = moduleSourceFile.symbol;
+                var locals = (_a = moduleSymbol.valueDeclaration) === null || _a === void 0 ? void 0 : _a.locals;
+                if (locals === undefined)
+                    return undefined;
+                var localSymbol = locals.get(token.escapedText);
+                if (localSymbol === undefined)
+                    return undefined;
+                var node = getNodeOfSymbol(localSymbol);
+                if (node === undefined)
+                    return undefined;
+                var exportName = { node: token, isTypeOnly: ts.isTypeDeclaration(node) };
+                return { exportName: exportName, node: node, moduleSourceFile: moduleSourceFile, moduleSpecifier: moduleSpecifier };
+            }
+            return undefined;
+        }
+        function doChange(changes, program, _a) {
+            var exportName = _a.exportName, node = _a.node, moduleSourceFile = _a.moduleSourceFile;
+            var exportDeclaration = tryGetExportDeclaration(moduleSourceFile, exportName.isTypeOnly);
+            if (exportDeclaration) {
+                updateExport(changes, program, moduleSourceFile, exportDeclaration, [exportName]);
+            }
+            else if (ts.canHaveExportModifier(node)) {
+                changes.insertExportModifier(moduleSourceFile, node);
+            }
+            else {
+                createExport(changes, program, moduleSourceFile, [exportName]);
+            }
+        }
+        function doChanges(changes, program, sourceFile, moduleExports, node) {
+            if (ts.length(moduleExports)) {
+                if (node) {
+                    updateExport(changes, program, sourceFile, node, moduleExports);
+                }
+                else {
+                    createExport(changes, program, sourceFile, moduleExports);
+                }
+            }
+        }
+        function tryGetExportDeclaration(sourceFile, isTypeOnly) {
+            var predicate = function (node) {
+                return ts.isExportDeclaration(node) && (isTypeOnly && node.isTypeOnly || !node.isTypeOnly);
+            };
+            return ts.findLast(sourceFile.statements, predicate);
+        }
+        function updateExport(changes, program, sourceFile, node, names) {
+            var namedExports = node.exportClause && ts.isNamedExports(node.exportClause) ? node.exportClause.elements : ts.factory.createNodeArray([]);
+            var allowTypeModifier = !node.isTypeOnly && !!(program.getCompilerOptions().isolatedModules || ts.find(namedExports, function (e) { return e.isTypeOnly; }));
+            changes.replaceNode(sourceFile, node, ts.factory.updateExportDeclaration(node, node.modifiers, node.isTypeOnly, ts.factory.createNamedExports(ts.factory.createNodeArray(__spreadArray(__spreadArray([], namedExports, true), createExportSpecifiers(names, allowTypeModifier), true), /*hasTrailingComma*/ namedExports.hasTrailingComma)), node.moduleSpecifier, node.assertClause));
+        }
+        function createExport(changes, program, sourceFile, names) {
+            changes.insertNodeAtEndOfScope(sourceFile, sourceFile, ts.factory.createExportDeclaration(/*modifiers*/ undefined, /*isTypeOnly*/ false, ts.factory.createNamedExports(createExportSpecifiers(names, /*allowTypeModifier*/ !!program.getCompilerOptions().isolatedModules)), /*moduleSpecifier*/ undefined, /*assertClause*/ undefined));
+        }
+        function createExportSpecifiers(names, allowTypeModifier) {
+            return ts.factory.createNodeArray(ts.map(names, function (n) { return ts.factory.createExportSpecifier(allowTypeModifier && n.isTypeOnly, /*propertyName*/ undefined, n.node); }));
+        }
+        function getNodeOfSymbol(symbol) {
+            if (symbol.valueDeclaration === undefined) {
+                return ts.firstOrUndefined(symbol.declarations);
+            }
+            var declaration = symbol.valueDeclaration;
+            var variableStatement = ts.isVariableDeclaration(declaration) ? ts.tryCast(declaration.parent.parent, ts.isVariableStatement) : undefined;
+            return variableStatement && ts.length(variableStatement.declarationList.declarations) === 1 ? variableStatement : declaration;
+        }
+    })(codefix = ts.codefix || (ts.codefix = {}));
+})(ts || (ts = {}));
+/* @internal */
+var ts;
 (function (ts) {
     var codefix;
     (function (codefix) {
@@ -158486,7 +158613,7 @@ var ts;
                 var argIndex = ts.findIndex(parent.parent.arguments, function (arg) { return arg === parent; });
                 if (argIndex < 0)
                     return undefined;
-                var signature = ts.singleOrUndefined(checker.getSignaturesOfType(checker.getTypeAtLocation(parent.parent.expression), 0 /* SignatureKind.Call */));
+                var signature = checker.getResolvedSignature(parent.parent);
                 if (!(signature && signature.declaration && signature.parameters[argIndex]))
                     return undefined;
                 var param = signature.parameters[argIndex].valueDeclaration;
@@ -158533,13 +158660,13 @@ var ts;
             if (ts.isIdentifier(token) && ts.isCallExpression(parent.parent)) {
                 var moduleDeclaration = ts.find(symbol.declarations, ts.isModuleDeclaration);
                 var moduleDeclarationSourceFile = moduleDeclaration === null || moduleDeclaration === void 0 ? void 0 : moduleDeclaration.getSourceFile();
-                if (moduleDeclaration && moduleDeclarationSourceFile && !isSourceFileFromLibrary(program, moduleDeclarationSourceFile)) {
+                if (moduleDeclaration && moduleDeclarationSourceFile && !ts.isSourceFileFromLibrary(program, moduleDeclarationSourceFile)) {
                     return { kind: InfoKind.Function, token: token, call: parent.parent, sourceFile: sourceFile, modifierFlags: 1 /* ModifierFlags.Export */, parentDeclaration: moduleDeclaration };
                 }
                 var moduleSourceFile = ts.find(symbol.declarations, ts.isSourceFile);
                 if (sourceFile.commonJsModuleIndicator)
                     return undefined;
-                if (moduleSourceFile && !isSourceFileFromLibrary(program, moduleSourceFile)) {
+                if (moduleSourceFile && !ts.isSourceFileFromLibrary(program, moduleSourceFile)) {
                     return { kind: InfoKind.Function, token: token, call: parent.parent, sourceFile: moduleSourceFile, modifierFlags: 1 /* ModifierFlags.Export */, parentDeclaration: moduleSourceFile };
                 }
             }
@@ -158549,7 +158676,7 @@ var ts;
                 return undefined;
             // Prefer to change the class instead of the interface if they are merged
             var declaration = classDeclaration || ts.find(symbol.declarations, function (d) { return ts.isInterfaceDeclaration(d) || ts.isTypeLiteralNode(d); });
-            if (declaration && !isSourceFileFromLibrary(program, declaration.getSourceFile())) {
+            if (declaration && !ts.isSourceFileFromLibrary(program, declaration.getSourceFile())) {
                 var makeStatic = !ts.isTypeLiteralNode(declaration) && (leftExpressionType.target || leftExpressionType) !== checker.getDeclaredTypeOfSymbol(symbol);
                 if (makeStatic && (ts.isPrivateIdentifier(token) || ts.isInterfaceDeclaration(declaration)))
                     return undefined;
@@ -158561,14 +158688,11 @@ var ts;
                 return { kind: InfoKind.TypeLikeDeclaration, token: token, call: call, modifierFlags: modifierFlags, parentDeclaration: declaration, declSourceFile: declSourceFile, isJSFile: isJSFile };
             }
             var enumDeclaration = ts.find(symbol.declarations, ts.isEnumDeclaration);
-            if (enumDeclaration && !(leftExpressionType.flags & 1056 /* TypeFlags.EnumLike */) && !ts.isPrivateIdentifier(token) && !isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) {
+            if (enumDeclaration && !(leftExpressionType.flags & 1056 /* TypeFlags.EnumLike */) && !ts.isPrivateIdentifier(token) && !ts.isSourceFileFromLibrary(program, enumDeclaration.getSourceFile())) {
                 return { kind: InfoKind.Enum, token: token, parentDeclaration: enumDeclaration };
             }
             return undefined;
         }
-        function isSourceFileFromLibrary(program, node) {
-            return program.isSourceFileFromExternalLibrary(node) || program.isSourceFileDefaultLibrary(node);
-        }
         function getActionsForMissingMemberDeclaration(context, info) {
             return info.isJSFile ? ts.singleElementArray(createActionForAddMissingMemberInJavascriptFile(context, info)) :
                 createActionsForAddMissingMemberInTypeScriptFile(context, info);
@@ -163994,8 +164118,8 @@ var ts;
                 var i = 0;
                 for (var _i = 0, extractions_1 = extractions; _i < extractions_1.length; _i++) {
                     var _a = extractions_1[_i], functionExtraction = _a.functionExtraction, constantExtraction = _a.constantExtraction;
-                    var description = functionExtraction.description;
                     if (refactor.refactorKindBeginsWith(extractFunctionAction.kind, requestedRefactor)) {
+                        var description = functionExtraction.description;
                         if (functionExtraction.errors.length === 0) {
                             // Don't issue refactorings with duplicated names.
                             // Scopes come back in "innermost first" order, so extractions will
@@ -164019,15 +164143,15 @@ var ts;
                         }
                     }
                     if (refactor.refactorKindBeginsWith(extractConstantAction.kind, requestedRefactor)) {
+                        var description = constantExtraction.description;
                         if (constantExtraction.errors.length === 0) {
                             // Don't issue refactorings with duplicated names.
                             // Scopes come back in "innermost first" order, so extractions will
                             // preferentially go into nearer scopes
-                            var description_1 = constantExtraction.description;
-                            if (!usedConstantNames.has(description_1)) {
-                                usedConstantNames.set(description_1, true);
+                            if (!usedConstantNames.has(description)) {
+                                usedConstantNames.set(description, true);
                                 constantActions.push({
-                                    description: description_1,
+                                    description: description,
                                     name: "constant_scope_".concat(i),
                                     kind: extractConstantAction.kind
                                 });